elixir_script

var Patterns = {
  get default () { return _Patterns; }
};

/* @flow */
function update(map, key, value) {
  let m = new Map(map);
  m.set(key, value);
  return m;
}

function remove(map, key) {
  let m = new Map(map);
  m.delete(key);
  return m;
}

class PostOffice {

  constructor() {
    this.mailboxes = new Map();
    this.subscribers = new Map();
  }

  send(address, message) {
    this.mailboxes = update(this.mailboxes, address, this.mailboxes.get(address).concat([message]));

    if (this.subscribers.get(address)) {
      this.subscribers.get(address)();
    }
  }

  receive(address) {
    let result = this.mailboxes.get(address)[0];

    this.mailboxes = update(this.mailboxes, address, this.mailboxes.get(address).slice(1));
    return result;
  }

  peek(address) {
    return this.mailboxes.get(address)[0];
  }

  add_mailbox(address = Symbol()) {
    this.mailboxes = update(this.mailboxes, address, []);
    return address;
  }

  remove_mailbox(address) {
    this.mailboxes = remove(this.mailboxes, address);
  }

  subscribe(address, subscribtion_fn) {
    this.subscribers = update(this.subscribers, address, subscribtion_fn);
  }

  unsubscribe(address) {
    this.subscribers = remove(this.subscribers, address);
  }
}

let Enum = {

  all__qmark__: function (collection, fun = x => x) {
    return collection.every(fun);
  },

  any__qmark__: function (collection, fun = x => x) {
    return collection.some(fun);
  },

  at: function (collection, n, the_default = null) {
    if (n > this.count(collection) || n < 0) {
      return the_default;
    }

    return collection[n];
  },

  concat: function (...enumables) {
    return enumables[0].concat(enumables[1]);
  },

  count: function (collection, fun = null) {
    if (fun == null) {
      return collection.length;
    } else {
      return collection.filter(fun).length;
    }
  },

  drop: function (collection, count) {
    return collection.slice(count);
  },

  drop_while: function (collection, fun) {
    let count = 0;

    for (let elem of collection) {
      if (fun(elem)) {
        count = count + 1;
      } else {
        break;
      }
    }

    return collection.slice(count);
  },

  each: function (collection, fun) {
    for (let elem of collection) {
      fun(elem);
    }
  },

  empty__qmark__: function (collection) {
    return collection.length === 0;
  },

  fetch: function (collection, n) {
    if (Kernel.is_list(collection)) {
      if (n < this.count(collection) && n >= 0) {
        return Kernel.SpecialForms.tuple(Kernel.SpecialForms.atom("ok"), collection[n]);
      } else {
        return Kernel.SpecialForms.atom("error");
      }
    }

    throw new Error("collection is not an Enumerable");
  },

  fetch__emark__: function (collection, n) {
    if (Kernel.is_list(collection)) {
      if (n < this.count(collection) && n >= 0) {
        return collection[n];
      } else {
        throw new Error("out of bounds error");
      }
    }

    throw new Error("collection is not an Enumerable");
  },

  filter: function (collection, fun) {
    return collection.filter(fun);
  },

  filter_map: function (collection, filter, mapper) {
    return collection.filter(filter).map(mapper);
  },

  find: function (collection, if_none = null, fun) {
    return collection.find(fun, null, if_none);
  },

  into: function (collection, list) {
    return list.concat(collection);
  },

  map: function (collection, fun) {
    return collection.map(fun);
  },

  map_reduce: function (collection, acc, fun) {
    let mapped = Kernel.SpecialForms.list();
    let the_acc = acc;

    for (var i = 0; i < this.count(collection); i++) {
      let tuple = fun(collection[i], the_acc);

      the_acc = Kernel.elem(tuple, 1);
      mapped = Kernel.SpecialForms.list(...mapped.concat([Kernel.elem(tuple, 0)]));
    }

    return Kernel.SpecialForms.tuple(mapped, the_acc);
  },

  member: function (collection, value) {
    return collection.includes(value);
  },

  reduce: function (collection, acc, fun) {
    return collection.reduce(fun, acc);
  },

  take: function (collection, count) {
    return collection.slice(0, count);
  },

  take_every: function (collection, nth) {
    let result = [];
    let index = 0;

    for (let elem of collection) {
      if (index % nth === 0) {
        result.push(elem);
      }
    }

    return Kernel.SpecialForms.list(...result);
  },

  take_while: function (collection, fun) {
    let count = 0;

    for (let elem of collection) {
      if (fun(elem)) {
        count = count + 1;
      } else {
        break;
      }
    }

    return collection.slice(0, count);
  },

  to_list: function (collection) {
    return collection;
  }
};

class BitString {
  constructor(...args) {
    this.raw_value = function () {
      return Object.freeze(args);
    };

    this.value = Object.freeze(this.process(args));
  }

  get(index) {
    return this.value[index];
  }

  count() {
    return this.value.length;
  }

  [Symbol.iterator]() {
    return this.value[Symbol.iterator]();
  }

  toString() {
    var i,
        s = "";
    for (i = 0; i < this.count(); i++) {
      if (s !== "") {
        s += ", ";
      }
      s += this[i].toString();
    }

    return "<<" + s + ">>";
  }

  process() {
    let processed_values = [];

    var i;
    for (i = 0; i < this.raw_value().length; i++) {
      let processed_value = this["process_" + this.raw_value()[i].type](this.raw_value()[i]);

      for (let attr of this.raw_value()[i].attributes) {
        processed_value = this["process_" + attr](processed_value);
      }

      processed_values = processed_values.concat(processed_value);
    }

    return processed_values;
  }

  process_integer(value) {
    return value.value;
  }

  process_float(value) {
    if (value.size === 64) {
      return BitString.float64ToBytes(value.value);
    } else if (value.size === 32) {
      return BitString.float32ToBytes(value.value);
    }

    throw new Error("Invalid size for float");
  }

  process_bitstring(value) {
    return value.value.value;
  }

  process_binary(value) {
    return BitString.toUTF8Array(value.value);
  }

  process_utf8(value) {
    return BitString.toUTF8Array(value.value);
  }

  process_utf16(value) {
    return BitString.toUTF16Array(value.value);
  }

  process_utf32(value) {
    return BitString.toUTF32Array(value.value);
  }

  process_signed(value) {
    return new Uint8Array([value])[0];
  }

  process_unsigned(value) {
    return value;
  }

  process_native(value) {
    return value;
  }

  process_big(value) {
    return value;
  }

  process_little(value) {
    return value.reverse();
  }

  process_size(value) {
    return value;
  }

  process_unit(value) {
    return value;
  }

  static integer(value) {
    return BitString.wrap(value, { "type": "integer", "unit": 1, "size": 8 });
  }

  static float(value) {
    return BitString.wrap(value, { "type": "float", "unit": 1, "size": 64 });
  }

  static bitstring(value) {
    return BitString.wrap(value, { "type": "bitstring", "unit": 1, "size": value.length });
  }

  static bits(value) {
    return BitString.bitstring(value);
  }

  static binary(value) {
    return BitString.wrap(value, { "type": "binary", "unit": 8, "size": value.length });
  }

  static bytes(value) {
    return BitString.binary(value);
  }

  static utf8(value) {
    return BitString.wrap(value, { "type": "utf8" });
  }

  static utf16(value) {
    return BitString.wrap(value, { "type": "utf16" });
  }

  static utf32(value) {
    return BitString.wrap(value, { "type": "utf32" });
  }

  static signed(value) {
    return BitString.wrap(value, {}, "signed");
  }

  static unsigned(value) {
    return BitString.wrap(value, {}, "unsigned");
  }

  static native(value) {
    return BitString.wrap(value, {}, "native");
  }

  static big(value) {
    return BitString.wrap(value, {}, "big");
  }

  static little(value) {
    return BitString.wrap(value, {}, "little");
  }

  static size(value, count) {
    return BitString.wrap(value, { "size": count });
  }

  static unit(value, count) {
    return BitString.wrap(value, { "unit": count });
  }

  static wrap(value, opt, new_attribute = null) {
    let the_value = value;

    if (!(value instanceof Object)) {
      the_value = { "value": value, "attributes": [] };
    }

    the_value = Object.assign(the_value, opt);

    if (new_attribute) {
      the_value.attributes.push(new_attribute);
    }

    return the_value;
  }

  static toUTF8Array(str) {
    var utf8 = [];
    for (var i = 0; i < str.length; i++) {
      var charcode = str.charCodeAt(i);
      if (charcode < 128) {
        utf8.push(charcode);
      } else if (charcode < 2048) {
        utf8.push(192 | charcode >> 6, 128 | charcode & 63);
      } else if (charcode < 55296 || charcode >= 57344) {
        utf8.push(224 | charcode >> 12, 128 | charcode >> 6 & 63, 128 | charcode & 63);
      }
      // surrogate pair
      else {
        i++;
        // UTF-16 encodes 0x10000-0x10FFFF by
        // subtracting 0x10000 and splitting the
        // 20 bits of 0x0-0xFFFFF into two halves
        charcode = 65536 + ((charcode & 1023) << 10 | str.charCodeAt(i) & 1023);
        utf8.push(240 | charcode >> 18, 128 | charcode >> 12 & 63, 128 | charcode >> 6 & 63, 128 | charcode & 63);
      }
    }
    return utf8;
  }

  static toUTF16Array(str) {
    var utf16 = [];
    for (var i = 0; i < str.length; i++) {
      var codePoint = str.codePointAt(i);

      if (codePoint <= 255) {
        utf16.push(0);
        utf16.push(codePoint);
      } else {
        utf16.push(codePoint >> 8 & 255);
        utf16.push(codePoint & 255);
      }
    }
    return utf16;
  }

  static toUTF32Array(str) {
    var utf32 = [];
    for (var i = 0; i < str.length; i++) {
      var codePoint = str.codePointAt(i);

      if (codePoint <= 255) {
        utf32.push(0);
        utf32.push(0);
        utf32.push(0);
        utf32.push(codePoint);
      } else {
        utf32.push(0);
        utf32.push(0);
        utf32.push(codePoint >> 8 & 255);
        utf32.push(codePoint & 255);
      }
    }
    return utf32;
  }

  //http://stackoverflow.com/questions/2003493/javascript-float-from-to-bits
  static float32ToBytes(f) {
    var bytes = [];

    var buf = new ArrayBuffer(4);
    new Float32Array(buf)[0] = f;

    let intVersion = new Uint32Array(buf)[0];

    bytes.push(intVersion >> 24 & 255);
    bytes.push(intVersion >> 16 & 255);
    bytes.push(intVersion >> 8 & 255);
    bytes.push(intVersion & 255);

    return bytes;
  }

  static float64ToBytes(f) {
    var bytes = [];

    var buf = new ArrayBuffer(8);
    new Float64Array(buf)[0] = f;

    var intVersion1 = new Uint32Array(buf)[0];
    var intVersion2 = new Uint32Array(buf)[1];

    bytes.push(intVersion2 >> 24 & 255);
    bytes.push(intVersion2 >> 16 & 255);
    bytes.push(intVersion2 >> 8 & 255);
    bytes.push(intVersion2 & 255);

    bytes.push(intVersion1 >> 24 & 255);
    bytes.push(intVersion1 >> 16 & 255);
    bytes.push(intVersion1 >> 8 & 255);
    bytes.push(intVersion1 & 255);

    return bytes;
  }
}

let SpecialForms = {

  __DIR__: function () {
    if (__dirname) {
      return __dirname;
    }

    if (document.currentScript) {
      return document.currentScript.src;
    }

    return null;
  },

  atom: function (_value) {
    return Symbol.for(_value);
  },

  list: function (...args) {
    return Object.freeze(args);
  },

  bitstring: function (...args) {
    return new BitString(...args);
  },

  bound: function (_var) {
    return Patterns.bound(_var);
  },

  _case: function (condition, clauses) {
    return Patterns.defmatch(...clauses)(condition);
  },

  cond: function (clauses) {
    for (let clause of clauses) {
      if (clause[0]) {
        return clause[1]();
      }
    }

    throw new Error();
  },

  fn: function (clauses) {
    return Patterns.defmatch(clauses);
  },

  map: function (obj) {
    return Object.freeze(obj);
  },

  map_update: function (map, values) {
    let obj = Object.assign({}, map);
    return Object.freeze(Object.assign(obj, values));
  },

  _for: function (collections, fun, filter = () => true, into = [], previousValues = []) {
    let pattern = collections[0][0];
    let collection = collections[0][1];

    if (collections.length === 1) {

      for (let elem of collection) {
        let r = Patterns.match_no_throw(pattern, elem);
        let args = previousValues.concat(r);

        if (r && filter.apply(this, args)) {
          into = Enum.into([fun.apply(this, args)], into);
        }
      }

      return into;
    } else {
      let _into = [];

      for (let elem of collection) {
        let r = Patterns.match_no_throw(pattern, elem);
        if (r) {
          _into = Enum.into(this._for(collections.slice(1), fun, filter, _into, previousValues.concat(r)), into);
        }
      }

      return _into;
    }
  },

  receive: function (receive_fun, timeout_in_ms = null, timeout_fn = time => true) {
    if (timeout_in_ms == null || timeout_in_ms === System.for('infinity')) {
      while (true) {
        if (self.mailbox.length !== 0) {
          let message = self.mailbox[0];
          self.mailbox = self.mailbox.slice(1);
          return receive_fun(message);
        }
      }
    } else if (timeout_in_ms === 0) {
      if (self.mailbox.length !== 0) {
        let message = self.mailbox[0];
        self.mailbox = self.mailbox.slice(1);
        return receive_fun(message);
      } else {
        return null;
      }
    } else {
      let now = Date.now();
      while (Date.now() < now + timeout_in_ms) {
        if (self.mailbox.length !== 0) {
          let message = self.mailbox[0];
          self.mailbox = self.mailbox.slice(1);
          return receive_fun(message);
        }
      }

      return timeout_fn(timeout_in_ms);
    }
  },

  tuple: function (...args) {
    return new Tuple(...args);
  },

  _try: function (do_fun, rescue_function, catch_fun, else_function, after_function) {
    let result = null;

    try {
      result = do_fun();
    } catch (e) {
      let ex_result = null;

      if (rescue_function) {
        try {
          ex_result = rescue_function(e);
          return ex_result;
        } catch (ex) {
          if (ex instanceof Patterns.MatchError) {
            throw ex;
          }
        }
      }

      if (catch_fun) {
        try {
          ex_result = catch_fun(e);
          return ex_result;
        } catch (ex) {
          if (ex instanceof Patterns.MatchError) {
            throw ex;
          }
        }
      }

      throw e;
    } finally {
      if (after_function) {
        after_function();
      }
    }

    if (else_function) {
      try {
        return else_function(result);
      } catch (ex) {
        if (ex instanceof Patterns.MatchError) {
          throw new Error('No Match Found in Else');
        }

        throw ex;
      }
    } else {
      return result;
    }
  }

};

let Kernel = {

  SpecialForms: SpecialForms,

  tl: function (list) {
    return SpecialForms.list(...list.slice(1));
  },

  hd: function (list) {
    return list[0];
  },

  is_nil: function (x) {
    return x == null;
  },

  is_atom: function (x) {
    return typeof x === 'symbol';
  },

  is_binary: function (x) {
    return typeof x === 'string' || x instanceof String;
  },

  is_boolean: function (x) {
    return typeof x === 'boolean' || x instanceof Boolean;
  },

  is_function: function (x, arity = -1) {
    return typeof x === 'function' || x instanceof Function;
  },

  // from: http://stackoverflow.com/a/3885844
  is_float: function (x) {
    return x === +x && x !== (x | 0);
  },

  is_integer: function (x) {
    return x === +x && x === (x | 0);
  },

  is_list: function (x) {
    return x instanceof Array;
  },

  is_map: function (x) {
    return typeof x === 'object' || x instanceof Object;
  },

  is_number: function (x) {
    return Kernel.is_integer(x) || Kernel.is_float(x);
  },

  is_tuple: function (x) {
    return x instanceof Tuple;
  },

  length: function (x) {
    return x.length;
  },

  is_pid: function (x) {
    return false;
  },

  is_port: function (x) {},

  is_reference: function (x) {},

  is_bitstring: function (x) {
    return Kernel.is_binary(x) || x instanceof SpecialForms.bitstring;
  },

  __in__: function (left, right) {
    for (let x of right) {
      if (Kernel.match__qmark__(left, x)) {
        return true;
      }
    }

    return false;
  },

  abs: function (number) {
    return Math.abs(number);
  },

  round: function (number) {
    return Math.round(number);
  },

  elem: function (tuple, index) {
    if (Kernel.is_list(tuple)) {
      return tuple[index];
    }

    return tuple.get(index);
  },

  rem: function (left, right) {
    return left % right;
  },

  div: function (left, right) {
    return left / right;
  },

  and: function (left, right) {
    return left && right;
  },

  or: function (left, right) {
    return left || right;
  },

  not: function (arg) {
    return !arg;
  },

  apply: function (module, func, args) {
    if (arguments.length === 3) {
      return module[func].apply(null, args);
    } else {
      return module.apply(null, func);
    }
  },

  to_string: function (arg) {
    if (Kernel.is_tuple(arg)) {
      return Tuple.to_string(arg);
    }

    return arg.toString();
  },

  throw: function (e) {
    throw e;
  },

  match__qmark__: function (pattern, expr, guard = () => true) {
    return _Patterns.match_no_throw(pattern, expr, guard) != null;
  }
};

class Tuple {

  constructor(...args) {
    this.values = Object.freeze(args);
  }

  get(index) {
    return this.values[index];
  }

  count() {
    return this.values.length;
  }

  [Symbol.iterator]() {
    return this.values[Symbol.iterator]();
  }

  toString() {
    var i,
        s = "";
    for (i = 0; i < this.values.length; i++) {
      if (s !== "") {
        s += ", ";
      }
      s += this.values[i].toString();
    }

    return "{" + s + "}";
  }

  static to_string(tuple) {
    return tuple.toString();
  }

  static delete_at(tuple, index) {
    let new_list = [];

    for (var i = 0; i < tuple.count(); i++) {
      if (i !== index) {
        new_list.push(tuple.get(i));
      }
    }

    return Kernel.SpecialForms.tuple.apply(null, new_list);
  }

  static duplicate(data, size) {
    let array = [];

    for (var i = size - 1; i >= 0; i--) {
      array.push(data);
    }

    return Kernel.SpecialForms.tuple.apply(null, array);
  }

  static insert_at(tuple, index, term) {
    let new_tuple = [];

    for (var i = 0; i <= tuple.count(); i++) {
      if (i === index) {
        new_tuple.push(term);
        i++;
        new_tuple.push(tuple.get(i));
      } else {
        new_tuple.push(tuple.get(i));
      }
    }

    return Kernel.SpecialForms.tuple.apply(null, new_tuple);
  }

  static from_list(list) {
    return Kernel.SpecialForms.tuple.apply(null, list);
  }

  static to_list(tuple) {
    let new_list = [];

    for (var i = 0; i < tuple.count(); i++) {
      new_list.push(tuple.get(i));
    }

    return Kernel.SpecialForms.list(...new_list);
  }
}

/* @flow */

class Variable {

  constructor(name = null) {
    this.name = name;
  }
}

class Wildcard {
  constructor() {}
}

class StartsWith {

  constructor(prefix) {
    this.prefix = prefix;
  }
}

class Capture {

  constructor(value) {
    this.value = value;
  }
}

class HeadTail {
  constructor() {}
}

class Type {

  constructor(type, objPattern = {}) {
    this.type = type;
    this.objPattern = objPattern;
  }
}

class Bound {

  constructor(value) {
    this.value = value;
  }
}

function variable(name = null) {
  return new Variable(name);
}

function wildcard() {
  return new Wildcard();
}

function startsWith(prefix) {
  return new StartsWith(prefix);
}

function capture(value) {
  return new Capture(value);
}

function headTail() {
  return new HeadTail();
}

function type(type, objPattern = {}) {
  return new Type(type, objPattern);
}

function bound(value) {
  return new Bound(value);
}

function is_number(value) {
  return typeof value === 'number';
}

function is_string(value) {
  return typeof value === 'string';
}

function is_tuple(value) {
  return value instanceof Tuple;
}

function is_boolean(value) {
  return typeof value === 'boolean';
}

function is_symbol(value) {
  return typeof value === 'symbol';
}

function is_null(value) {
  return value === null;
}

function is_undefined(value) {
  return typeof value === 'undefined';
}

function is_function(value) {
  return Object.prototype.toString.call(value) == '[object Function]';
}

function is_variable(value) {
  return value instanceof Variable;
}

function is_wildcard(value) {
  return value instanceof Wildcard;
}

function is_headTail(value) {
  return value instanceof HeadTail;
}

function is_capture(value) {
  return value instanceof Capture;
}

function is_type(value) {
  return value instanceof Type;
}

function is_startsWith(value) {
  return value instanceof StartsWith;
}

function is_bound(value) {
  return value instanceof Bound;
}

function is_object(value) {
  return typeof value === 'object';
}

function is_array(value) {
  return Array.isArray(value);
}

var Checks = {
  is_number,
  is_string,
  is_boolean,
  is_symbol,
  is_null,
  is_undefined,
  is_function,
  is_variable,
  is_wildcard,
  is_headTail,
  is_capture,
  is_type,
  is_startsWith,
  is_bound,
  is_object,
  is_array,
  is_tuple
};

function resolveTuple(pattern) {
  let matches = [];

  for (let elem of pattern) {
    matches.push(buildMatch(elem));
  }

  return function (value, args) {
    if (!Checks.is_tuple(value) || value.count() != pattern.count()) {
      return false;
    }

    return value.values.every(function (v, i) {
      return matches[i](value.get(i), args);
    });
  };
}

function resolveSymbol(pattern) {
  return function (value) {
    return Checks.is_symbol(value) && value === pattern;
  };
}

function resolveString(pattern) {
  return function (value) {
    return Checks.is_string(value) && value === pattern;
  };
}

function resolveNumber(pattern) {
  return function (value) {
    return Checks.is_number(value) && value === pattern;
  };
}

function resolveBoolean(pattern) {
  return function (value) {
    return Checks.is_boolean(value) && value === pattern;
  };
}

function resolveFunction(pattern) {
  return function (value) {
    return Checks.is_function(value) && value === pattern;
  };
}

function resolveNull(pattern) {
  return function (value) {
    return Checks.is_null(value);
  };
}

function resolveBound(pattern) {
  return function (value, args) {
    if (typeof value === typeof pattern.value && value === pattern.value) {
      args.push(value);
      return true;
    }

    return false;
  };
}

function resolveWildcard() {
  return function () {
    return true;
  };
}

function resolveVariable() {
  return function (value, args) {
    args.push(value);
    return true;
  };
}

function resolveHeadTail() {
  return function (value, args) {
    if (!Checks.is_array(value) || value.length < 2) {
      return false;
    }

    const head = value[0];
    const tail = value.slice(1);

    args.push(head);
    args.push(tail);

    return true;
  };
}

function resolveCapture(pattern) {
  const matches = buildMatch(pattern.value);

  return function (value, args) {
    if (matches(value, args)) {
      args.push(value);
      return true;
    }

    return false;
  };
}

function resolveStartsWith(pattern) {
  const prefix = pattern.prefix;

  return function (value, args) {
    if (Checks.is_string(value) && value.startsWith(prefix)) {
      args.push(value.substring(prefix.length));
      return true;
    }

    return false;
  };
}

function resolveType(pattern) {
  return function (value, args) {
    if (!value instanceof pattern.type) {
      return false;
    }

    const matches = buildMatch(pattern.objPattern);
    return matches(value, args) && args.push(value) > 0;
  };
}

function resolveArray(pattern) {
  const matches = pattern.map(x => buildMatch(x));

  return function (value, args) {
    if (!Checks.is_array(value) || value.length != pattern.length) {
      return false;
    }

    return value.every(function (v, i) {
      return matches[i](value[i], args);
    });
  };
}

function resolveObject(pattern) {
  let matches = {};

  for (let key of Object.keys(pattern)) {
    matches[key] = buildMatch(pattern[key]);
  }

  return function (value, args) {
    if (!Checks.is_object(value) || pattern.length > value.length) {
      return false;
    }

    for (let key of Object.keys(pattern)) {
      if (!(key in value) || !matches[key](value[key], args)) {
        return false;
      }
    }

    return true;
  };
}

function resolveNoMatch() {
  return function () {
    return false;
  };
}

var Resolvers = {
  resolveBound,
  resolveWildcard,
  resolveVariable,
  resolveHeadTail,
  resolveCapture,
  resolveStartsWith,
  resolveType,
  resolveArray,
  resolveObject,
  resolveNoMatch,
  resolveSymbol,
  resolveString,
  resolveNumber,
  resolveBoolean,
  resolveFunction,
  resolveNull,
  resolveTuple
};

function buildMatch(pattern) {

  if (Checks.is_tuple(pattern)) {
    return Resolvers.resolveTuple(pattern);
  }

  if (Checks.is_variable(pattern)) {
    return Resolvers.resolveVariable(pattern);
  }

  if (Checks.is_wildcard(pattern)) {
    return Resolvers.resolveWildcard(pattern);
  }

  if (Checks.is_undefined(pattern)) {
    return Resolvers.resolveWildcard(pattern);
  }

  if (Checks.is_headTail(pattern)) {
    return Resolvers.resolveHeadTail(pattern);
  }

  if (Checks.is_startsWith(pattern)) {
    return Resolvers.resolveStartsWith(pattern);
  }

  if (Checks.is_capture(pattern)) {
    return Resolvers.resolveCapture(pattern);
  }

  if (Checks.is_bound(pattern)) {
    return Resolvers.resolveBound(pattern);
  }

  if (Checks.is_type(pattern)) {
    return Resolvers.resolveType(pattern);
  }

  if (Checks.is_array(pattern)) {
    return Resolvers.resolveArray(pattern);
  }

  if (Checks.is_number(pattern)) {
    return Resolvers.resolveNumber(pattern);
  }

  if (Checks.is_string(pattern)) {
    return Resolvers.resolveString(pattern);
  }

  if (Checks.is_boolean(pattern)) {
    return Resolvers.resolveBoolean(pattern);
  }

  if (Checks.is_symbol(pattern)) {
    return Resolvers.resolveSymbol(pattern);
  }

  if (Checks.is_null(pattern)) {
    return Resolvers.resolveNull(pattern);
  }

  if (Checks.is_object(pattern)) {
    return Resolvers.resolveObject(pattern);
  }

  return Resolvers.resolveNoMatch();
}

class MatchError extends Error {
  constructor(arg) {
    super();

    if (typeof arg === 'symbol') {
      this.message = 'No match for: ' + arg.toString();
    } else {
      this.message = 'No match for: ' + arg;
    }

    this.stack = new Error().stack;
    this.name = this.constructor.name;
  }
}

class Case {

  constructor(pattern, fn, guard = () => true) {
    this.pattern = buildMatch(pattern);
    this.fn = fn;
    this.guard = guard;
  }
}

function make_case(pattern, fn, guard = () => true) {
  return new Case(pattern, fn, guard);
}

function defmatch(...cases) {
  return function (...args) {
    for (let processedCase of cases) {
      let result = [];
      if (processedCase.pattern(args, result) && processedCase.guard.apply(this, result)) {
        return processedCase.fn.apply(this, result);
      }
    }

    throw new MatchError(args);
  };
}

function match(pattern, expr, guard = () => true) {
  let result = [];
  let processedPattern = buildMatch(pattern);
  if (processedPattern(expr, result) && guard.apply(this, result)) {
    return result;
  } else {
    throw new MatchError(expr);
  }
}

function match_no_throw(pattern, expr, guard = () => true) {
  try {
    return match(pattern, expr, guard);
  } catch (e) {
    if (e instanceof MatchError) {
      return null;
    }

    throw e;
  }
}

function patternMap(collection, pattern, fun, guard = () => true) {
  let ret = [];

  for (let elem of collection) {
    try {
      let result = fun.apply(this, match(pattern, elem, guard));
      ret = ret.concat(result);
    } catch (e) {
      if (!(e instanceof MatchError)) {
        throw e;
      }
    }
  }

  return ret;
}

var _Patterns = {
  defmatch, match, MatchError, match_no_throw, patternMap,
  variable, wildcard, startsWith,
  capture, headTail, type, bound, Case, make_case
};

let Atom = {};

Atom.to_string = function (atom) {
  return Symbol.keyFor(atom);
};

Atom.to_char_list = function (atom) {
  return Atom.to_string(atom).split('');
};

let Integer = {

  is_even: function (n) {
    return n % 2 === 0;
  },

  is_odd: function (n) {
    return n % 2 !== 0;
  },

  parse: function (bin) {
    let result = parseInt(bin);

    if (isNaN(result)) {
      return Kernel.SpecialForms.atom("error");
    }

    let indexOfDot = bin.indexOf(".");

    if (indexOfDot >= 0) {
      return Kernel.SpecialForms.tuple(result, bin.substring(indexOfDot));
    }

    return Kernel.SpecialForms.tuple(result, "");
  },

  to_char_list: function (number, base = 10) {
    return number.toString(base).split("");
  },

  to_string: function (number, base = 10) {
    return number.toString(base);
  }
};

let JS = {
  get_property_or_call_function: function (item, property) {
    if (item[property] instanceof Function) {
      return item[property]();
    } else {
      return item[property];
    }
  }
};

let List = {};

List.delete = function (list, item) {
  let new_value = [];
  let value_found = false;

  for (let x of list) {
    if (x === item && value_found !== false) {
      new_value.push(x);
      value_found = true;
    } else if (x !== item) {
      new_value.push(x);
    }
  }

  return Kernel.SpecialForms.list(...new_value);
};

List.delete_at = function (list, index) {
  let new_value = [];

  for (let i = 0; i < list.length; i++) {
    if (i !== index) {
      new_value.push(list[i]);
    }
  }

  return Kernel.SpecialForms.list(...new_value);
};

List.duplicate = function (elem, n) {
  let new_value = [];

  for (var i = 0; i < n; i++) {
    new_value.push(elem);
  }

  return Kernel.SpecialForms.list(...new_value);
};

List.first = function (list) {
  return list[0];
};

List.flatten = function (list, tail = Kernel.SpecialForms.list()) {
  let new_value = [];

  for (let x of list) {
    if (Kernel.is_list(x)) {
      new_value = new_value.concat(List.flatten(x));
    } else {
      new_value.push(x);
    }
  }

  new_value = new_value.concat(tail);

  return Kernel.SpecialForms.list(...new_value);
};

List.foldl = function (list, acc, func) {
  return list.reduce(func, acc);
};

List.foldr = function (list, acc, func) {
  let new_acc = acc;

  for (var i = list.length - 1; i >= 0; i--) {
    new_acc = func(list[i], new_acc);
  }

  return new_acc;
};

List.insert_at = function (list, index, value) {
  let new_value = [];

  for (let i = 0; i < list.length; i++) {
    if (i === index) {
      new_value.push(value);
      new_value.push(list[i]);
    } else {
      new_value.push(list[i]);
    }
  }

  return Kernel.SpecialForms.list(...new_value);
};

List.keydelete = function (list, key, position) {
  let new_list = [];

  for (let i = 0; i < list.length; i++) {
    if (!Kernel.match__qmark__(list[i][position], key)) {
      new_list.push(list[i]);
    }
  }

  return Kernel.SpecialForms.list(...new_list);
};

List.keyfind = function (list, key, position, _default = null) {

  for (let i = 0; i < list.length; i++) {
    if (Kernel.match__qmark__(list[i][position], key)) {
      return list[i];
    }
  }

  return _default;
};

List.keymember__qmark__ = function (list, key, position) {

  for (let i = 0; i < list.length; i++) {
    if (Kernel.match__qmark__(list[i][position], key)) {
      return true;
    }
  }

  return false;
};

List.keyreplace = function (list, key, position, new_tuple) {
  let new_list = [];

  for (let i = 0; i < list.length; i++) {
    if (!Kernel.match__qmark__(list[i][position], key)) {
      new_list.push(list[i]);
    } else {
      new_list.push(new_tuple);
    }
  }

  return Kernel.SpecialForms.list(...new_list);
};

List.keysort = function (list, position) {
  let new_list = list;

  new_list.sort(function (a, b) {
    if (position === 0) {
      if (a[position].value < b[position].value) {
        return -1;
      }

      if (a[position].value > b[position].value) {
        return 1;
      }

      return 0;
    } else {
      if (a[position] < b[position]) {
        return -1;
      }

      if (a[position] > b[position]) {
        return 1;
      }

      return 0;
    }
  });

  return Kernel.SpecialForms.list(...new_list);
};

List.keystore = function (list, key, position, new_tuple) {
  let new_list = [];
  let replaced = false;

  for (let i = 0; i < list.length; i++) {
    if (!Kernel.match__qmark__(list[i][position], key)) {
      new_list.push(list[i]);
    } else {
      new_list.push(new_tuple);
      replaced = true;
    }
  }

  if (!replaced) {
    new_list.push(new_tuple);
  }

  return Kernel.SpecialForms.list(...new_list);
};

List.last = function (list) {
  return list[list.length - 1];
};

List.replace_at = function (list, index, value) {
  let new_value = [];

  for (let i = 0; i < list.length; i++) {
    if (i === index) {
      new_value.push(value);
    } else {
      new_value.push(list[i]);
    }
  }

  return Kernel.SpecialForms.list(...new_value);
};

List.update_at = function (list, index, fun) {
  let new_value = [];

  for (let i = 0; i < list.count(); i++) {
    if (i === index) {
      new_value.push(fun(list.get(i)));
    } else {
      new_value.push(list.get(i));
    }
  }

  return new_value;
};

List.wrap = function (list) {
  if (Kernel.is_list(list)) {
    return list;
  } else if (list == null) {
    return Kernel.SpecialForms.list();
  } else {
    return Kernel.SpecialForms.list(list);
  }
};

List.zip = function (list_of_lists) {
  if (list_of_lists.length === 0) {
    return Kernel.SpecialForms.list();
  }

  let new_value = [];
  let smallest_length = list_of_lists[0];

  for (let x of list_of_lists) {
    if (x.length < smallest_length) {
      smallest_length = x.length;
    }
  }

  for (let i = 0; i < smallest_length; i++) {
    let current_value = [];
    for (let j = 0; j < list_of_lists.length; j++) {
      current_value.push(list_of_lists[j][i]);
    }

    new_value.push(Kernel.SpecialForms.tuple(...current_value));
  }

  return Kernel.SpecialForms.list(...new_value);
};

List.to_tuple = function (list) {
  return Kernel.SpecialForms.tuple.apply(null, list);
};

List.append = function (list, value) {
  return Kernel.SpecialForms.list(...list.concat([value]));
};

List.concat = function (left, right) {
  return left.concat(right);
};

let Range = function (_first, _last) {
  if (!(this instanceof Range)) {
    return new Range(_first, _last);
  }

  this.first = function () {
    return _first;
  };

  this.last = function () {
    return _last;
  };

  let _range = [];

  for (let i = _first; i <= _last; i++) {
    _range.push(i);
  }

  _range = Object.freeze(_range);

  this.value = function () {
    return _range;
  };

  this.length = function () {
    return _range.length;
  };

  return this;
};

Range.prototype[Symbol.iterator] = function () {
  return this.value()[Symbol.iterator]();
};

Range.new = function (first, last) {
  return Range(first, last);
};

Range.range__qmark__ = function (range) {
  return range instanceof Range;
};

let Keyword = {};

Keyword.has_key__qm__ = function (keywords, key) {
  for (let keyword of keywords) {
    if (Kernel.elem(keyword, 0) == key) {
      return true;
    }
  }

  return false;
};

Keyword.get = function (keywords, key, the_default = null) {
  for (let keyword of keywords) {
    if (Kernel.elem(keyword, 0) == key) {
      return Kernel.elem(keyword, 1);
    }
  }

  return the_default;
};

let Agent = {};

Agent.start = function (fun, options = []) {
  const name = Keyword.has_key__qm__(options, Kernel.SpecialForms.atom('name')) ? Keyword.get(options, Kernel.SpecialForms.atom('name')) : Symbol();

  self.post_office.add_mailbox(name);
  self.post_office.send(name, fun());

  return Kernel.SpecialForms.tuple(Kernel.SpecialForms.atom('ok'), name);
};

Agent.stop = function (agent, timeout = 5000) {
  self.post_office.remove_mailbox(agent);
  return Kernel.SpecialForms.atom('ok');
};

Agent.update = function (agent, fun, timeout = 5000) {

  const current_state = self.post_office.receive(agent);
  self.post_office.send(agent, fun(current_state));

  return Kernel.SpecialForms.atom('ok');
};

Agent.get = function (agent, fun, timeout = 5000) {
  return fun(self.post_office.peek(agent));
};

Agent.get_and_update = function (agent, fun, timeout = 5000) {

  const get_and_update_tuple = fun(self.post_office.receive(agent));
  self.post_office.send(agent, Kernel.elem(get_and_update_tuple, 1));

  return Kernel.elem(get_and_update_tuple, 0);
};

self.post_office = self.post_office || new PostOffice();

export { _Patterns as Patterns, BitString, Kernel, Atom, Enum, Integer, JS, List, Range, Tuple, Agent, Keyword };
//# sourceMappingURL=data:application/json;base64,{"version":3,"names":[],"mappings":"","sources":["elixir.js"],"sourcesContent":["var Patterns = {\n  get default () { return _Patterns; }\n};\n\n/* @flow */\nfunction update(map, key, value) {\n  let m = new Map(map);\n  m.set(key, value);\n  return m;\n}\n\nfunction remove(map, key) {\n  let m = new Map(map);\n  m.delete(key);\n  return m;\n}\n\nclass PostOffice {\n\n  constructor() {\n    this.mailboxes = new Map();\n    this.subscribers = new Map();\n  }\n\n  send(address, message) {\n    this.mailboxes = update(this.mailboxes, address, this.mailboxes.get(address).concat([message]));\n\n    if (this.subscribers.get(address)) {\n      this.subscribers.get(address)();\n    }\n  }\n\n  receive(address) {\n    let result = this.mailboxes.get(address)[0];\n\n    this.mailboxes = update(this.mailboxes, address, this.mailboxes.get(address).slice(1));\n    return result;\n  }\n\n  peek(address) {\n    return this.mailboxes.get(address)[0];\n  }\n\n  add_mailbox(address = Symbol()) {\n    this.mailboxes = update(this.mailboxes, address, []);\n    return address;\n  }\n\n  remove_mailbox(address) {\n    this.mailboxes = remove(this.mailboxes, address);\n  }\n\n  subscribe(address, subscribtion_fn) {\n    this.subscribers = update(this.subscribers, address, subscribtion_fn);\n  }\n\n  unsubscribe(address) {\n    this.subscribers = remove(this.subscribers, address);\n  }\n}\n\nlet Enum = {\n\n  all__qmark__: function (collection, fun = x => x) {\n    return collection.every(fun);\n  },\n\n  any__qmark__: function (collection, fun = x => x) {\n    return collection.some(fun);\n  },\n\n  at: function (collection, n, the_default = null) {\n    if (n > this.count(collection) || n < 0) {\n      return the_default;\n    }\n\n    return collection[n];\n  },\n\n  concat: function (...enumables) {\n    return enumables[0].concat(enumables[1]);\n  },\n\n  count: function (collection, fun = null) {\n    if (fun == null) {\n      return collection.length;\n    } else {\n      return collection.filter(fun).length;\n    }\n  },\n\n  drop: function (collection, count) {\n    return collection.slice(count);\n  },\n\n  drop_while: function (collection, fun) {\n    let count = 0;\n\n    for (let elem of collection) {\n      if (fun(elem)) {\n        count = count + 1;\n      } else {\n        break;\n      }\n    }\n\n    return collection.slice(count);\n  },\n\n  each: function (collection, fun) {\n    for (let elem of collection) {\n      fun(elem);\n    }\n  },\n\n  empty__qmark__: function (collection) {\n    return collection.length === 0;\n  },\n\n  fetch: function (collection, n) {\n    if (Kernel.is_list(collection)) {\n      if (n < this.count(collection) && n >= 0) {\n        return Kernel.SpecialForms.tuple(Kernel.SpecialForms.atom(\"ok\"), collection[n]);\n      } else {\n        return Kernel.SpecialForms.atom(\"error\");\n      }\n    }\n\n    throw new Error(\"collection is not an Enumerable\");\n  },\n\n  fetch__emark__: function (collection, n) {\n    if (Kernel.is_list(collection)) {\n      if (n < this.count(collection) && n >= 0) {\n        return collection[n];\n      } else {\n        throw new Error(\"out of bounds error\");\n      }\n    }\n\n    throw new Error(\"collection is not an Enumerable\");\n  },\n\n  filter: function (collection, fun) {\n    return collection.filter(fun);\n  },\n\n  filter_map: function (collection, filter, mapper) {\n    return collection.filter(filter).map(mapper);\n  },\n\n  find: function (collection, if_none = null, fun) {\n    return collection.find(fun, null, if_none);\n  },\n\n  into: function (collection, list) {\n    return list.concat(collection);\n  },\n\n  map: function (collection, fun) {\n    return collection.map(fun);\n  },\n\n  map_reduce: function (collection, acc, fun) {\n    let mapped = Kernel.SpecialForms.list();\n    let the_acc = acc;\n\n    for (var i = 0; i < this.count(collection); i++) {\n      let tuple = fun(collection[i], the_acc);\n\n      the_acc = Kernel.elem(tuple, 1);\n      mapped = Kernel.SpecialForms.list(...mapped.concat([Kernel.elem(tuple, 0)]));\n    }\n\n    return Kernel.SpecialForms.tuple(mapped, the_acc);\n  },\n\n  member: function (collection, value) {\n    return collection.includes(value);\n  },\n\n  reduce: function (collection, acc, fun) {\n    return collection.reduce(fun, acc);\n  },\n\n  take: function (collection, count) {\n    return collection.slice(0, count);\n  },\n\n  take_every: function (collection, nth) {\n    let result = [];\n    let index = 0;\n\n    for (let elem of collection) {\n      if (index % nth === 0) {\n        result.push(elem);\n      }\n    }\n\n    return Kernel.SpecialForms.list(...result);\n  },\n\n  take_while: function (collection, fun) {\n    let count = 0;\n\n    for (let elem of collection) {\n      if (fun(elem)) {\n        count = count + 1;\n      } else {\n        break;\n      }\n    }\n\n    return collection.slice(0, count);\n  },\n\n  to_list: function (collection) {\n    return collection;\n  }\n};\n\nclass BitString {\n  constructor(...args) {\n    this.raw_value = function () {\n      return Object.freeze(args);\n    };\n\n    this.value = Object.freeze(this.process(args));\n  }\n\n  get(index) {\n    return this.value[index];\n  }\n\n  count() {\n    return this.value.length;\n  }\n\n  [Symbol.iterator]() {\n    return this.value[Symbol.iterator]();\n  }\n\n  toString() {\n    var i,\n        s = \"\";\n    for (i = 0; i < this.count(); i++) {\n      if (s !== \"\") {\n        s += \", \";\n      }\n      s += this[i].toString();\n    }\n\n    return \"<<\" + s + \">>\";\n  }\n\n  process() {\n    let processed_values = [];\n\n    var i;\n    for (i = 0; i < this.raw_value().length; i++) {\n      let processed_value = this[\"process_\" + this.raw_value()[i].type](this.raw_value()[i]);\n\n      for (let attr of this.raw_value()[i].attributes) {\n        processed_value = this[\"process_\" + attr](processed_value);\n      }\n\n      processed_values = processed_values.concat(processed_value);\n    }\n\n    return processed_values;\n  }\n\n  process_integer(value) {\n    return value.value;\n  }\n\n  process_float(value) {\n    if (value.size === 64) {\n      return BitString.float64ToBytes(value.value);\n    } else if (value.size === 32) {\n      return BitString.float32ToBytes(value.value);\n    }\n\n    throw new Error(\"Invalid size for float\");\n  }\n\n  process_bitstring(value) {\n    return value.value.value;\n  }\n\n  process_binary(value) {\n    return BitString.toUTF8Array(value.value);\n  }\n\n  process_utf8(value) {\n    return BitString.toUTF8Array(value.value);\n  }\n\n  process_utf16(value) {\n    return BitString.toUTF16Array(value.value);\n  }\n\n  process_utf32(value) {\n    return BitString.toUTF32Array(value.value);\n  }\n\n  process_signed(value) {\n    return new Uint8Array([value])[0];\n  }\n\n  process_unsigned(value) {\n    return value;\n  }\n\n  process_native(value) {\n    return value;\n  }\n\n  process_big(value) {\n    return value;\n  }\n\n  process_little(value) {\n    return value.reverse();\n  }\n\n  process_size(value) {\n    return value;\n  }\n\n  process_unit(value) {\n    return value;\n  }\n\n  static integer(value) {\n    return BitString.wrap(value, { \"type\": \"integer\", \"unit\": 1, \"size\": 8 });\n  }\n\n  static float(value) {\n    return BitString.wrap(value, { \"type\": \"float\", \"unit\": 1, \"size\": 64 });\n  }\n\n  static bitstring(value) {\n    return BitString.wrap(value, { \"type\": \"bitstring\", \"unit\": 1, \"size\": value.length });\n  }\n\n  static bits(value) {\n    return BitString.bitstring(value);\n  }\n\n  static binary(value) {\n    return BitString.wrap(value, { \"type\": \"binary\", \"unit\": 8, \"size\": value.length });\n  }\n\n  static bytes(value) {\n    return BitString.binary(value);\n  }\n\n  static utf8(value) {\n    return BitString.wrap(value, { \"type\": \"utf8\" });\n  }\n\n  static utf16(value) {\n    return BitString.wrap(value, { \"type\": \"utf16\" });\n  }\n\n  static utf32(value) {\n    return BitString.wrap(value, { \"type\": \"utf32\" });\n  }\n\n  static signed(value) {\n    return BitString.wrap(value, {}, \"signed\");\n  }\n\n  static unsigned(value) {\n    return BitString.wrap(value, {}, \"unsigned\");\n  }\n\n  static native(value) {\n    return BitString.wrap(value, {}, \"native\");\n  }\n\n  static big(value) {\n    return BitString.wrap(value, {}, \"big\");\n  }\n\n  static little(value) {\n    return BitString.wrap(value, {}, \"little\");\n  }\n\n  static size(value, count) {\n    return BitString.wrap(value, { \"size\": count });\n  }\n\n  static unit(value, count) {\n    return BitString.wrap(value, { \"unit\": count });\n  }\n\n  static wrap(value, opt, new_attribute = null) {\n    let the_value = value;\n\n    if (!(value instanceof Object)) {\n      the_value = { \"value\": value, \"attributes\": [] };\n    }\n\n    the_value = Object.assign(the_value, opt);\n\n    if (new_attribute) {\n      the_value.attributes.push(new_attribute);\n    }\n\n    return the_value;\n  }\n\n  static toUTF8Array(str) {\n    var utf8 = [];\n    for (var i = 0; i < str.length; i++) {\n      var charcode = str.charCodeAt(i);\n      if (charcode < 128) {\n        utf8.push(charcode);\n      } else if (charcode < 2048) {\n        utf8.push(192 | charcode >> 6, 128 | charcode & 63);\n      } else if (charcode < 55296 || charcode >= 57344) {\n        utf8.push(224 | charcode >> 12, 128 | charcode >> 6 & 63, 128 | charcode & 63);\n      }\n      // surrogate pair\n      else {\n        i++;\n        // UTF-16 encodes 0x10000-0x10FFFF by\n        // subtracting 0x10000 and splitting the\n        // 20 bits of 0x0-0xFFFFF into two halves\n        charcode = 65536 + ((charcode & 1023) << 10 | str.charCodeAt(i) & 1023);\n        utf8.push(240 | charcode >> 18, 128 | charcode >> 12 & 63, 128 | charcode >> 6 & 63, 128 | charcode & 63);\n      }\n    }\n    return utf8;\n  }\n\n  static toUTF16Array(str) {\n    var utf16 = [];\n    for (var i = 0; i < str.length; i++) {\n      var codePoint = str.codePointAt(i);\n\n      if (codePoint <= 255) {\n        utf16.push(0);\n        utf16.push(codePoint);\n      } else {\n        utf16.push(codePoint >> 8 & 255);\n        utf16.push(codePoint & 255);\n      }\n    }\n    return utf16;\n  }\n\n  static toUTF32Array(str) {\n    var utf32 = [];\n    for (var i = 0; i < str.length; i++) {\n      var codePoint = str.codePointAt(i);\n\n      if (codePoint <= 255) {\n        utf32.push(0);\n        utf32.push(0);\n        utf32.push(0);\n        utf32.push(codePoint);\n      } else {\n        utf32.push(0);\n        utf32.push(0);\n        utf32.push(codePoint >> 8 & 255);\n        utf32.push(codePoint & 255);\n      }\n    }\n    return utf32;\n  }\n\n  //http://stackoverflow.com/questions/2003493/javascript-float-from-to-bits\n  static float32ToBytes(f) {\n    var bytes = [];\n\n    var buf = new ArrayBuffer(4);\n    new Float32Array(buf)[0] = f;\n\n    let intVersion = new Uint32Array(buf)[0];\n\n    bytes.push(intVersion >> 24 & 255);\n    bytes.push(intVersion >> 16 & 255);\n    bytes.push(intVersion >> 8 & 255);\n    bytes.push(intVersion & 255);\n\n    return bytes;\n  }\n\n  static float64ToBytes(f) {\n    var bytes = [];\n\n    var buf = new ArrayBuffer(8);\n    new Float64Array(buf)[0] = f;\n\n    var intVersion1 = new Uint32Array(buf)[0];\n    var intVersion2 = new Uint32Array(buf)[1];\n\n    bytes.push(intVersion2 >> 24 & 255);\n    bytes.push(intVersion2 >> 16 & 255);\n    bytes.push(intVersion2 >> 8 & 255);\n    bytes.push(intVersion2 & 255);\n\n    bytes.push(intVersion1 >> 24 & 255);\n    bytes.push(intVersion1 >> 16 & 255);\n    bytes.push(intVersion1 >> 8 & 255);\n    bytes.push(intVersion1 & 255);\n\n    return bytes;\n  }\n}\n\nlet SpecialForms = {\n\n  __DIR__: function () {\n    if (__dirname) {\n      return __dirname;\n    }\n\n    if (document.currentScript) {\n      return document.currentScript.src;\n    }\n\n    return null;\n  },\n\n  atom: function (_value) {\n    return Symbol.for(_value);\n  },\n\n  list: function (...args) {\n    return Object.freeze(args);\n  },\n\n  bitstring: function (...args) {\n    return new BitString(...args);\n  },\n\n  bound: function (_var) {\n    return Patterns.bound(_var);\n  },\n\n  _case: function (condition, clauses) {\n    return Patterns.defmatch(...clauses)(condition);\n  },\n\n  cond: function (clauses) {\n    for (let clause of clauses) {\n      if (clause[0]) {\n        return clause[1]();\n      }\n    }\n\n    throw new Error();\n  },\n\n  fn: function (clauses) {\n    return Patterns.defmatch(clauses);\n  },\n\n  map: function (obj) {\n    return Object.freeze(obj);\n  },\n\n  map_update: function (map, values) {\n    let obj = Object.assign({}, map);\n    return Object.freeze(Object.assign(obj, values));\n  },\n\n  _for: function (collections, fun, filter = () => true, into = [], previousValues = []) {\n    let pattern = collections[0][0];\n    let collection = collections[0][1];\n\n    if (collections.length === 1) {\n\n      for (let elem of collection) {\n        let r = Patterns.match_no_throw(pattern, elem);\n        let args = previousValues.concat(r);\n\n        if (r && filter.apply(this, args)) {\n          into = Enum.into([fun.apply(this, args)], into);\n        }\n      }\n\n      return into;\n    } else {\n      let _into = [];\n\n      for (let elem of collection) {\n        let r = Patterns.match_no_throw(pattern, elem);\n        if (r) {\n          _into = Enum.into(this._for(collections.slice(1), fun, filter, _into, previousValues.concat(r)), into);\n        }\n      }\n\n      return _into;\n    }\n  },\n\n  receive: function (receive_fun, timeout_in_ms = null, timeout_fn = time => true) {\n    if (timeout_in_ms == null || timeout_in_ms === System.for('infinity')) {\n      while (true) {\n        if (self.mailbox.length !== 0) {\n          let message = self.mailbox[0];\n          self.mailbox = self.mailbox.slice(1);\n          return receive_fun(message);\n        }\n      }\n    } else if (timeout_in_ms === 0) {\n      if (self.mailbox.length !== 0) {\n        let message = self.mailbox[0];\n        self.mailbox = self.mailbox.slice(1);\n        return receive_fun(message);\n      } else {\n        return null;\n      }\n    } else {\n      let now = Date.now();\n      while (Date.now() < now + timeout_in_ms) {\n        if (self.mailbox.length !== 0) {\n          let message = self.mailbox[0];\n          self.mailbox = self.mailbox.slice(1);\n          return receive_fun(message);\n        }\n      }\n\n      return timeout_fn(timeout_in_ms);\n    }\n  },\n\n  tuple: function (...args) {\n    return new Tuple(...args);\n  },\n\n  _try: function (do_fun, rescue_function, catch_fun, else_function, after_function) {\n    let result = null;\n\n    try {\n      result = do_fun();\n    } catch (e) {\n      let ex_result = null;\n\n      if (rescue_function) {\n        try {\n          ex_result = rescue_function(e);\n          return ex_result;\n        } catch (ex) {\n          if (ex instanceof Patterns.MatchError) {\n            throw ex;\n          }\n        }\n      }\n\n      if (catch_fun) {\n        try {\n          ex_result = catch_fun(e);\n          return ex_result;\n        } catch (ex) {\n          if (ex instanceof Patterns.MatchError) {\n            throw ex;\n          }\n        }\n      }\n\n      throw e;\n    } finally {\n      if (after_function) {\n        after_function();\n      }\n    }\n\n    if (else_function) {\n      try {\n        return else_function(result);\n      } catch (ex) {\n        if (ex instanceof Patterns.MatchError) {\n          throw new Error('No Match Found in Else');\n        }\n\n        throw ex;\n      }\n    } else {\n      return result;\n    }\n  }\n\n};\n\nlet Kernel = {\n\n  SpecialForms: SpecialForms,\n\n  tl: function (list) {\n    return SpecialForms.list(...list.slice(1));\n  },\n\n  hd: function (list) {\n    return list[0];\n  },\n\n  is_nil: function (x) {\n    return x == null;\n  },\n\n  is_atom: function (x) {\n    return typeof x === 'symbol';\n  },\n\n  is_binary: function (x) {\n    return typeof x === 'string' || x instanceof String;\n  },\n\n  is_boolean: function (x) {\n    return typeof x === 'boolean' || x instanceof Boolean;\n  },\n\n  is_function: function (x, arity = -1) {\n    return typeof x === 'function' || x instanceof Function;\n  },\n\n  // from: http://stackoverflow.com/a/3885844\n  is_float: function (x) {\n    return x === +x && x !== (x | 0);\n  },\n\n  is_integer: function (x) {\n    return x === +x && x === (x | 0);\n  },\n\n  is_list: function (x) {\n    return x instanceof Array;\n  },\n\n  is_map: function (x) {\n    return typeof x === 'object' || x instanceof Object;\n  },\n\n  is_number: function (x) {\n    return Kernel.is_integer(x) || Kernel.is_float(x);\n  },\n\n  is_tuple: function (x) {\n    return x instanceof Tuple;\n  },\n\n  length: function (x) {\n    return x.length;\n  },\n\n  is_pid: function (x) {\n    return false;\n  },\n\n  is_port: function (x) {},\n\n  is_reference: function (x) {},\n\n  is_bitstring: function (x) {\n    return Kernel.is_binary(x) || x instanceof SpecialForms.bitstring;\n  },\n\n  __in__: function (left, right) {\n    for (let x of right) {\n      if (Kernel.match__qmark__(left, x)) {\n        return true;\n      }\n    }\n\n    return false;\n  },\n\n  abs: function (number) {\n    return Math.abs(number);\n  },\n\n  round: function (number) {\n    return Math.round(number);\n  },\n\n  elem: function (tuple, index) {\n    if (Kernel.is_list(tuple)) {\n      return tuple[index];\n    }\n\n    return tuple.get(index);\n  },\n\n  rem: function (left, right) {\n    return left % right;\n  },\n\n  div: function (left, right) {\n    return left / right;\n  },\n\n  and: function (left, right) {\n    return left && right;\n  },\n\n  or: function (left, right) {\n    return left || right;\n  },\n\n  not: function (arg) {\n    return !arg;\n  },\n\n  apply: function (module, func, args) {\n    if (arguments.length === 3) {\n      return module[func].apply(null, args);\n    } else {\n      return module.apply(null, func);\n    }\n  },\n\n  to_string: function (arg) {\n    if (Kernel.is_tuple(arg)) {\n      return Tuple.to_string(arg);\n    }\n\n    return arg.toString();\n  },\n\n  throw: function (e) {\n    throw e;\n  },\n\n  match__qmark__: function (pattern, expr, guard = () => true) {\n    return _Patterns.match_no_throw(pattern, expr, guard) != null;\n  }\n};\n\nclass Tuple {\n\n  constructor(...args) {\n    this.values = Object.freeze(args);\n  }\n\n  get(index) {\n    return this.values[index];\n  }\n\n  count() {\n    return this.values.length;\n  }\n\n  [Symbol.iterator]() {\n    return this.values[Symbol.iterator]();\n  }\n\n  toString() {\n    var i,\n        s = \"\";\n    for (i = 0; i < this.values.length; i++) {\n      if (s !== \"\") {\n        s += \", \";\n      }\n      s += this.values[i].toString();\n    }\n\n    return \"{\" + s + \"}\";\n  }\n\n  static to_string(tuple) {\n    return tuple.toString();\n  }\n\n  static delete_at(tuple, index) {\n    let new_list = [];\n\n    for (var i = 0; i < tuple.count(); i++) {\n      if (i !== index) {\n        new_list.push(tuple.get(i));\n      }\n    }\n\n    return Kernel.SpecialForms.tuple.apply(null, new_list);\n  }\n\n  static duplicate(data, size) {\n    let array = [];\n\n    for (var i = size - 1; i >= 0; i--) {\n      array.push(data);\n    }\n\n    return Kernel.SpecialForms.tuple.apply(null, array);\n  }\n\n  static insert_at(tuple, index, term) {\n    let new_tuple = [];\n\n    for (var i = 0; i <= tuple.count(); i++) {\n      if (i === index) {\n        new_tuple.push(term);\n        i++;\n        new_tuple.push(tuple.get(i));\n      } else {\n        new_tuple.push(tuple.get(i));\n      }\n    }\n\n    return Kernel.SpecialForms.tuple.apply(null, new_tuple);\n  }\n\n  static from_list(list) {\n    return Kernel.SpecialForms.tuple.apply(null, list);\n  }\n\n  static to_list(tuple) {\n    let new_list = [];\n\n    for (var i = 0; i < tuple.count(); i++) {\n      new_list.push(tuple.get(i));\n    }\n\n    return Kernel.SpecialForms.list(...new_list);\n  }\n}\n\n/* @flow */\n\nclass Variable {\n\n  constructor(name = null) {\n    this.name = name;\n  }\n}\n\nclass Wildcard {\n  constructor() {}\n}\n\nclass StartsWith {\n\n  constructor(prefix) {\n    this.prefix = prefix;\n  }\n}\n\nclass Capture {\n\n  constructor(value) {\n    this.value = value;\n  }\n}\n\nclass HeadTail {\n  constructor() {}\n}\n\nclass Type {\n\n  constructor(type, objPattern = {}) {\n    this.type = type;\n    this.objPattern = objPattern;\n  }\n}\n\nclass Bound {\n\n  constructor(value) {\n    this.value = value;\n  }\n}\n\nfunction variable(name = null) {\n  return new Variable(name);\n}\n\nfunction wildcard() {\n  return new Wildcard();\n}\n\nfunction startsWith(prefix) {\n  return new StartsWith(prefix);\n}\n\nfunction capture(value) {\n  return new Capture(value);\n}\n\nfunction headTail() {\n  return new HeadTail();\n}\n\nfunction type(type, objPattern = {}) {\n  return new Type(type, objPattern);\n}\n\nfunction bound(value) {\n  return new Bound(value);\n}\n\nfunction is_number(value) {\n  return typeof value === 'number';\n}\n\nfunction is_string(value) {\n  return typeof value === 'string';\n}\n\nfunction is_tuple(value) {\n  return value instanceof Tuple;\n}\n\nfunction is_boolean(value) {\n  return typeof value === 'boolean';\n}\n\nfunction is_symbol(value) {\n  return typeof value === 'symbol';\n}\n\nfunction is_null(value) {\n  return value === null;\n}\n\nfunction is_undefined(value) {\n  return typeof value === 'undefined';\n}\n\nfunction is_function(value) {\n  return Object.prototype.toString.call(value) == '[object Function]';\n}\n\nfunction is_variable(value) {\n  return value instanceof Variable;\n}\n\nfunction is_wildcard(value) {\n  return value instanceof Wildcard;\n}\n\nfunction is_headTail(value) {\n  return value instanceof HeadTail;\n}\n\nfunction is_capture(value) {\n  return value instanceof Capture;\n}\n\nfunction is_type(value) {\n  return value instanceof Type;\n}\n\nfunction is_startsWith(value) {\n  return value instanceof StartsWith;\n}\n\nfunction is_bound(value) {\n  return value instanceof Bound;\n}\n\nfunction is_object(value) {\n  return typeof value === 'object';\n}\n\nfunction is_array(value) {\n  return Array.isArray(value);\n}\n\nvar Checks = {\n  is_number,\n  is_string,\n  is_boolean,\n  is_symbol,\n  is_null,\n  is_undefined,\n  is_function,\n  is_variable,\n  is_wildcard,\n  is_headTail,\n  is_capture,\n  is_type,\n  is_startsWith,\n  is_bound,\n  is_object,\n  is_array,\n  is_tuple\n};\n\nfunction resolveTuple(pattern) {\n  let matches = [];\n\n  for (let elem of pattern) {\n    matches.push(buildMatch(elem));\n  }\n\n  return function (value, args) {\n    if (!Checks.is_tuple(value) || value.count() != pattern.count()) {\n      return false;\n    }\n\n    return value.values.every(function (v, i) {\n      return matches[i](value.get(i), args);\n    });\n  };\n}\n\nfunction resolveSymbol(pattern) {\n  return function (value) {\n    return Checks.is_symbol(value) && value === pattern;\n  };\n}\n\nfunction resolveString(pattern) {\n  return function (value) {\n    return Checks.is_string(value) && value === pattern;\n  };\n}\n\nfunction resolveNumber(pattern) {\n  return function (value) {\n    return Checks.is_number(value) && value === pattern;\n  };\n}\n\nfunction resolveBoolean(pattern) {\n  return function (value) {\n    return Checks.is_boolean(value) && value === pattern;\n  };\n}\n\nfunction resolveFunction(pattern) {\n  return function (value) {\n    return Checks.is_function(value) && value === pattern;\n  };\n}\n\nfunction resolveNull(pattern) {\n  return function (value) {\n    return Checks.is_null(value);\n  };\n}\n\nfunction resolveBound(pattern) {\n  return function (value, args) {\n    if (typeof value === typeof pattern.value && value === pattern.value) {\n      args.push(value);\n      return true;\n    }\n\n    return false;\n  };\n}\n\nfunction resolveWildcard() {\n  return function () {\n    return true;\n  };\n}\n\nfunction resolveVariable() {\n  return function (value, args) {\n    args.push(value);\n    return true;\n  };\n}\n\nfunction resolveHeadTail() {\n  return function (value, args) {\n    if (!Checks.is_array(value) || value.length < 2) {\n      return false;\n    }\n\n    const head = value[0];\n    const tail = value.slice(1);\n\n    args.push(head);\n    args.push(tail);\n\n    return true;\n  };\n}\n\nfunction resolveCapture(pattern) {\n  const matches = buildMatch(pattern.value);\n\n  return function (value, args) {\n    if (matches(value, args)) {\n      args.push(value);\n      return true;\n    }\n\n    return false;\n  };\n}\n\nfunction resolveStartsWith(pattern) {\n  const prefix = pattern.prefix;\n\n  return function (value, args) {\n    if (Checks.is_string(value) && value.startsWith(prefix)) {\n      args.push(value.substring(prefix.length));\n      return true;\n    }\n\n    return false;\n  };\n}\n\nfunction resolveType(pattern) {\n  return function (value, args) {\n    if (!value instanceof pattern.type) {\n      return false;\n    }\n\n    const matches = buildMatch(pattern.objPattern);\n    return matches(value, args) && args.push(value) > 0;\n  };\n}\n\nfunction resolveArray(pattern) {\n  const matches = pattern.map(x => buildMatch(x));\n\n  return function (value, args) {\n    if (!Checks.is_array(value) || value.length != pattern.length) {\n      return false;\n    }\n\n    return value.every(function (v, i) {\n      return matches[i](value[i], args);\n    });\n  };\n}\n\nfunction resolveObject(pattern) {\n  let matches = {};\n\n  for (let key of Object.keys(pattern)) {\n    matches[key] = buildMatch(pattern[key]);\n  }\n\n  return function (value, args) {\n    if (!Checks.is_object(value) || pattern.length > value.length) {\n      return false;\n    }\n\n    for (let key of Object.keys(pattern)) {\n      if (!(key in value) || !matches[key](value[key], args)) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n}\n\nfunction resolveNoMatch() {\n  return function () {\n    return false;\n  };\n}\n\nvar Resolvers = {\n  resolveBound,\n  resolveWildcard,\n  resolveVariable,\n  resolveHeadTail,\n  resolveCapture,\n  resolveStartsWith,\n  resolveType,\n  resolveArray,\n  resolveObject,\n  resolveNoMatch,\n  resolveSymbol,\n  resolveString,\n  resolveNumber,\n  resolveBoolean,\n  resolveFunction,\n  resolveNull,\n  resolveTuple\n};\n\nfunction buildMatch(pattern) {\n\n  if (Checks.is_tuple(pattern)) {\n    return Resolvers.resolveTuple(pattern);\n  }\n\n  if (Checks.is_variable(pattern)) {\n    return Resolvers.resolveVariable(pattern);\n  }\n\n  if (Checks.is_wildcard(pattern)) {\n    return Resolvers.resolveWildcard(pattern);\n  }\n\n  if (Checks.is_undefined(pattern)) {\n    return Resolvers.resolveWildcard(pattern);\n  }\n\n  if (Checks.is_headTail(pattern)) {\n    return Resolvers.resolveHeadTail(pattern);\n  }\n\n  if (Checks.is_startsWith(pattern)) {\n    return Resolvers.resolveStartsWith(pattern);\n  }\n\n  if (Checks.is_capture(pattern)) {\n    return Resolvers.resolveCapture(pattern);\n  }\n\n  if (Checks.is_bound(pattern)) {\n    return Resolvers.resolveBound(pattern);\n  }\n\n  if (Checks.is_type(pattern)) {\n    return Resolvers.resolveType(pattern);\n  }\n\n  if (Checks.is_array(pattern)) {\n    return Resolvers.resolveArray(pattern);\n  }\n\n  if (Checks.is_number(pattern)) {\n    return Resolvers.resolveNumber(pattern);\n  }\n\n  if (Checks.is_string(pattern)) {\n    return Resolvers.resolveString(pattern);\n  }\n\n  if (Checks.is_boolean(pattern)) {\n    return Resolvers.resolveBoolean(pattern);\n  }\n\n  if (Checks.is_symbol(pattern)) {\n    return Resolvers.resolveSymbol(pattern);\n  }\n\n  if (Checks.is_null(pattern)) {\n    return Resolvers.resolveNull(pattern);\n  }\n\n  if (Checks.is_object(pattern)) {\n    return Resolvers.resolveObject(pattern);\n  }\n\n  return Resolvers.resolveNoMatch();\n}\n\nclass MatchError extends Error {\n  constructor(arg) {\n    super();\n\n    if (typeof arg === 'symbol') {\n      this.message = 'No match for: ' + arg.toString();\n    } else {\n      this.message = 'No match for: ' + arg;\n    }\n\n    this.stack = new Error().stack;\n    this.name = this.constructor.name;\n  }\n}\n\nclass Case {\n\n  constructor(pattern, fn, guard = () => true) {\n    this.pattern = buildMatch(pattern);\n    this.fn = fn;\n    this.guard = guard;\n  }\n}\n\nfunction make_case(pattern, fn, guard = () => true) {\n  return new Case(pattern, fn, guard);\n}\n\nfunction defmatch(...cases) {\n  return function (...args) {\n    for (let processedCase of cases) {\n      let result = [];\n      if (processedCase.pattern(args, result) && processedCase.guard.apply(this, result)) {\n        return processedCase.fn.apply(this, result);\n      }\n    }\n\n    throw new MatchError(args);\n  };\n}\n\nfunction match(pattern, expr, guard = () => true) {\n  let result = [];\n  let processedPattern = buildMatch(pattern);\n  if (processedPattern(expr, result) && guard.apply(this, result)) {\n    return result;\n  } else {\n    throw new MatchError(expr);\n  }\n}\n\nfunction match_no_throw(pattern, expr, guard = () => true) {\n  try {\n    return match(pattern, expr, guard);\n  } catch (e) {\n    if (e instanceof MatchError) {\n      return null;\n    }\n\n    throw e;\n  }\n}\n\nfunction patternMap(collection, pattern, fun, guard = () => true) {\n  let ret = [];\n\n  for (let elem of collection) {\n    try {\n      let result = fun.apply(this, match(pattern, elem, guard));\n      ret = ret.concat(result);\n    } catch (e) {\n      if (!(e instanceof MatchError)) {\n        throw e;\n      }\n    }\n  }\n\n  return ret;\n}\n\nvar _Patterns = {\n  defmatch, match, MatchError, match_no_throw, patternMap,\n  variable, wildcard, startsWith,\n  capture, headTail, type, bound, Case, make_case\n};\n\nlet Atom = {};\n\nAtom.to_string = function (atom) {\n  return Symbol.keyFor(atom);\n};\n\nAtom.to_char_list = function (atom) {\n  return Atom.to_string(atom).split('');\n};\n\nlet Integer = {\n\n  is_even: function (n) {\n    return n % 2 === 0;\n  },\n\n  is_odd: function (n) {\n    return n % 2 !== 0;\n  },\n\n  parse: function (bin) {\n    let result = parseInt(bin);\n\n    if (isNaN(result)) {\n      return Kernel.SpecialForms.atom(\"error\");\n    }\n\n    let indexOfDot = bin.indexOf(\".\");\n\n    if (indexOfDot >= 0) {\n      return Kernel.SpecialForms.tuple(result, bin.substring(indexOfDot));\n    }\n\n    return Kernel.SpecialForms.tuple(result, \"\");\n  },\n\n  to_char_list: function (number, base = 10) {\n    return number.toString(base).split(\"\");\n  },\n\n  to_string: function (number, base = 10) {\n    return number.toString(base);\n  }\n};\n\nlet JS = {\n  get_property_or_call_function: function (item, property) {\n    if (item[property] instanceof Function) {\n      return item[property]();\n    } else {\n      return item[property];\n    }\n  }\n};\n\nlet List = {};\n\nList.delete = function (list, item) {\n  let new_value = [];\n  let value_found = false;\n\n  for (let x of list) {\n    if (x === item && value_found !== false) {\n      new_value.push(x);\n      value_found = true;\n    } else if (x !== item) {\n      new_value.push(x);\n    }\n  }\n\n  return Kernel.SpecialForms.list(...new_value);\n};\n\nList.delete_at = function (list, index) {\n  let new_value = [];\n\n  for (let i = 0; i < list.length; i++) {\n    if (i !== index) {\n      new_value.push(list[i]);\n    }\n  }\n\n  return Kernel.SpecialForms.list(...new_value);\n};\n\nList.duplicate = function (elem, n) {\n  let new_value = [];\n\n  for (var i = 0; i < n; i++) {\n    new_value.push(elem);\n  }\n\n  return Kernel.SpecialForms.list(...new_value);\n};\n\nList.first = function (list) {\n  return list[0];\n};\n\nList.flatten = function (list, tail = Kernel.SpecialForms.list()) {\n  let new_value = [];\n\n  for (let x of list) {\n    if (Kernel.is_list(x)) {\n      new_value = new_value.concat(List.flatten(x));\n    } else {\n      new_value.push(x);\n    }\n  }\n\n  new_value = new_value.concat(tail);\n\n  return Kernel.SpecialForms.list(...new_value);\n};\n\nList.foldl = function (list, acc, func) {\n  return list.reduce(func, acc);\n};\n\nList.foldr = function (list, acc, func) {\n  let new_acc = acc;\n\n  for (var i = list.length - 1; i >= 0; i--) {\n    new_acc = func(list[i], new_acc);\n  }\n\n  return new_acc;\n};\n\nList.insert_at = function (list, index, value) {\n  let new_value = [];\n\n  for (let i = 0; i < list.length; i++) {\n    if (i === index) {\n      new_value.push(value);\n      new_value.push(list[i]);\n    } else {\n      new_value.push(list[i]);\n    }\n  }\n\n  return Kernel.SpecialForms.list(...new_value);\n};\n\nList.keydelete = function (list, key, position) {\n  let new_list = [];\n\n  for (let i = 0; i < list.length; i++) {\n    if (!Kernel.match__qmark__(list[i][position], key)) {\n      new_list.push(list[i]);\n    }\n  }\n\n  return Kernel.SpecialForms.list(...new_list);\n};\n\nList.keyfind = function (list, key, position, _default = null) {\n\n  for (let i = 0; i < list.length; i++) {\n    if (Kernel.match__qmark__(list[i][position], key)) {\n      return list[i];\n    }\n  }\n\n  return _default;\n};\n\nList.keymember__qmark__ = function (list, key, position) {\n\n  for (let i = 0; i < list.length; i++) {\n    if (Kernel.match__qmark__(list[i][position], key)) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\nList.keyreplace = function (list, key, position, new_tuple) {\n  let new_list = [];\n\n  for (let i = 0; i < list.length; i++) {\n    if (!Kernel.match__qmark__(list[i][position], key)) {\n      new_list.push(list[i]);\n    } else {\n      new_list.push(new_tuple);\n    }\n  }\n\n  return Kernel.SpecialForms.list(...new_list);\n};\n\nList.keysort = function (list, position) {\n  let new_list = list;\n\n  new_list.sort(function (a, b) {\n    if (position === 0) {\n      if (a[position].value < b[position].value) {\n        return -1;\n      }\n\n      if (a[position].value > b[position].value) {\n        return 1;\n      }\n\n      return 0;\n    } else {\n      if (a[position] < b[position]) {\n        return -1;\n      }\n\n      if (a[position] > b[position]) {\n        return 1;\n      }\n\n      return 0;\n    }\n  });\n\n  return Kernel.SpecialForms.list(...new_list);\n};\n\nList.keystore = function (list, key, position, new_tuple) {\n  let new_list = [];\n  let replaced = false;\n\n  for (let i = 0; i < list.length; i++) {\n    if (!Kernel.match__qmark__(list[i][position], key)) {\n      new_list.push(list[i]);\n    } else {\n      new_list.push(new_tuple);\n      replaced = true;\n    }\n  }\n\n  if (!replaced) {\n    new_list.push(new_tuple);\n  }\n\n  return Kernel.SpecialForms.list(...new_list);\n};\n\nList.last = function (list) {\n  return list[list.length - 1];\n};\n\nList.replace_at = function (list, index, value) {\n  let new_value = [];\n\n  for (let i = 0; i < list.length; i++) {\n    if (i === index) {\n      new_value.push(value);\n    } else {\n      new_value.push(list[i]);\n    }\n  }\n\n  return Kernel.SpecialForms.list(...new_value);\n};\n\nList.update_at = function (list, index, fun) {\n  let new_value = [];\n\n  for (let i = 0; i < list.count(); i++) {\n    if (i === index) {\n      new_value.push(fun(list.get(i)));\n    } else {\n      new_value.push(list.get(i));\n    }\n  }\n\n  return new_value;\n};\n\nList.wrap = function (list) {\n  if (Kernel.is_list(list)) {\n    return list;\n  } else if (list == null) {\n    return Kernel.SpecialForms.list();\n  } else {\n    return Kernel.SpecialForms.list(list);\n  }\n};\n\nList.zip = function (list_of_lists) {\n  if (list_of_lists.length === 0) {\n    return Kernel.SpecialForms.list();\n  }\n\n  let new_value = [];\n  let smallest_length = list_of_lists[0];\n\n  for (let x of list_of_lists) {\n    if (x.length < smallest_length) {\n      smallest_length = x.length;\n    }\n  }\n\n  for (let i = 0; i < smallest_length; i++) {\n    let current_value = [];\n    for (let j = 0; j < list_of_lists.length; j++) {\n      current_value.push(list_of_lists[j][i]);\n    }\n\n    new_value.push(Kernel.SpecialForms.tuple(...current_value));\n  }\n\n  return Kernel.SpecialForms.list(...new_value);\n};\n\nList.to_tuple = function (list) {\n  return Kernel.SpecialForms.tuple.apply(null, list);\n};\n\nList.append = function (list, value) {\n  return Kernel.SpecialForms.list(...list.concat([value]));\n};\n\nList.concat = function (left, right) {\n  return left.concat(right);\n};\n\nlet Range = function (_first, _last) {\n  if (!(this instanceof Range)) {\n    return new Range(_first, _last);\n  }\n\n  this.first = function () {\n    return _first;\n  };\n\n  this.last = function () {\n    return _last;\n  };\n\n  let _range = [];\n\n  for (let i = _first; i <= _last; i++) {\n    _range.push(i);\n  }\n\n  _range = Object.freeze(_range);\n\n  this.value = function () {\n    return _range;\n  };\n\n  this.length = function () {\n    return _range.length;\n  };\n\n  return this;\n};\n\nRange.prototype[Symbol.iterator] = function () {\n  return this.value()[Symbol.iterator]();\n};\n\nRange.new = function (first, last) {\n  return Range(first, last);\n};\n\nRange.range__qmark__ = function (range) {\n  return range instanceof Range;\n};\n\nlet Keyword = {};\n\nKeyword.has_key__qm__ = function (keywords, key) {\n  for (let keyword of keywords) {\n    if (Kernel.elem(keyword, 0) == key) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\nKeyword.get = function (keywords, key, the_default = null) {\n  for (let keyword of keywords) {\n    if (Kernel.elem(keyword, 0) == key) {\n      return Kernel.elem(keyword, 1);\n    }\n  }\n\n  return the_default;\n};\n\nlet Agent = {};\n\nAgent.start = function (fun, options = []) {\n  const name = Keyword.has_key__qm__(options, Kernel.SpecialForms.atom('name')) ? Keyword.get(options, Kernel.SpecialForms.atom('name')) : Symbol();\n\n  self.post_office.add_mailbox(name);\n  self.post_office.send(name, fun());\n\n  return Kernel.SpecialForms.tuple(Kernel.SpecialForms.atom('ok'), name);\n};\n\nAgent.stop = function (agent, timeout = 5000) {\n  self.post_office.remove_mailbox(agent);\n  return Kernel.SpecialForms.atom('ok');\n};\n\nAgent.update = function (agent, fun, timeout = 5000) {\n\n  const current_state = self.post_office.receive(agent);\n  self.post_office.send(agent, fun(current_state));\n\n  return Kernel.SpecialForms.atom('ok');\n};\n\nAgent.get = function (agent, fun, timeout = 5000) {\n  return fun(self.post_office.peek(agent));\n};\n\nAgent.get_and_update = function (agent, fun, timeout = 5000) {\n\n  const get_and_update_tuple = fun(self.post_office.receive(agent));\n  self.post_office.send(agent, Kernel.elem(get_and_update_tuple, 1));\n\n  return Kernel.elem(get_and_update_tuple, 0);\n};\n\nself.post_office = self.post_office || new PostOffice();\n\nexport { _Patterns as Patterns, BitString, Kernel, Atom, Enum, Integer, JS, List, Range, Tuple, Agent, Keyword };"],"file":"elixir.js","sourceRoot":"/source/"}