/**
functions
* create a schedule for a target
inputs
* targets
* current time
* previous schedules
variables
* time that a schedule is started
* time that a new schedule should be made and ran
* time that a schedule finishes
process
* a new schedule needs to be created and ran when the duration of paddings of the previous schedule has elapsed.
* to ensure that there is no downtime and overlap between the last task of the current schedule and the first task of the next scheudle, the minimum length a schedule should be long enough is such that the amount of paddings in the schedule is greater than or equal to the duration of the longest action (weaken).
	* e.g., if longest task takes 10 seconds before it starts, the amount of paddings have to be at least 10 seconds before starting the tasks in the next schedule.
* prioritise adding another schedule to the better targets rather than adding a new schedule for worse targets.
*/

// weaken_manager.js - 3.4GB - continuously runs enough threads of cyclic_weaken.js to meet float_ram_fraction_for_weaken_cyclic.
import {
  array_make_schedule_script,
  void_schedule_script_runner
} from "lib_ram_script.js";
// main
export const main = async function (ns) {
  for (;;)
    void_schedule_script_runner(
      ns,
      array_make_schedule_script(ns, [
        {
          file: ns.args[1],
          threads_or_ram_botnet: ns.args[2],
          args: [ns.args[3]],
        },
      ])
    ),
    await ns.sleep(1e3 * ns.args[0]);
};

export const main = async function(ns) {
  await ns.sleep(ns.args[2]);
//  const start = Date.now();
//  const s = new Date(start);
  await ns.weaken(ns.args[1]);
//  const finish = Date.now();
//  const f = new Date(finish);
//  ns.tprint("\t#" + ns.args[3] + "\t" + ns.args[0] + " weakening " + ns.args[1] + "\nWeaken started:\t\t" + s.toISOString() + "\nWeaken finished:\t" + f.toISOString());
};

// tor.js - 3.8GB - tries to continually buy TOR Router
export const main = async function(ns) {
  const float_period_check = ns.args[0] * 1000;
  while (true) {
    if (ns.scan("home").includes("darkweb")) {
      break;
    }
    try {
      ns.purchaseTor();
    } catch (error) {
      ns.print(JSON.stringify(error));
    }
    await ns.sleep(float_period_check);
  }
};

// servers.js - 8.55GB - continually buys the best server with cash available, unless there are 25 servers already, in which case deletes the worst server, unless all 25 have ram == PurchasedServerMaxRam
export const main = async function(ns) {
  const float_period_check = ns.args[0] * 1000;
  const string_servers_bought_name = ns.args[0];
  const object_get_constants = function(ns) {
    const object_constants = {
      // cost of server per 1 GB of RAM
      BaseCostFor1GBOfRamServer: 55000,
      // maximum amount of purchased servers allowed
      PurchasedServerLimit: 25,
      // minimum ram of purchased servers possible
      integer_server_ram_min: 2,
      // maximum ram of purchased servers possible. 2^20
      PurchasedServerMaxRam: 1048576,
    };
    return object_constants;
  };
  // returns the total ram of a server
  const integer_get_server_ram_total = function(ns, string_server) {
    return (ns.getServerRam(string_server))[0];
  };
  // true if all bought servers have ram == PurchasedServerMaxRam
  const boolean_servers_bought_all_max = function(ns) {
    const array_servers_bought = ns.getPurchasedServers();
    if (array_servers_bought.length > 0) {
      let boolean_tripwire = true;
      for (let integer_indices_0 = 0; integer_indices_0 < array_servers_bought.length; ++integer_indices_0) {
        if (integer_get_server_ram_total(ns, array_servers_bought[integer_indices_0]) < object_get_constants(ns).PurchasedServerMaxRam) {
          boolean_tripwire = false;
        }
      }
      return boolean_tripwire;
    }
  };
  // returns bought server with smallest RAM
  const string_get_server_bought_smallest = function(ns) {
    const array_servers_bought = ns.getPurchasedServers();
    if (array_servers_bought.length > 0) {
      let string_server_smallest;
      let integer_size_smallest = object_get_constants(ns).PurchasedServerMaxRam;
      for (let integer_indices_0 = 0; integer_indices_0 < array_servers_bought.length; ++integer_indices_0) {
        let integer_server_ram_total = integer_get_server_ram_total(ns, array_servers_bought[integer_indices_0]);
        if (integer_server_ram_total < integer_size_smallest) {
          string_server_smallest = array_servers_bought[integer_indices_0];
          integer_size_smallest = integer_server_ram_total;
        }
      }
      return string_server_smallest;
    }
  };
  // returns bought server with biggest RAM
  const string_get_server_bought_biggest = function(ns) {
    const array_servers_bought = ns.getPurchasedServers();
    if (array_servers_bought.length > 0) {
      let string_server_biggest;
      let integer_size_biggest = object_get_constants(ns).integer_server_ram_min;
      for (let integer_indices_0 = 0; integer_indices_0 < array_servers_bought.length; ++integer_indices_0) {
        let integer_server_ram_total = integer_get_server_ram_total(ns, array_servers_bought[integer_indices_0]);
        if (integer_server_ram_total > integer_size_biggest) {
          string_server_biggest = array_servers_bought[integer_indices_0];
          integer_size_biggest = integer_server_ram_total;
        }
      }
    return string_server_biggest;
    }
  };
  // return the RAM of the server with the biggest RAM that you can afford
  const integer_get_server_ram_biggest_afforded = function(ns) {
    const object_constants = object_get_constants(ns);
    let integer_server_ram_biggest_afforded = Math.pow(2, Math.trunc(Math.log2(ns.getServerMoneyAvailable("home") / object_constants.BaseCostFor1GBOfRamServer) / Math.log2(2)));
    if (integer_server_ram_biggest_afforded > object_constants.PurchasedServerMaxRam) {
      integer_server_ram_biggest_afforded = object_constants.PurchasedServerMaxRam;
    }
    return integer_server_ram_biggest_afforded;
  };
  const boolean_conditions_server_purchase_1 = function(ns) {
    const integer_server_ram_biggest_afforded = integer_get_server_ram_biggest_afforded(ns);
    const object_constants = object_get_constants(ns);
    if (// you have no bought servers yet
      (ns.getPurchasedServers().length === 0) &&
      // ram is at least equal to the minimum ram possible for purchased servers
      (integer_server_ram_biggest_afforded >= object_constants.integer_server_ram_min) &&
      // ram is at least equal to the ram of "home" (probably a bad idea to hardcode this since the string_name of "home" might change in the future) or max ram.
      (integer_server_ram_biggest_afforded >= integer_get_server_ram_total(ns, "home") ||
      integer_server_ram_biggest_afforded >= object_constants.PurchasedServerMaxRam)
    ) {
      return true;
    }
  };
  
  const boolean_conditions_server_purchase_2 = function(ns) {
    const integer_servers_bought_amount = ns.getPurchasedServers().length;
    const object_constants = object_get_constants(ns);
    if (// you have one or more servers already
      (integer_servers_bought_amount > 0) &&
      // you currently own less than the maximum amount of purchased servers allowed
      (integer_servers_bought_amount < object_constants.PurchasedServerLimit)
      
    ) {
      const float_ram_server_bought_biggest = integer_get_server_ram_total(ns, string_get_server_bought_biggest(ns));
      if (
          // you dont own a server with max ram yet, buy a server with ram greater than the ram of your biggest bought server
        (float_ram_server_bought_biggest != object_constants.PurchasedServerMaxRam) &&
        (float_ram_server_bought_biggest < integer_get_server_ram_biggest_afforded(ns))
      ) {
        return true;
      }
    }
  };
  
  const boolean_conditions_server_purchase_3 = function(ns) {
    const integer_servers_bought_amount = ns.getPurchasedServers().length;
    const object_constants = object_get_constants(ns);
    const float_ram_server_bought_maximum = object_constants.PurchasedServerMaxRam;
    if (// you have one or more servers already
      (integer_servers_bought_amount > 0) &&
      // you currently own less than the maximum amount of purchased servers allowed
      (integer_servers_bought_amount < object_constants.PurchasedServerLimit)
    ) {
      if (// you already bought a server with max ram, buy another server the max possible ram
        (integer_get_server_ram_total(ns, string_get_server_bought_biggest(ns)) == float_ram_server_bought_maximum) &&
        (integer_get_server_ram_biggest_afforded(ns) >= float_ram_server_bought_maximum)
      ) {
        return true;
      }
    }
  };
  
  const boolean_conditions_server_delete_purchase = function(ns) {
    const object_constants = object_get_constants(ns);
    if (// you currently own the maximum amount of purchased servers allowed
      (ns.getPurchasedServers().length == object_constants.PurchasedServerLimit) &&
      // your servers do not all have the maximum ram possible for purchased servers
      !(boolean_servers_bought_all_max(ns, object_constants.PurchasedServerMaxRam)) &&
      // is cash at least equal to the price of the cheapest server bought + the next highest server after that, which is twice the price of the former, thus 3. this check is so that a server with the same ram as before isn't bought.
      (ns.getServerMoneyAvailable("home") >= 3 * object_constants.BaseCostFor1GBOfRamServer * integer_get_server_ram_total(ns, string_get_server_bought_smallest(ns)))
    ) {
      return true;
    }
    else {
      return false;
    }
  };
  while (!boolean_servers_bought_all_max(ns)) {
    while (boolean_conditions_server_delete_purchase(ns)) {
      ns.deleteServer(string_get_server_bought_smallest(ns));
      ns.purchaseServer(string_servers_bought_name, integer_get_server_ram_biggest_afforded(ns));
    }
    
    while (
      boolean_conditions_server_purchase_3(ns) ||
      boolean_conditions_server_purchase_2(ns) ||
      boolean_conditions_server_purchase_1(ns)
    ) {
      ns.purchaseServer(string_servers_bought_name, integer_get_server_ram_biggest_afforded(ns));
    }
    await ns.sleep(float_period_check);
  }
};

// ram.js - 6.2GB - tries to continually buy ram as long as you have sufficient cash
export const main = async function(ns) {
  const float_period_check = ns.args[0] * 1000;
  while(true) {
    try {
      while (ns.getServerMoneyAvailable("home") >= ns.getUpgradeHomeRamCost()) {
        ns.upgradeHomeRam();
      }
    }
    catch (error) {
      ns.print(JSON.stringify(error));
    }
    await ns.sleep(float_period_check);
  }
};

// programs.js - 3.7GB - tries to continually buy programs
export const main = async function(ns) {
  const float_period_check = ns.args[0] * 1000;
  const array_programs = ns.args[1];
  let boolean_has_all_programs = false;
  while (true) {
    if (boolean_has_all_programs) {
      break;
    }
    let boolean_program_missing = false;
    for (let integer_indices_0 = 0; integer_indices_0 < array_programs.length; ++integer_indices_0) {
      const string_program = array_programs[integer_indices_0];
      if (!ns.fileExists(string_program, "home")) {
        boolean_program_missing = true;
      }
      try {
        ns.purchaseProgram(string_program);
      } catch (error) {
        ns.print(JSON.stringify(error));
      }
    }
    if (!boolean_program_missing) {
      boolean_has_all_programs = true;
    }
    await ns.sleep(float_period_check);
  }
};

export const main = async function (ns) {
  for (;;) await ns.sleep(999999);
};

// hacknet.js - 5.6 GB - purchases nodes and upgrades them until the node requirements for joining Netburners are met.
const object_get_nodes_stats = function (ns) {
  const object_output = {
    level: 0,
    ram: 0,
    cores: 0,
  };
  const integer_nodes = ns.hacknet.numNodes();
  for (
    let integer_index_nodes = 0;
    integer_index_nodes < integer_nodes;
    ++integer_index_nodes
  ) {
    const object_node_stats = ns.hacknet.getNodeStats(integer_index_nodes);
    object_output.level += object_node_stats.level;
    object_output.ram += object_node_stats.ram;
    object_output.cores += object_node_stats.cores;
  }
  return object_output;
};
export const main = async function (ns) {
  const
    float_period_check = 1e3 * ns.args[0],
    integer_level = 100,
    integer_ram = 8,
    integer_cores = 4;
  for (; ns.hacknet.numNodes() <= 0;) {
    try {
      ns.hacknet.purchaseNode();
    } catch (error) {
      await ns.sleep(float_period_check);
    }
    await ns.sleep(float_period_check);
  }
  let object_nodes_stats = object_get_nodes_stats(ns);
  for (
    ;
    !(integer_level <= object_nodes_stats.level &&
    integer_ram <= object_nodes_stats.ram &&
    integer_cores <= object_nodes_stats.cores);
  ) {
    object_nodes_stats = object_get_nodes_stats(ns);
    const integer_nodes = ns.hacknet.numNodes();
    let
      integer_cost = ns.hacknet.getPurchaseNodeCost(),
      function_job = function () {
        ns.hacknet.purchaseNode();
      };
    for (
      let integer_index_nodes = 0;
      integer_index_nodes < integer_nodes;
      ++integer_index_nodes
    ) {
      const
        integer_cost_level = ns.hacknet.getLevelUpgradeCost(integer_index_nodes, 1),
        integer_cost_ram = ns.hacknet.getRamUpgradeCost(integer_index_nodes, 1),
        integer_cost_core = ns.hacknet.getCoreUpgradeCost(integer_index_nodes, 1);
      if (
        object_nodes_stats.level < integer_level &&
        integer_cost_level < integer_cost
      ) {
        integer_cost = integer_cost_level;
        function_job = function () {
          ns.hacknet.upgradeLevel(integer_index_nodes, 1);
        };
      }
      if (
        object_nodes_stats.ram < integer_ram &&
        integer_cost_ram < integer_cost
      ) {
        integer_cost = integer_cost_ram;
        function_job = function () {
          ns.hacknet.upgradeRam(integer_index_nodes, 1);
        };
      }
      if (
        object_nodes_stats.cores < integer_cores &&
        integer_cost_core < integer_cost
      ) {
        integer_cost = integer_cost_core;
        function_job = function () {
          ns.hacknet.upgradeCore(integer_index_nodes, 1);
        };
      }
    }
    try {
      function_job();
    } catch (error) {
      await ns.sleep(float_period_check);
    }
    await ns.sleep(float_period_check);
  }
};

/* hacker.js - 8.05GB - TODO:
* Maybe add functionality that allows on-the-fly hot loading of settings from a file.
* add a job cap thing that prevents running more jobs if the first worker in a cycle finishes. add a thing to worker script that writes to a file (or to `window`) its identifier, when it started and when it finishes. add a padding optimiser that detects when tail collision occurs and increases padding each cycle if it does occur, and decreases it by half of how much it increases everytime no tail collision occurs
* do we need to Add delay between each script execution?
*/
import {
  array_get_servers_rooted
}
from "lib_root.js";
import {
  float_get_server_ram_free,
  array_get_servers_rooted_sorted_by_ram
}
from "lib_ram.js";
// main
export const main = async function(ns) {
  const array_arguments = ns.args;
  // main loop
  let integer_time_finishes = Date.now();
  while (true) {
    if (integer_time_finishes <= Date.now()) {
      integer_time_finishes = await void_runner(ns, ...array_arguments.slice(1)) + Date.now();
    }
    // arbitrarily check every float_period_check_seconds to see if the current time is greater than the time that the runner is supposed to finish.
    await ns.sleep(array_arguments[0] * 1000);
  }
};
// functions
const object_get_constants = function(ns) {
  // from BitNode/BitNodeMultipliers
  const object_get_bitnode_multipliers = function(ns) {
    // try {
    //   return ns.getBitNodeMultipliers();
    // }
    // catch (error) {
    //   ns.tprint(JSON.stringify(error));
    //   return {
    //     HackingLevelMultiplier:     1,
    //     StrengthLevelMultiplier:    1,
    //     DefenseLevelMultiplier:     1,
    //     DexterityLevelMultiplier:   1,
    //     AgilityLevelMultiplier:     1,
    //     CharismaLevelMultiplier:    1,
    
    //     ServerGrowthRate:           1,
    //     ServerMaxMoney:             1,
    //     ServerStartingMoney:        1,
    //     ServerStartingSecurity:     1,
    //     ServerWeakenRate:           1,
    
    //     HomeComputerRamCost:        1,
    
    //     PurchasedServerCost:        1,
    //     PurchasedServerLimit:       1,
    //     PurchasedServerMaxRam:      1,
    
    //     CompanyWorkMoney:           1,
    //     CrimeMoney:                 1,
    //     HacknetNodeMoney:           1,
    //     ManualHackMoney:            1,
    //     ScriptHackMoney:            1,
    //     CodingContractMoney:        1,
    
    //     ClassGymExpGain:            1,
    //     CompanyWorkExpGain:         1,
    //     CrimeExpGain:               1,
    //     FactionWorkExpGain:         1,
    //     HackExpGain:                1,
    
    //     FactionPassiveRepGain:      1,
    //     FactionWorkRepGain:         1,
    //     RepToDonateToFaction:       1,
    
    //     AugmentationMoneyCost:      1,
    //     AugmentationRepCost:        1,
    
    //     InfiltrationMoney:          1,
    //     InfiltrationRep:            1,
    
    //     FourSigmaMarketDataCost:    1,
    //     FourSigmaMarketDataApiCost: 1,
    
    //     CorporationValuation:       1,
    
    //     BladeburnerRank:            1,
    //     BladeburnerSkillCost:       1,
    
    //     DaedalusAugsRequirement:    1,
    //   };
    // }
    return {
      HackingLevelMultiplier:     1,
      StrengthLevelMultiplier:    1,
      DefenseLevelMultiplier:     1,
      DexterityLevelMultiplier:   1,
      AgilityLevelMultiplier:     1,
      CharismaLevelMultiplier:    1,
  
      ServerGrowthRate:           1,
      ServerMaxMoney:             1,
      ServerStartingMoney:        1,
      ServerStartingSecurity:     1,
      ServerWeakenRate:           1,
  
      HomeComputerRamCost:        1,
  
      PurchasedServerCost:        1,
      PurchasedServerLimit:       1,
      PurchasedServerMaxRam:      1,
  
      CompanyWorkMoney:           1,
      CrimeMoney:                 1,
      HacknetNodeMoney:           1,
      ManualHackMoney:            1,
      ScriptHackMoney:            1,
      CodingContractMoney:        1,
  
      ClassGymExpGain:            1,
      CompanyWorkExpGain:         1,
      CrimeExpGain:               1,
      FactionWorkExpGain:         1,
      HackExpGain:                1,
  
      FactionPassiveRepGain:      1,
      FactionWorkRepGain:         1,
      RepToDonateToFaction:       1,
  
      AugmentationMoneyCost:      1,
      AugmentationRepCost:        1,
  
      InfiltrationMoney:          1,
      InfiltrationRep:            1,
  
      FourSigmaMarketDataCost:    1,
      FourSigmaMarketDataApiCost: 1,
  
      CorporationValuation:       1,
  
      BladeburnerRank:            1,
      BladeburnerSkillCost:       1,
  
      DaedalusAugsRequirement:    1,
    };
  };
  const object_get_stats = function(ns) {
    // try {
    //   return ns.getStats();
    // }
    // catch (error) {
    //   ns.tprint(JSON.stringify(error));
    //   return {
    //     hacking:        ns.getHackingLevel(),
    //     strength:       1,
    //     defense:        1,
    //     dexterity:      1,
    //     agility:        1,
    //     charisma:       1,
    //     intelligence:   1
    //   };
    // }
    return {
      hacking:        ns.getHackingLevel(),
      strength:       1,
      defense:        1,
      dexterity:      1,
      agility:        1,
      charisma:       1,
      intelligence:   1
    };
  };
  // object_constants are from https://github.com/danielyxie/bitburner/blob/master/src/Constants.js
  const object_constants = {
    // factor used in determining the amount security increases by from a grow or hack
    ServerFortifyAmount: 0.002,
    // amount security decreases by from a weaken
    ServerWeakenAmount: 0.05,
    // base percentage cash increases by from a grow
    ServerBaseGrowthRate: 1.03,
    // max percentage cash increases by from a grow (accounts for server security)
    ServerMaxGrowthRate: 1.0035,
    // hacking multipliers
    object_hacking_multipliers: ns.getHackingMultipliers(),
    // bitnode multipliers
    object_bitnode_multipliers: object_get_bitnode_multipliers(ns),
    // player stats
    object_stats: object_get_stats(ns),
    // filenames and ram cost of helper object_scripts
    array_workers: ["weaken.js", "grow.js", "hack.js"]
  };
  return object_constants;
};
// targetting
// returns the score of a server which is calculated by taking into account its max cash, growth, and required hacking level. adapted from `calculatePercentMoneyHacked` in Hacking.js
const float_get_server_score = function(ns, string_server_target) {
  const float_player_hacking_level = ns.getHackingLevel();
  return ns.getServerMaxMoney(string_server_target) * ns.getServerGrowth(string_server_target) * ((float_player_hacking_level - (ns.getServerRequiredHackingLevel(string_server_target) - 1)) * Math.pow(float_player_hacking_level, -1));
};
// sort an array of servers by their score, from lowest to highest
const void_sort_by_server_scores = function(ns, array_servers) {
  return array_servers.sort((string_element_0, string_element_1) => float_get_server_score(ns, string_element_0) - float_get_server_score(ns, string_element_1));
};
// weaken, grow, hack
// returns integer_threads_required if it's less than or equal to integer_threads_available, otherwise returns integer_threads_available
const integer_get_corrected_threads = function(ns, integer_threads_required, integer_threads_available) {
  if (integer_threads_required > integer_threads_available) {
    return integer_threads_available;
  }
  else {
    return integer_threads_required;
  }
};
// weaken stuff
// the threads required for weaken to cause string_server_target's security to decrease by float_weaken_amount. adapted from `weaken` in NetscriptFunctions.js and `weaken` in Server.ts
const integer_get_threads_required_for_weaken = function(ns, float_weaken_amount) {
  const object_constants = object_get_constants(ns);
  return float_weaken_amount * Math.pow(object_constants.ServerWeakenAmount, -1) * Math.pow(object_constants.object_bitnode_multipliers.ServerWeakenRate, -1);
};
// returns the threads required for weaken to cause string_server_target's security to reach minimum
const integer_get_threads_required_for_weaken_minimum_security = function(ns, string_server_target, float_server_target_security) {
  return Math.ceil(integer_get_threads_required_for_weaken(ns, float_server_target_security - ns.getServerMinSecurityLevel(string_server_target)));
};
// returns the threads required for weaken to cause string_server_target's security to reach minimum if possible, otherwise, return max threads that string_server_used can provide
const integer_get_threads_weaken = function(ns, float_server_used_ram_free, string_server_target, float_server_target_security) {
  const string_weaken = object_get_constants(ns).array_workers[0];
  const integer_threads_available = Math.trunc(float_server_used_ram_free / ns.getScriptRam(string_weaken));
  const integer_threads_required = integer_get_threads_required_for_weaken_minimum_security(ns, string_server_target, float_server_target_security);
  return integer_get_corrected_threads(ns, integer_threads_required, integer_threads_available);
};
// returns the security decrease from the weaken threads used. Adapted from `weaken` in NetscriptFunctions.js and `weaken` in Server.ts
const float_get_security_decrease_from_weaken = function(ns, integer_threads_weaken) {
  return integer_threads_weaken * object_get_constants(ns).ServerWeakenAmount;
};
// grow stuff
// returns the number of threads of `grow` needed to grow `string_server_target` by the percentage `float_growth` when it has security of `float_server_security`. float_growth = How much the server is being grown by, in DECIMAL form (e.g. 1.5 rather than 50). adapted from `numCycleForGrowth` in https://github.com/danielyxie/bitburner/blob/master/src/Server/ServerHelpers.ts
const integer_get_threads_for_growth = function(ns, string_server_target, float_server_target_security, float_growth) {
  const object_constants = object_get_constants(ns);
  let ajdGrowthRate = 1 + (object_constants.ServerBaseGrowthRate - 1) / float_server_target_security;
  if (ajdGrowthRate > object_constants.ServerMaxGrowthRate) {
      ajdGrowthRate = object_constants.ServerMaxGrowthRate;
  }
  const serverGrowthPercentage = ns.getServerGrowth(string_server_target) / 100;
  const cycles = Math.log(float_growth)/(Math.log(ajdGrowthRate) * object_constants.object_hacking_multipliers.growth * serverGrowthPercentage * object_constants.object_bitnode_multipliers.ServerGrowthRate);
  return Math.ceil(cycles);
};
// Inverse function of integer_get_threads_for_growth. Returns the percentage growth in decimal form (e.g., 2 = 100% growth).
const float_get_growth_from_threads = function(ns, string_server_target, float_server_target_security, integer_threads) {
  const object_constants = object_get_constants(ns);
  let ajdGrowthRate = 1 + (object_constants.ServerBaseGrowthRate - 1) / float_server_target_security;
  if (ajdGrowthRate > object_constants.ServerMaxGrowthRate) {
      ajdGrowthRate = object_constants.ServerMaxGrowthRate;
  }
  const serverGrowthPercentage = ns.getServerGrowth(string_server_target) / 100;
  const float_growth = Math.pow(ajdGrowthRate, integer_threads * object_constants.object_hacking_multipliers.growth * serverGrowthPercentage * object_constants.object_bitnode_multipliers.ServerGrowthRate);
  return float_growth;
};
// returns the threads required by grow to grow string_server_target's cash to its maximum when security is at float_server_target_security and current cash is at float_server_target_cash
const integer_get_threads_required_for_grow_maximum_cash = function(ns, string_server_target, float_server_target_security, float_server_target_cash) {
  return integer_get_threads_for_growth(ns, string_server_target, float_server_target_security, ns.getServerMaxMoney(string_server_target) / float_server_target_cash);
};
// returns the threads required by grow to grow string_server_target's cash to its maximum if possible, otherwise, return max threads that string_server_used can provide
const integer_get_threads_grow = function(ns, float_server_used_ram_free, string_server_target, float_server_target_security, float_server_target_cash) {
  const string_grow = object_get_constants(ns).array_workers[1];
  const integer_threads_available = Math.trunc(float_server_used_ram_free / ns.getScriptRam(string_grow));
  const integer_threads_required = integer_get_threads_required_for_grow_maximum_cash(ns, string_server_target, float_server_target_security, float_server_target_cash);
  return integer_get_corrected_threads(ns, integer_threads_required, integer_threads_available);
};
// returns the security increase from the growth threads used. Adapted from `processSingleServerGrowth` in ServerHelpers.ts and `fortify` in Server.ts
const float_get_security_increase_from_grow = function(ns, integer_threads_grow) {
  return 2 * object_get_constants(ns).ServerFortifyAmount * integer_threads_grow;
};
// hack stuff
// returns the percentage of the available cash in string_server_target that is stolen when it is hacked when it has float_server_target_security. adapted from calculatePercentMoneyHacked() in https://github.com/danielyxie/bitburner/blob/master/src/Hacking.js . See also `hackDifficulty` in https://github.com/danielyxie/bitburner/blob/master/src/Server.js
const float_get_percentage_of_cash_from_available_per_hack = function(ns, string_server_target, float_server_target_security) {
  const object_constants = object_get_constants(ns);
  const balanceFactor = 240;
  
  const difficultyMult = (100 - float_server_target_security) / 100;
  const skillMult = (ns.getHackingLevel() - (ns.getServerRequiredHackingLevel(string_server_target) - 1)) / ns.getHackingLevel();
  const percentMoneyHacked = difficultyMult * skillMult * object_constants.object_hacking_multipliers.money / balanceFactor;
  if (percentMoneyHacked < 0) { return 0; }  
  if (percentMoneyHacked > 1) { return 1; }
  return percentMoneyHacked * object_constants.object_bitnode_multipliers.ScriptHackMoney;
};
// returns the threads required to steal "float_percentage_to_steal" of available money in string_server_target
const integer_get_threads_required_to_hack_percentage = function(ns, string_server_target, float_server_target_security, float_percentage_to_steal) {
  return Math.ceil(float_percentage_to_steal / float_get_percentage_of_cash_from_available_per_hack(ns, string_server_target, float_server_target_security));
};
// returns the threads required to steal "float_percentage_to_steal" of available money in string_server_target if possible, otherwise, return max threads that string_server_used can provide
const integer_get_threads_hack = function(ns, float_server_used_ram_free, string_server_target, float_server_target_security, float_percentage_to_steal) {
  const string_hack = object_get_constants(ns).array_workers[2];
  const integer_threads_available = Math.trunc(float_server_used_ram_free / ns.getScriptRam(string_hack));
  const integer_threads_required = integer_get_threads_required_to_hack_percentage(ns, string_server_target, float_server_target_security, float_percentage_to_steal);
  return integer_get_corrected_threads(ns, integer_threads_required, integer_threads_available);
};
// returns the security increase from the hack threads. adapted from `hack` in NetscriptFunctions.js and `fortify` in Server.ts
const float_get_security_increase_from_hack = function(ns, string_server_target, float_server_target_security, float_server_target_cash, integer_threads_hack) {
  let maxThreadNeeded = Math.ceil(1/float_get_percentage_of_cash_from_available_per_hack(ns, string_server_target, float_server_target_security)*(float_server_target_cash/ns.getServerMaxMoney(string_server_target)));
  if (isNaN(maxThreadNeeded)) {
      // Server has a 'max money' of 0 (probably). We'll set this to an arbitrarily large value
      maxThreadNeeded = 1e6;
  }
  return object_get_constants(ns).ServerFortifyAmount * Math.min(integer_threads_hack, maxThreadNeeded);
};
// percentage to steal stuff
// returns the threads required by grow to grow a string_server_target's money back to its original value after stealing float_percentage_to_steal of it, and assuming security is at float_server_target_security
const integer_get_threads_required_for_cash_grow_after_percentage_stolen = function(ns, string_server_target, float_server_target_security, float_percentage_to_steal) {
  return integer_get_threads_for_growth(ns, string_server_target, float_server_target_security, Math.pow(1 - float_percentage_to_steal, -1));
};
// should return true if there is enough ram to provide the threads required by weaken to weaken to minimum security, then by grow to grow string_server_target's cash back to maximum after stealing float_percentage_to_steal of the cash, then by weaken to weaken to minimum security again if possible, otherwise, returns false. assumes security is at float_server_target_security
const boolean_is_ram_enough_after_hack_percentage = function(ns, float_server_used_ram_free, string_server_target, float_server_target_cash, float_server_target_security, float_percentage_to_steal) {
  const string_weaken = object_get_constants(ns).array_workers[0];
  const string_grow = object_get_constants(ns).array_workers[1];
  const float_server_target_security_after_hack = float_server_target_security + float_get_security_increase_from_hack(ns, string_server_target, float_server_target_security, float_server_target_cash, integer_get_threads_hack(ns, float_server_used_ram_free, string_server_target, float_server_target_security, float_percentage_to_steal));
  const integer_threads_required_for_weaken_minimum_security_after_hack = integer_get_threads_required_for_weaken_minimum_security(ns, string_server_target, float_server_target_security_after_hack);
  const float_server_target_security_after_weaken = float_server_target_security_after_hack - float_get_security_decrease_from_weaken(ns, integer_threads_required_for_weaken_minimum_security_after_hack);
  const integer_threads_required_for_cash_grow_after_percentage_stolen = integer_get_threads_required_for_cash_grow_after_percentage_stolen(ns, string_server_target, float_server_target_security_after_weaken, float_percentage_to_steal);
  const float_server_target_security_after_grow = float_server_target_security_after_weaken + float_get_security_increase_from_grow(ns,integer_threads_required_for_cash_grow_after_percentage_stolen);
  const integer_threads_required_for_weaken_minimum_security_after_grow = integer_get_threads_required_for_weaken_minimum_security(ns, string_server_target, float_server_target_security_after_grow);
  const float_ram_required = (integer_threads_required_for_weaken_minimum_security_after_hack * ns.getScriptRam(string_weaken)) + (integer_threads_required_for_cash_grow_after_percentage_stolen * ns.getScriptRam(string_grow)) + (integer_threads_required_for_weaken_minimum_security_after_grow * ns.getScriptRam(string_weaken));
  
  if (float_ram_required < float_server_used_ram_free) {
    return true;
  }
  else {
    return false;
  }
};
// returns the number of cycles of bisection to be done to reach a certain precision, rounded up to the nearest integer
const integer_get_cycles_for_bisection_precision = function(ns, float_precision) {
  return Math.ceil(Math.log(Math.pow(float_precision, -1)) * Math.pow(Math.log(2), -1));
};
// this should return optimum percentage to steal such that cash stolen at most is as high as float_steal_cap and string_server_target's security is able to be weakened to minimum with one weaken after the hack, its cash grown to 100% after one grow after the weaken, then its security weakened again to minimum with one weaken, all with the ram it has remaining after the hack by using a binary search algorithm
const float_get_percentage_to_steal = function(ns, float_server_used_ram_free, string_server_target, float_server_target_cash, float_server_target_security, float_precision, float_steal_cap) {
  const integer_cycles_for_bisection_precision = integer_get_cycles_for_bisection_precision(ns, float_precision);
  let float_ceiling = 1;
  let float_floor = 0;
  let float_percentage_to_steal = (float_ceiling + float_floor) * 0.5;
  for (let integer_indices_0 = 0; integer_indices_0 < integer_cycles_for_bisection_precision; ++integer_indices_0) {
    if (boolean_is_ram_enough_after_hack_percentage(ns, float_server_used_ram_free, string_server_target, float_server_target_cash, float_server_target_security, float_percentage_to_steal)) {
      float_floor = float_percentage_to_steal;
    }
    else {
      float_ceiling = float_percentage_to_steal;
    }
    float_percentage_to_steal = (float_ceiling + float_floor) * 0.5;
    if (float_percentage_to_steal > float_steal_cap) {
      break;
    }
  }
  // cap which can be used so not all money is stolen, which can be bad because it's harder to grow from 0 in most cases
  if (float_percentage_to_steal > float_steal_cap) {
    return float_steal_cap;
  }
  else {
    return float_percentage_to_steal;
  }
};
// scheduling
const array_get_servers_rooted_sorted_by_score = function(ns) {
  let array_servers_rooted = array_get_servers_rooted(ns);
  void_sort_by_server_scores(ns, array_servers_rooted);
  return array_servers_rooted;
};
const string_get_server_rooted_hackable_with_score_biggest = function(ns) {
  const array_servers_rooted_sorted_by_score = array_get_servers_rooted_sorted_by_score(ns);
  // iterate through array in reverse
  for (let integer_indices_0 = array_servers_rooted_sorted_by_score.length - 1; integer_indices_0 >= 0; --integer_indices_0) {
    const string_server_target = array_servers_rooted_sorted_by_score[integer_indices_0];
    if (ns.getHackingLevel() >= ns.getServerRequiredHackingLevel(string_server_target)) {
      return string_server_target;
    }
  }
};
const string_job_decider_prepare = function(ns, string_server_target, float_server_target_security, float_server_target_cash) {
  if (float_server_target_security > ns.getServerMinSecurityLevel(string_server_target)) {
    return "weaken";
  }
  if (float_server_target_cash < ns.getServerMaxMoney(string_server_target)) {
    return "grow";
  }
  return "";
};
const string_job_decider = function(ns, string_server_target, float_server_target_security, float_server_target_cash) {
  if (float_server_target_security > ns.getServerMinSecurityLevel(string_server_target)) {
    return "weaken";
  }
  else {
    if (float_server_target_cash < ns.getServerMaxMoney(string_server_target)) {
      return "grow";
    }
    else {
      return "hack";
    }
  }
};
const boolean_can_server_run_script_threads = function(ns, float_server_used_ram_free, float_script_ram, integer_threads) {
  if (float_script_ram * integer_threads > float_server_used_ram_free) {
    return false;
  }
  else {
    return true;
  }
};
// Returns time it takes to complete a hack on a server, in seconds. Adapted from `calculateHackingTime` in Hacking.js 
const float_get_time_hack = function(ns, string_server_target, float_server_target_security) {
  const object_constants = object_get_constants(ns);
  const difficultyMult = ns.getServerRequiredHackingLevel(string_server_target) * float_server_target_security;
  const baseDiff      = 500;
  const baseSkill     = 50;
  const diffFactor    = 2.5;
  const intFactor     = 0.1;
  const hack_stat = object_constants.object_stats.hacking;
  const int = object_constants.object_stats.intelligence;
  var skillFactor = (diffFactor * difficultyMult + baseDiff);
  // tslint:disable-next-line
  skillFactor /= (hack_stat + baseSkill + (intFactor * int));
  const hackTimeMultiplier = 5;
  const hackingTime = hackTimeMultiplier * skillFactor / object_constants.object_hacking_multipliers.speed;
  return hackingTime;
};
// Returns time it takes to complete a grow operation on a server, in seconds. Adapted from `calculateGrowTime` in Hacking.js
const float_get_time_grow = function(ns, string_server_target, float_server_target_security) {
  const growTimeMultiplier = 3.2; // Relative to hacking time. 16/5 = 3.2
  return growTimeMultiplier * float_get_time_hack(ns, string_server_target, float_server_target_security);
};
// Returns time it takes to complete a weaken operation on a server, in seconds. Adapted from `calculateHackingTime` in Hacking.js
const float_get_time_weaken = function(ns, string_server_target, float_server_target_security) {
  const weakenTimeMultiplier = 4; // Relative to hacking time
  return weakenTimeMultiplier * float_get_time_hack(ns, string_server_target, float_server_target_security);
};
// makes a schedule
const array_make_schedule = function(ns, integer_job_cap, float_precision, float_steal_cap, float_padding_seconds, string_server_target, string_decider) {
  const array_workers = object_get_constants(ns).array_workers;
  const string_weaken = array_workers[0];
  const string_grow = array_workers[1];
  const string_hack = array_workers[2];
  const array_servers_rooted_sorted_by_ram = array_get_servers_rooted_sorted_by_ram(ns);
  const float_server_target_security_minimum = ns.getServerMinSecurityLevel(string_server_target);
  const float_server_target_cash_maximum = ns.getServerMaxMoney(string_server_target);
  const float_time_weaken = float_get_time_weaken(ns, string_server_target, ns.getServerSecurityLevel(string_server_target));
  const float_time_grow = float_get_time_grow(ns, string_server_target, ns.getServerSecurityLevel(string_server_target));
  const float_time_hack = float_get_time_hack(ns, string_server_target, ns.getServerSecurityLevel(string_server_target));
  // tripwires
  let boolean_end_loop_array_servers = false;
  let boolean_end_loop_server = false;
  let float_server_target_security_current = ns.getServerSecurityLevel(string_server_target);
  let float_server_target_cash_current = ns.getServerMoneyAvailable(string_server_target);
  let array_schedule = [];
  let integer_array_schedule_length = 0;
  let integer_time_job_finishes_seconds = Math.max(float_time_weaken, float_time_grow, float_time_hack);
  // iterate through servers in reverse to use servers with the biggest rams first
  for (let integer_indices_0 = array_servers_rooted_sorted_by_ram.length - 1; integer_indices_0 >= 0; --integer_indices_0) {
    if (integer_array_schedule_length >= integer_job_cap ||
      boolean_end_loop_array_servers) {
      break;
    }
    const string_server_used = array_servers_rooted_sorted_by_ram[integer_indices_0];
    let float_server_used_ram_free_current = float_get_server_ram_free(ns, string_server_used);
    while (
      float_server_used_ram_free_current > 0 &&
      integer_array_schedule_length < integer_job_cap &&
      !boolean_end_loop_array_servers &&
      !boolean_end_loop_server
    ) {
      const string_job = string_decider(ns, string_server_target, float_server_target_security_current, float_server_target_cash_current);
      const schedule_item = {
        string_job: string_job,
        string_server_used: string_server_used,
        string_server_target: string_server_target,
        float_server_target_security_before: float_server_target_security_current,
        float_server_target_cash_before: float_server_target_cash_current
      };
      switch (string_job) {
        case "": {
          boolean_end_loop_array_servers = true;
          break;
        }
        case "weaken": {
          if (!boolean_can_server_run_script_threads(ns, float_server_used_ram_free_current, ns.getScriptRam(string_weaken), 1)) {
            // start using a server with more ram
            boolean_end_loop_server = true;
            break;
          }
          const integer_threads_weaken = integer_get_threads_weaken(ns, float_server_used_ram_free_current, string_server_target, float_server_target_security_current);
          float_server_used_ram_free_current -= integer_threads_weaken * ns.getScriptRam(string_weaken);
          
          const float_server_target_security_uncorrected = float_server_target_security_current - float_get_security_decrease_from_weaken(ns, integer_threads_weaken);
          if (float_server_target_security_uncorrected < float_server_target_security_minimum) {
            float_server_target_security_current = float_server_target_security_minimum;
          }
          else {
            float_server_target_security_current = float_server_target_security_uncorrected;
          }
          schedule_item.float_server_target_security_current = float_server_target_security_current;
          schedule_item.float_delay_seconds = integer_time_job_finishes_seconds - float_time_weaken + float_padding_seconds;
          integer_time_job_finishes_seconds += float_padding_seconds;
          schedule_item.integer_time_job_finishes_seconds = integer_time_job_finishes_seconds;
          schedule_item.integer_threads = integer_threads_weaken;
          array_schedule.push(schedule_item);
          ++integer_array_schedule_length;
          break;
        }
        case "grow": {
          if (!boolean_can_server_run_script_threads(ns, float_server_used_ram_free_current, ns.getScriptRam(string_grow), 1)) {
            // start using a server with more ram
            boolean_end_loop_server = true;
            break;
          }
          if (float_server_target_cash_current === 0) {
            float_server_target_cash_current = 1; // counts 0 cash as 1 so it can still grow. taken from `grow` in NetscriptFunctions.js
          }
          const integer_threads_grow = integer_get_threads_grow(ns, float_server_used_ram_free_current, string_server_target, float_server_target_security_current, float_server_target_cash_current);
          float_server_used_ram_free_current -= integer_threads_grow * ns.getScriptRam(string_grow);
          const float_server_target_cash_current_uncorrected = float_server_target_cash_current * float_get_growth_from_threads(ns, string_server_target, float_server_target_security_current, integer_threads_grow);
          if (float_server_target_cash_current_uncorrected > float_server_target_cash_maximum) {
            float_server_target_cash_current = float_server_target_cash_maximum;
          }
          else {
            float_server_target_cash_current = float_server_target_cash_current_uncorrected;
          }
          // the following is adapted from `processSingleServerGrowth` in ServerHelpers.ts and `fortify` in Server.ts
          float_server_target_security_current += float_get_security_increase_from_grow(ns, integer_threads_grow);
          schedule_item.float_server_target_security_current = float_server_target_security_current;
          schedule_item.float_delay_seconds = integer_time_job_finishes_seconds - float_time_grow + float_padding_seconds;
          integer_time_job_finishes_seconds += float_padding_seconds;
          schedule_item.integer_time_job_finishes_seconds = integer_time_job_finishes_seconds;
          schedule_item.integer_threads = integer_threads_grow;
          array_schedule.push(schedule_item);
          ++integer_array_schedule_length;
          break;
        }
        case "hack": {
          if (!boolean_can_server_run_script_threads(ns, float_server_used_ram_free_current, ns.getScriptRam(string_hack), 1)) {
            // start using a server with more ram
            boolean_end_loop_server = true;
            break;
          }
          const integer_threads_hack = integer_get_threads_hack(ns, float_server_used_ram_free_current, string_server_target, float_server_target_security_current, float_get_percentage_to_steal(ns, float_server_used_ram_free_current, string_server_target, float_server_target_cash_current, float_server_target_security_current, float_precision, float_steal_cap));
          float_server_used_ram_free_current -= integer_threads_hack * ns.getScriptRam(string_hack);
          // the following is adapted from `hack` in NetscriptFunctions.js and `fortify` in Server.ts
          const float_server_target_cash_before = float_server_target_cash_current;
          
          const float_server_target_cash_current_uncorrected = float_server_target_cash_current - Math.floor(float_server_target_cash_current * float_get_percentage_of_cash_from_available_per_hack(ns, string_server_target, float_server_target_security_current)) * integer_threads_hack;
          if (float_server_target_cash_current_uncorrected < 0) {
            float_server_target_cash_current = 0;
          }
          else {
            float_server_target_cash_current = float_server_target_cash_current_uncorrected;
          }
          float_server_target_security_current += float_get_security_increase_from_hack(ns, string_server_target, float_server_target_security_current, float_server_target_cash_before, integer_threads_hack);
          schedule_item.float_server_target_security_current = float_server_target_security_current;
          schedule_item.float_delay_seconds = integer_time_job_finishes_seconds - float_time_hack + float_padding_seconds;
          integer_time_job_finishes_seconds += float_padding_seconds;
          schedule_item.integer_time_job_finishes_seconds = integer_time_job_finishes_seconds;
          schedule_item.integer_threads = integer_threads_hack;
          array_schedule.push(schedule_item);
          ++integer_array_schedule_length;
          break;
        }
      }
    }
  }
  // remove jobs near the end that cause security to not equal minimum. in other words, the target should have minimum security when the schedule finishes. this is to make the jobs in the next schedule run as quick as possible. TODO: make it so that we don't have to do this deleting step, instead, the array making steps above should already take into this into account and don't make more items than is needed.
  let array_schedule_edited = array_schedule;
  let boolean_have_not_seen_item_with_security_minimum = true;
  while (boolean_have_not_seen_item_with_security_minimum) {
    for (let integer_indices_1 = array_schedule_edited.length - 1; integer_indices_1 >= 0; --integer_indices_1) {
      if (!boolean_have_not_seen_item_with_security_minimum) {
        break;
      }
      const object_job = array_schedule_edited[integer_indices_1];
      if (object_job.float_server_target_security_current === float_server_target_security_minimum) {
        boolean_have_not_seen_item_with_security_minimum = false;
        break;
      }
      else {
        array_schedule_edited.splice(integer_indices_1, 1);
      }
    }
  }
  if (boolean_have_not_seen_item_with_security_minimum) {
    return array_schedule;
  }
  else {
    return array_schedule_edited;
  }
};
const void_schedule_runner = async function(ns, array_schedule) {
  const array_workers = object_get_constants(ns).array_workers;
  for (let integer_indices_0 = 0; integer_indices_0 < array_schedule.length; ++integer_indices_0) {
    const string_job = array_schedule[integer_indices_0].string_job;
    const string_server_used = array_schedule[integer_indices_0].string_server_used;
    const string_server_target = array_schedule[integer_indices_0].string_server_target;
    const integer_threads = array_schedule[integer_indices_0].integer_threads;
    const float_delay = array_schedule[integer_indices_0].float_delay_seconds * 1000;
    const identifier = integer_indices_0;
    let string_script = "";
    switch (string_job) {
      case "weaken": {
        string_script = array_workers[0];
        break;
      }
      case "grow": {
        string_script = array_workers[1];
        break;
      }
      case "hack": {
        string_script = array_workers[2];
        break;
      }
    }
    await ns.exec(string_script, string_server_used, integer_threads, string_server_used, string_server_target, float_delay, identifier);
  }
};
// returns the the time it'll take to finish in milliseconds.
const void_runner = async function(ns, integer_job_cap, float_precision, float_steal_cap, float_padding_seconds, string_server_target_argument) {
  let integer_time_start = Date.now();
  let string_server_target = string_server_target_argument;
  if (string_server_target_argument === "") {
    string_server_target = string_get_server_rooted_hackable_with_score_biggest(ns);
  }
  // prepare the target if necessary
  while (true) {
    if (
      ns.getServerSecurityLevel(string_server_target) === ns.getServerMinSecurityLevel(string_server_target) &&
      ns.getServerMoneyAvailable(string_server_target) === ns.getServerMaxMoney(string_server_target)
    ) {
      break;
    }
    const array_schedule_prepare = array_make_schedule(ns, integer_job_cap, float_precision, float_steal_cap, float_padding_seconds, string_server_target, string_job_decider_prepare);
    if (array_schedule_prepare.length > 0) {
      await void_schedule_runner(ns, array_schedule_prepare);
      await ns.sleep((array_schedule_prepare[array_schedule_prepare.length - 1].integer_time_job_finishes_seconds * 1000) - integer_time_start + Date.now());
    }
  }
  // make and run actual hacking schedule
  const array_schedule = array_make_schedule(ns, integer_job_cap, float_precision, float_steal_cap, float_padding_seconds, string_server_target, string_job_decider);
  await void_schedule_runner(ns, array_schedule);
  return (array_schedule[array_schedule.length - 1].integer_time_job_finishes_seconds * 1000) - integer_time_start + Date.now();
};

export const main = async function(ns) {
  await ns.sleep(ns.args[2]);
//  const start = Date.now();
//  const s = new Date(start);
  await ns.hack(ns.args[1]);
//  const finish = Date.now();
//  const f = new Date(finish);
//  ns.tprint("\t#" + ns.args[3] + "\t" + ns.args[0] + " hacking " + ns.args[1] + "\nHack started:\t\t" + s.toISOString() + "\nHack finished:\t\t" + f.toISOString());
};

export const main = async function(ns) {
  await ns.sleep(ns.args[2]);
//  const start = Date.now();
//  const s = new Date(start);
  await ns.grow(ns.args[1]);
//  const finish = Date.now();
//  const f = new Date(finish);
//  ns.tprint("\t#" + ns.args[3] + "\t" + ns.args[0] + " growing " + ns.args[1] + "\nGrow started:\t\t" + s.toISOString() + "\nGrow finished:\t\t" + f.toISOString());
};

export const main = async function (ns) {
  for (;;) await ns.weaken(ns.args[0]), await ns.sleep(1);
};

// botnet.js - 2.15GB - opens ports and nukes any unrooted servers if the player's hacking level is high enough to do so and the appropriate number of object_exploits are present
export const main = async function(ns) {
  const float_period_check = ns.args[0] * 1000;
  const object_get_constants = function(ns) {
    // object_constants are from https://github.com/danielyxie/bitburner/blob/master/src/Constants.js
    const object_constants = {
      // filenames and related functions of exploits
      array_exploits: [ns.brutessh, ns.ftpcrack, ns.relaysmtp, ns.httpworm, ns.sqlinject],
      // name of current host (usually "home")
      string_host: "home" // or ns.getHostname()
    };
    return object_constants;
  };  
  // returns an array of all servers in the game
  const array_get_servers = function(ns) {
    const string_host = object_get_constants(ns).string_host;
    const array_servers = [string_host];
    for (let integer_indices_0 = 0; integer_indices_0 < array_servers.length; ++integer_indices_0) {
      const array_scan_results = ns.scan(array_servers[integer_indices_0]);
      for (let integer_indices_1 = 0; integer_indices_1 < array_scan_results.length; ++integer_indices_1) {
        if (array_servers.indexOf(array_scan_results[integer_indices_1]) === -1) {
          array_servers.push(array_scan_results[integer_indices_1]);
        }
      }
    }
    return array_servers;
  };
  
  // returns an array of all servers that are yet to be rooted
  const array_get_servers_unrooted = function(ns) {
    const array_servers = array_get_servers(ns);
    const array_servers_unrooted = [];
    for (let integer_indices_0 = 0; integer_indices_0 < array_servers.length; ++integer_indices_0) {
      if (!ns.hasRootAccess(array_servers[integer_indices_0])) {
        array_servers_unrooted.push(array_servers[integer_indices_0]);
      }
    }
    return array_servers_unrooted;
  };
  
  // tries to open ports of server
  const void_open_ports_try = function(ns, string_server_target) {
    const array_exploits = object_get_constants(ns).array_exploits;
    for (let integer_indices_0 = 0; integer_indices_0 < array_exploits.length; ++integer_indices_0) {
      const string_exploit_function = array_exploits[integer_indices_0];
      try {
        string_exploit_function(string_server_target);
      }
      catch (error) {
        ns.print(JSON.stringify(error));
      }
    }
  };
  while(true) {
    const array_servers_unrooted = array_get_servers_unrooted(ns);
    if (array_servers_unrooted.length === 0) {
      break;
    }
    for (let integer_indices_0 = 0; integer_indices_0 < array_servers_unrooted.length; ++integer_indices_0) {
      const string_server_unrooted = array_servers_unrooted[integer_indices_0];
      void_open_ports_try(ns, string_server_unrooted);
      try {
        ns.nuke(string_server_unrooted);
      } catch (error) {
        ns.print(JSON.stringify(error));
      }
    }
    await ns.sleep(float_period_check);
  }
};

{
  "name": "bitburner_scripts",
  "version": "0.1.0",
  "description": "Scripts for the game \"Bitburner\".",
  "main": "index.js",
  "dependencies": {
    "http-server": "^0.12.3"
  },
  "devDependencies": {},
  "scripts": {
    "start": "http-server -p 8080 -a 127.0.0.1 --cors -c-1",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "bitburner",
    "netscript"
  ],
  "author": "Jesse Ira Abadilla",
  "license": "BlueOak-1.0.0"
}

{
  "name": "a",
  "version": "0.1.0",
  "lockfileVersion": 2,
  "requires": true,
  "packages": {
    "": {
      "name": "a",
      "dependencies": {
        "http-server": "^0.12.3"
      },
      "devDependencies": {}
    },
    "node_modules/async": {
      "version": "2.6.3",
      "resolved": "https://registry.npmjs.org/async/-/async-2.6.3.tgz",
      "integrity": "sha512-zflvls11DCy+dQWzTW2dzuilv8Z5X/pjfmZOWba6TNIVDm+2UDaJmXSOXlasHKfNBs8oo3M0aT50fDEWfKZjXg==",
      "dependencies": {
        "lodash": "^4.17.14"
      }
    },
    "node_modules/basic-auth": {
      "version": "1.1.0",
      "resolved": "https://registry.npmjs.org/basic-auth/-/basic-auth-1.1.0.tgz",
      "integrity": "sha1-RSIe5Cn37h5QNb4/UVM/HN/SmIQ=",
      "engines": {
        "node": ">= 0.6"
      }
    },
    "node_modules/colors": {
      "version": "1.4.0",
      "resolved": "https://registry.npmjs.org/colors/-/colors-1.4.0.tgz",
      "integrity": "sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==",
      "engines": {
        "node": ">=0.1.90"
      }
    },
    "node_modules/corser": {
      "version": "2.0.1",
      "resolved": "https://registry.npmjs.org/corser/-/corser-2.0.1.tgz",
      "integrity": "sha1-jtolLsqrWEDc2XXOuQ2TcMgZ/4c=",
      "engines": {
        "node": ">= 0.4.0"
      }
    },
    "node_modules/debug": {
      "version": "3.2.7",
      "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
      "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
      "dependencies": {
        "ms": "^2.1.1"
      }
    },
    "node_modules/ecstatic": {
      "version": "3.3.2",
      "resolved": "https://registry.npmjs.org/ecstatic/-/ecstatic-3.3.2.tgz",
      "integrity": "sha512-fLf9l1hnwrHI2xn9mEDT7KIi22UDqA2jaCwyCbSUJh9a1V+LEUSL/JO/6TIz/QyuBURWUHrFL5Kg2TtO1bkkog==",
      "dependencies": {
        "he": "^1.1.1",
        "mime": "^1.6.0",
        "minimist": "^1.1.0",
        "url-join": "^2.0.5"
      },
      "bin": {
        "ecstatic": "lib/ecstatic.js"
      }
    },
    "node_modules/eventemitter3": {
      "version": "4.0.7",
      "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz",
      "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw=="
    },
    "node_modules/follow-redirects": {
      "version": "1.13.1",
      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.13.1.tgz",
      "integrity": "sha512-SSG5xmZh1mkPGyKzjZP8zLjltIfpW32Y5QpdNJyjcfGxK3qo3NDDkZOZSFiGn1A6SclQxY9GzEwAHQ3dmYRWpg==",
      "engines": {
        "node": ">=4.0"
      }
    },
    "node_modules/he": {
      "version": "1.2.0",
      "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz",
      "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==",
      "bin": {
        "he": "bin/he"
      }
    },
    "node_modules/http-proxy": {
      "version": "1.18.1",
      "resolved": "https://registry.npmjs.org/http-proxy/-/http-proxy-1.18.1.tgz",
      "integrity": "sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==",
      "dependencies": {
        "eventemitter3": "^4.0.0",
        "follow-redirects": "^1.0.0",
        "requires-port": "^1.0.0"
      },
      "engines": {
        "node": ">=8.0.0"
      }
    },
    "node_modules/http-server": {
      "version": "0.12.3",
      "resolved": "https://registry.npmjs.org/http-server/-/http-server-0.12.3.tgz",
      "integrity": "sha512-be0dKG6pni92bRjq0kvExtj/NrrAd28/8fCXkaI/4piTwQMSDSLMhWyW0NI1V+DBI3aa1HMlQu46/HjVLfmugA==",
      "dependencies": {
        "basic-auth": "^1.0.3",
        "colors": "^1.4.0",
        "corser": "^2.0.1",
        "ecstatic": "^3.3.2",
        "http-proxy": "^1.18.0",
        "minimist": "^1.2.5",
        "opener": "^1.5.1",
        "portfinder": "^1.0.25",
        "secure-compare": "3.0.1",
        "union": "~0.5.0"
      },
      "bin": {
        "hs": "bin/http-server",
        "http-server": "bin/http-server"
      },
      "engines": {
        "node": ">=6"
      }
    },
    "node_modules/lodash": {
      "version": "4.17.20",
      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.20.tgz",
      "integrity": "sha512-PlhdFcillOINfeV7Ni6oF1TAEayyZBoZ8bcshTHqOYJYlrqzRK5hagpagky5o4HfCzzd1TRkXPMFq6cKk9rGmA=="
    },
    "node_modules/mime": {
      "version": "1.6.0",
      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
      "bin": {
        "mime": "cli.js"
      },
      "engines": {
        "node": ">=4"
      }
    },
    "node_modules/minimist": {
      "version": "1.2.5",
      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz",
      "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw=="
    },
    "node_modules/mkdirp": {
      "version": "0.5.5",
      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.5.tgz",
      "integrity": "sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==",
      "dependencies": {
        "minimist": "^1.2.5"
      },
      "bin": {
        "mkdirp": "bin/cmd.js"
      }
    },
    "node_modules/ms": {
      "version": "2.1.3",
      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
    },
    "node_modules/opener": {
      "version": "1.5.2",
      "resolved": "https://registry.npmjs.org/opener/-/opener-1.5.2.tgz",
      "integrity": "sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A==",
      "bin": {
        "opener": "bin/opener-bin.js"
      }
    },
    "node_modules/portfinder": {
      "version": "1.0.28",
      "resolved": "https://registry.npmjs.org/portfinder/-/portfinder-1.0.28.tgz",
      "integrity": "sha512-Se+2isanIcEqf2XMHjyUKskczxbPH7dQnlMjXX6+dybayyHvAf/TCgyMRlzf/B6QDhAEFOGes0pzRo3by4AbMA==",
      "dependencies": {
        "async": "^2.6.2",
        "debug": "^3.1.1",
        "mkdirp": "^0.5.5"
      },
      "engines": {
        "node": ">= 0.12.0"
      }
    },
    "node_modules/qs": {
      "version": "6.9.4",
      "resolved": "https://registry.npmjs.org/qs/-/qs-6.9.4.tgz",
      "integrity": "sha512-A1kFqHekCTM7cz0udomYUoYNWjBebHm/5wzU/XqrBRBNWectVH0QIiN+NEcZ0Dte5hvzHwbr8+XQmguPhJ6WdQ==",
      "engines": {
        "node": ">=0.6"
      }
    },
    "node_modules/requires-port": {
      "version": "1.0.0",
      "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz",
      "integrity": "sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8="
    },
    "node_modules/secure-compare": {
      "version": "3.0.1",
      "resolved": "https://registry.npmjs.org/secure-compare/-/secure-compare-3.0.1.tgz",
      "integrity": "sha1-8aAymzCLIh+uN7mXTz1XjQypmeM="
    },
    "node_modules/union": {
      "version": "0.5.0",
      "resolved": "https://registry.npmjs.org/union/-/union-0.5.0.tgz",
      "integrity": "sha512-N6uOhuW6zO95P3Mel2I2zMsbsanvvtgn6jVqJv4vbVcz/JN0OkL9suomjQGmWtxJQXOCqUJvquc1sMeNz/IwlA==",
      "dependencies": {
        "qs": "^6.4.0"
      },
      "engines": {
        "node": ">= 0.8.0"
      }
    },
    "node_modules/url-join": {
      "version": "2.0.5",
      "resolved": "https://registry.npmjs.org/url-join/-/url-join-2.0.5.tgz",
      "integrity": "sha1-WvIvGMBSoACkjXuCxenC4v7tpyg="
    }
  },
  "dependencies": {
    "async": {
      "version": "2.6.3",
      "resolved": "https://registry.npmjs.org/async/-/async-2.6.3.tgz",
      "integrity": "sha512-zflvls11DCy+dQWzTW2dzuilv8Z5X/pjfmZOWba6TNIVDm+2UDaJmXSOXlasHKfNBs8oo3M0aT50fDEWfKZjXg==",
      "requires": {
        "lodash": "^4.17.14"
      }
    },
    "basic-auth": {
      "version": "1.1.0",
      "resolved": "https://registry.npmjs.org/basic-auth/-/basic-auth-1.1.0.tgz",
      "integrity": "sha1-RSIe5Cn37h5QNb4/UVM/HN/SmIQ="
    },
    "colors": {
      "version": "1.4.0",
      "resolved": "https://registry.npmjs.org/colors/-/colors-1.4.0.tgz",
      "integrity": "sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA=="
    },
    "corser": {
      "version": "2.0.1",
      "resolved": "https://registry.npmjs.org/corser/-/corser-2.0.1.tgz",
      "integrity": "sha1-jtolLsqrWEDc2XXOuQ2TcMgZ/4c="
    },
    "debug": {
      "version": "3.2.7",
      "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
      "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
      "requires": {
        "ms": "^2.1.1"
      }
    },
    "ecstatic": {
      "version": "3.3.2",
      "resolved": "https://registry.npmjs.org/ecstatic/-/ecstatic-3.3.2.tgz",
      "integrity": "sha512-fLf9l1hnwrHI2xn9mEDT7KIi22UDqA2jaCwyCbSUJh9a1V+LEUSL/JO/6TIz/QyuBURWUHrFL5Kg2TtO1bkkog==",
      "requires": {
        "he": "^1.1.1",
        "mime": "^1.6.0",
        "minimist": "^1.1.0",
        "url-join": "^2.0.5"
      }
    },
    "eventemitter3": {
      "version": "4.0.7",
      "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz",
      "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw=="
    },
    "follow-redirects": {
      "version": "1.13.1",
      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.13.1.tgz",
      "integrity": "sha512-SSG5xmZh1mkPGyKzjZP8zLjltIfpW32Y5QpdNJyjcfGxK3qo3NDDkZOZSFiGn1A6SclQxY9GzEwAHQ3dmYRWpg=="
    },
    "he": {
      "version": "1.2.0",
      "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz",
      "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw=="
    },
    "http-proxy": {
      "version": "1.18.1",
      "resolved": "https://registry.npmjs.org/http-proxy/-/http-proxy-1.18.1.tgz",
      "integrity": "sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==",
      "requires": {
        "eventemitter3": "^4.0.0",
        "follow-redirects": "^1.0.0",
        "requires-port": "^1.0.0"
      }
    },
    "http-server": {
      "version": "0.12.3",
      "resolved": "https://registry.npmjs.org/http-server/-/http-server-0.12.3.tgz",
      "integrity": "sha512-be0dKG6pni92bRjq0kvExtj/NrrAd28/8fCXkaI/4piTwQMSDSLMhWyW0NI1V+DBI3aa1HMlQu46/HjVLfmugA==",
      "requires": {
        "basic-auth": "^1.0.3",
        "colors": "^1.4.0",
        "corser": "^2.0.1",
        "ecstatic": "^3.3.2",
        "http-proxy": "^1.18.0",
        "minimist": "^1.2.5",
        "opener": "^1.5.1",
        "portfinder": "^1.0.25",
        "secure-compare": "3.0.1",
        "union": "~0.5.0"
      }
    },
    "lodash": {
      "version": "4.17.20",
      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.20.tgz",
      "integrity": "sha512-PlhdFcillOINfeV7Ni6oF1TAEayyZBoZ8bcshTHqOYJYlrqzRK5hagpagky5o4HfCzzd1TRkXPMFq6cKk9rGmA=="
    },
    "mime": {
      "version": "1.6.0",
      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg=="
    },
    "minimist": {
      "version": "1.2.5",
      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz",
      "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw=="
    },
    "mkdirp": {
      "version": "0.5.5",
      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.5.tgz",
      "integrity": "sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==",
      "requires": {
        "minimist": "^1.2.5"
      }
    },
    "ms": {
      "version": "2.1.3",
      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
    },
    "opener": {
      "version": "1.5.2",
      "resolved": "https://registry.npmjs.org/opener/-/opener-1.5.2.tgz",
      "integrity": "sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A=="
    },
    "portfinder": {
      "version": "1.0.28",
      "resolved": "https://registry.npmjs.org/portfinder/-/portfinder-1.0.28.tgz",
      "integrity": "sha512-Se+2isanIcEqf2XMHjyUKskczxbPH7dQnlMjXX6+dybayyHvAf/TCgyMRlzf/B6QDhAEFOGes0pzRo3by4AbMA==",
      "requires": {
        "async": "^2.6.2",
        "debug": "^3.1.1",
        "mkdirp": "^0.5.5"
      }
    },
    "qs": {
      "version": "6.9.4",
      "resolved": "https://registry.npmjs.org/qs/-/qs-6.9.4.tgz",
      "integrity": "sha512-A1kFqHekCTM7cz0udomYUoYNWjBebHm/5wzU/XqrBRBNWectVH0QIiN+NEcZ0Dte5hvzHwbr8+XQmguPhJ6WdQ=="
    },
    "requires-port": {
      "version": "1.0.0",
      "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz",
      "integrity": "sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8="
    },
    "secure-compare": {
      "version": "3.0.1",
      "resolved": "https://registry.npmjs.org/secure-compare/-/secure-compare-3.0.1.tgz",
      "integrity": "sha1-8aAymzCLIh+uN7mXTz1XjQypmeM="
    },
    "union": {
      "version": "0.5.0",
      "resolved": "https://registry.npmjs.org/union/-/union-0.5.0.tgz",
      "integrity": "sha512-N6uOhuW6zO95P3Mel2I2zMsbsanvvtgn6jVqJv4vbVcz/JN0OkL9suomjQGmWtxJQXOCqUJvquc1sMeNz/IwlA==",
      "requires": {
        "qs": "^6.4.0"
      }
    },
    "url-join": {
      "version": "2.0.5",
      "resolved": "https://registry.npmjs.org/url-join/-/url-join-2.0.5.tgz",
      "integrity": "sha1-WvIvGMBSoACkjXuCxenC4v7tpyg="
    }
  }
}

var urljoin = require('../lib/url-join');
describe('url join', function () {
  it('should work for simple case', function () {
    urljoin('http://www.google.com/', 'foo/bar', '?test=123')
      .should.eql('http://www.google.com/foo/bar?test=123');
  });
  it('should work for simple case with new syntax', function () {
    urljoin(['http://www.google.com/', 'foo/bar', '?test=123'])
      .should.eql('http://www.google.com/foo/bar?test=123');
  });
  it('should work for hashbang urls', function () {
    urljoin(['http://www.google.com', '#!', 'foo/bar', '?test=123'])
      .should.eql('http://www.google.com/#!/foo/bar?test=123');
  });
  it('should be able to join protocol', function () {
    urljoin('http:', 'www.google.com/', 'foo/bar', '?test=123')
      .should.eql('http://www.google.com/foo/bar?test=123');
  });
  it('should be able to join protocol with slashes', function () {
    urljoin('http://', 'www.google.com/', 'foo/bar', '?test=123')
      .should.eql('http://www.google.com/foo/bar?test=123');
  });
  it('should remove extra slashes', function () {
    urljoin('http:', 'www.google.com///', 'foo/bar', '?test=123')
      .should.eql('http://www.google.com/foo/bar?test=123');
  });
  it('should not remove extra slashes in an encoded URL', function () {
    urljoin('http:', 'www.google.com///', 'foo/bar', '?url=http%3A//Ftest.com')
      .should.eql('http://www.google.com/foo/bar?url=http%3A//Ftest.com');
    urljoin('http://a.com/23d04b3/', '/b/c.html')
      .should.eql('http://a.com/23d04b3/b/c.html')
      .should.not.eql('http://a.com/23d04b3//b/c.html');
  });
  it('should support anchors in urls', function () {
    urljoin('http:', 'www.google.com///', 'foo/bar', '?test=123', '#faaaaa')
      .should.eql('http://www.google.com/foo/bar?test=123#faaaaa');
  });
  it('should support protocol-relative urls', function () {
    urljoin('//www.google.com', 'foo/bar', '?test=123')
      .should.eql('//www.google.com/foo/bar?test=123')
  });
  it('should support file protocol urls', function () {
    urljoin('file:/', 'android_asset', 'foo/bar')
      .should.eql('file://android_asset/foo/bar')
    urljoin('file:', '/android_asset', 'foo/bar')
      .should.eql('file://android_asset/foo/bar')
  });
  it('should support absolute file protocol urls', function () {
    urljoin('file:', '///android_asset', 'foo/bar')
      .should.eql('file:///android_asset/foo/bar')
    urljoin('file:///', 'android_asset', 'foo/bar')
      .should.eql('file:///android_asset/foo/bar')
    urljoin('file:///', '//android_asset', 'foo/bar')
      .should.eql('file:///android_asset/foo/bar')
    urljoin('file:///android_asset', 'foo/bar')
      .should.eql('file:///android_asset/foo/bar')
  });
  it.skip('should merge multiple query params properly', function () {
    urljoin('http:', 'www.google.com///', 'foo/bar', '?test=123', '?key=456')
      .should.eql('http://www.google.com/foo/bar?test=123&key=456');
    urljoin('http:', 'www.google.com///', 'foo/bar', '?test=123', '?boom=value', '&key=456')
      .should.eql('http://www.google.com/foo/bar?test=123&boom=value&key=456');
    urljoin('http://example.org/x', '?a=1', '?b=2', '?c=3', '?d=4')
      .should.eql('http://example.org/x?a=1&b=2&c=3&d=4');
  });
  //There is a problem with the capital A and the regex in the replace function
  // /([^:\s\%\3\A])\/+/g
  // I think the intention of the regex is to avoid replacing two slashes in the query string:
  // "?url=http%3A//"
  it.skip('should merge slashes in paths correctly', function () {
    urljoin('http://example.org', 'a//', 'b//', 'A//', 'B//')
      .should.eql('http://example.org/a/b/A/B/');
  });
  it.skip('should merge colons in paths correctly', function () {
    urljoin('http://example.org/', ':foo:', 'bar')
      .should.eql('http://example.org/:foo:/bar');
  });
  it.skip('should merge just a simple path without URL correctly', function() {
    urljoin('/', 'test')
      .should.eql('/test');
  });
  it('should merge a simple path with a number correctly', function() {
    urljoin('http://blabla.com/', 1)
      .should.eql('http://blabla.com/1');
  });
  it.skip('should merge slashes in protocol correctly', function () {
    urljoin('http://example.org', 'a')
      .should.eql('http://example.org/a');
    urljoin('http:', '//example.org', 'a')
      .should.eql('http://example.org/a');
    urljoin('http:///example.org', 'a')
      .should.eql('http://example.org/a');
    urljoin('file:///example.org', 'a')
      .should.eql('file:///example.org/a');
    //this one is broken
    urljoin('file:example.org', 'a')
      .should.eql('file://example.org/a');
    urljoin('file:/', 'example.org', 'a')
      .should.eql('file://example.org/a');
    urljoin('file:', '/example.org', 'a')
      .should.eql('file://example.org/a');
    urljoin('file:', '//example.org', 'a')
      .should.eql('file://example.org/a');
  });
});

{
  "_from": "url-join@^2.0.5",
  "_id": "url-join@2.0.5",
  "_inBundle": false,
  "_integrity": "sha1-WvIvGMBSoACkjXuCxenC4v7tpyg=",
  "_location": "/url-join",
  "_phantomChildren": {},
  "_requested": {
    "type": "range",
    "registry": true,
    "raw": "url-join@^2.0.5",
    "name": "url-join",
    "escapedName": "url-join",
    "rawSpec": "^2.0.5",
    "saveSpec": null,
    "fetchSpec": "^2.0.5"
  },
  "_requiredBy": [
    "/ecstatic"
  ],
  "_resolved": "https://registry.npmjs.org/url-join/-/url-join-2.0.5.tgz",
  "_shasum": "5af22f18c052a000a48d7b82c5e9c2e2feeda728",
  "_spec": "url-join@^2.0.5",
  "_where": "/home/a/documents/pijul/nicoty/bitburner_scripts/node_modules/ecstatic",
  "author": {
    "name": "José F. Romaniello",
    "email": "jfromaniello@gmail.com",
    "url": "http://joseoncode.com"
  },
  "bugs": {
    "url": "https://github.com/jfromaniello/url-join/issues"
  },
  "bundleDependencies": false,
  "deprecated": false,
  "description": "Join urls and normalize as in path.join.",
  "devDependencies": {
    "mocha": "^3.2.0",
    "should": "~1.2.1"
  },
  "homepage": "https://github.com/jfromaniello/url-join#readme",
  "keywords": [
    "url",
    "join"
  ],
  "license": "MIT",
  "main": "lib/url-join.js",
  "name": "url-join",
  "repository": {
    "type": "git",
    "url": "git://github.com/jfromaniello/url-join.git"
  },
  "scripts": {
    "test": "mocha --require should"
  },
  "version": "2.0.5"
}

(function (name, context, definition) {
  if (typeof module !== 'undefined' && module.exports) module.exports = definition();
  else if (typeof define === 'function' && define.amd) define(definition);
  else context[name] = definition();
})('urljoin', this, function () {
  function startsWith(str, searchString) {
    return str.substr(0, searchString.length) === searchString;
  }
  function normalize (str, options) {
    if (startsWith(str, 'file://')) {
      // make sure file protocol has max three slashes
      str = str.replace(/(\/{0,3})\/*/g, '$1');
    } else {
      // make sure protocol is followed by two slashes
      str = str.replace(/:\//g, '://');
      // remove consecutive slashes
      str = str.replace(/([^:\s\%\3\A])\/+/g, '$1/');
    }
    // remove trailing slash before parameters or hash
    str = str.replace(/\/(\?|&|#[^!])/g, '$1');
    // replace ? in parameters with &
    str = str.replace(/(\?.+)\?/g, '$1&');
    return str;
  }
  return function () {
    var input = arguments;
    var options = {};
    if (typeof arguments[0] === 'object') {
      // new syntax with array and options
      input = arguments[0];
      options = arguments[1] || {};
    }
    var joined = [].slice.call(input, 0).join('/');
    return normalize(joined, options);
  };
});

{
  "name": "url-join",
  "version": "2.0.5",
  "homepage": "https://github.com/jfromaniello/url-join",
  "authors": [
    "José F. Romaniello <jfromaniello@gmail.com>"
  ],
  "description": "Join urls and normalize as in path.join.",
  "main": "lib/url-join.js",
  "moduleType": [
    "amd",
    "globals",
    "node"
  ],
  "keywords": [
    "url",
    "join"
  ],
  "license": "MIT",
  "ignore": [
    "**/.*",
    "node_modules",
    "bower_components",
    "test",
    "tests"
  ]
}

Join all arguments together and normalize the resulting url.
## Install
~~~
npm install url-join
~~~
## Usage
~~~javascript
var urljoin = require('url-join');
var fullUrl = urljoin('http://www.google.com', 'a', '/b/cd', '?foo=123');
console.log(fullUrl);
~~~
Prints:
~~~
'http://www.google.com/a/b/cd?foo=123'
~~~
## Browser and AMD
It also works in the browser, you can either include ```lib/url-join.js``` in your page:
~~~html
<script src="url-join.js"></script>
<script type="text/javascript">
	urljoin('http://blabla.com', 'foo?a=1')
</script>
~~~
Or using an AMD module system like requirejs:
~~~javascript
define(['path/url-join.js'], function (urljoin) {
  urljoin('http://blabla.com', 'foo?a=1');
});
~~~
## License
MIT

MIT License
Copyright (c) 2015 José F. Romaniello
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

language: node_js
node_js:
  - "5"
  - "4"
  - "0.12"  

node_modules/*
*.log

var assert = require('assert'),
    fs = require('fs'),
    path = require('path'),
    request = require('request'),
    vows = require('vows'),
    union = require('../');
vows.describe('union/streaming').addBatch({
  'When using `union`': {
    'a simple union server': {
      topic: function () {
        var self = this;
        union.createServer({
          buffer: false,
          before: [
            function (req, res, next) {
              var chunks = '';
              req.on('data', function (chunk) {
                chunks += chunk;
              });
              req.on('end', function () {
                self.callback(null, chunks);
              });
            }
          ]
        }).listen(9000, function () {
          request.post('http://localhost:9000').write('hello world');
        });
      },
      'should receive complete POST data': function (chunks) {
        assert.equal(chunks, 'hello world');
      }
    },
    "a simple pipe to a file": {
      topic: function () {
        var self = this;
        union.createServer({
          before: [
            function (req, res, next) {
              var filename = path.join(__dirname, 'fixtures', 'pipe-write-test.txt'),
                  writeStream = fs.createWriteStream(filename);
              req.pipe(writeStream);
              writeStream.on('close', function () {
                res.writeHead(200);
                fs.createReadStream(filename).pipe(res);
              });
            }
          ]
        }).listen(9044, function () {
          request({
            method: 'POST',
            uri: 'http://localhost:9044',
            body: 'hello world'
          }, self.callback);
        });
      },
      'should receive complete POST data': function (err, res, body) {
        assert.equal(body, 'hello world');
      }
    }
  }
}).export(module);

var assert = require('assert'),
    request = require('request'),
    vows = require('vows'),
    union = require('../');
vows.describe('union/status-code').addBatch({
  'When using `union`': {
    'with a server setting `res.statusCode`': {
      topic: function () {
        var server = union.createServer({
          before: [
            function (req, res) {
              res.statusCode = 404;
              res.end();
            }
          ]
        });
        server.listen(9091, this.callback);
      },
      'and sending a request': {
        topic: function () {
          request('http://localhost:9091/', this.callback);
        },
        'it should have proper `statusCode` set': function (err, res, body) {
          assert.isTrue(!err);
          assert.equal(res.statusCode, 404);
        }
      }
    }
  }
}).export(module);

/*
 * simple-test.js: Simple tests for basic streaming and non-streaming HTTP requests with union.
 *
 * (C) 2011, Charlie Robbins & the Contributors
 * MIT LICENSE
 *
 */
var assert = require('assert'),
    fs = require('fs'),
    path = require('path'),
    spawn = require('child_process').spawn,
    request = require('request'),
    vows = require('vows'),
    macros = require('./helpers/macros');
var examplesDir = path.join(__dirname, '..', 'examples', 'simple'),
    simpleScript = path.join(examplesDir, 'simple.js'),
    pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8')),
    fooURI = 'http://localhost:9090/foo',
    server;
vows.describe('union/simple').addBatch({
  "When using union": {
    "a simple http server": {
      topic: function () {
        server = spawn(process.argv[0], [simpleScript]);
        server.stdout.on('data', this.callback.bind(this, null));
      },
      "a GET request to `/foo`": {
        topic: function () {
          request({ uri: fooURI }, this.callback);
        },
        "it should respond with `hello world`": function (err, res, body) {
          macros.assertValidResponse(err, res);
          assert.equal(body, 'hello world\n');
        },
        "it should respond with 'x-powered-by': 'union <version>'": function (err, res, body) {
          assert.isNull(err);
          assert.equal(res.headers['x-powered-by'], 'union ' + pkg.version);
        }
      },
      "a POST request to `/foo`": {
        topic: function () {
          request.post({ uri: fooURI }, this.callback);
        },
        "it should respond with `wrote to a stream!`": function (err, res, body) {
          macros.assertValidResponse(err, res);
          assert.equal(body, 'wrote to a stream!');
        }
      },
      "a GET request to `/redirect`": {
        topic: function () {
          request.get({
            url: 'http://localhost:9090/redirect',
            followRedirect: false
          }, this.callback);
        },
        "it should redirect to `http://www.google.com`": function (err, res, body) {
          assert.equal(res.statusCode, 302);
          assert.equal(res.headers.location, "http://www.google.com");
        }
      },
      "a GET request to `/custom_redirect`": {
        topic: function () {
          request.get({
            url: 'http://localhost:9090/custom_redirect',
            followRedirect: false
          }, this.callback);
        },
        "it should redirect to `/foo`": function (err, res, body) {
          assert.equal(res.statusCode, 301);
          assert.equal(res.headers.location, "http://localhost:9090/foo");
        }
      },
      "a GET request to `/async`": {
        topic: function () {
          request.get({
            url: 'http://localhost:9090/async',
            timeout: 500
          }, this.callback);
        },
        "it should not timeout": function (err, res, body) {
          assert.ifError(err);
          assert.equal(res.statusCode, 200);
        }
      }
    }
  }
}).addBatch({
  "When the tests are over": {
    "the server should close": function () {
      server.kill();
    }
  }
}).export(module);

var assert = require('assert'),
    request = require('request'),
    vows = require('vows'),
    union = require('../');
vows.describe('union/properties').addBatch({
  'When using `union`': {
    'with a server that responds to requests': {
      topic: function () {
        var callback = this.callback;
        var server = union.createServer({
          before: [
            function (req, res) {
              callback(null, req, res);
              res.writeHead(200, { 'content-type': 'text' });
              res.end();
            }
          ]
        });
        server.listen(9092, function () {
          request('http://localhost:9092/');
        });
      },
      'the `req` should have a proper `httpVersion` set': function (err, req) {
        assert.isNull(err);
        assert.equal(req.httpVersion, '1.1');
      },
      'the `req` should have a proper `httpVersionMajor` set': function (err, req) {
        assert.isNull(err);
        assert.equal(req.httpVersionMajor, 1);
      },
      'the `req` should have a proper `httpVersionMinor` set': function (err, req) {
        assert.isNull(err);
        assert.equal(req.httpVersionMinor, 1);
      },
      'the `req` should have proper `socket` reference set': function (err, req) {
        var net = require('net');
        assert.isNull(err);
        assert.isTrue(req.socket instanceof net.Socket);
      }
    }
  }
}).export(module);

/*
 * macros.js: Simple test macros
 *
 * (C) 2011, Charlie Robbins & the Contributors
 * MIT LICENSE
 *
 */
var assert = require('assert');
var macros = exports;
macros.assertValidResponse = function (err, res) {
  assert.isTrue(!err);
  assert.equal(res.statusCode, 200);
};

// var assert = require('assert'),
//     request = require('request'),
//     vows = require('vows'),
//     union = require('../');
// vows.describe('union/header').addBatch({
//   'When using `union`': {
//     'with a server that responds with a header': {
//       topic: function () {
//         var callback = this.callback;
//         var server = union.createServer({
//           before: [
//             function (req, res) {
//               res.on('header', function () {
//                 callback(null, res);
//               });
//               res.writeHead(200, { 'content-type': 'text' });
//               res.end();
//             }
//           ]
//         });
//         server.listen(9092, function () {
//           request('http://localhost:9092/');
//         });
//       },
//       'it should have proper `headerSent` set': function (err, res) {
//         assert.isNull(err);
//         assert.isTrue(res.headerSent);
//       },
//       'it should have proper `_emittedHeader` set': function (err, res) {
//         assert.isNull(err);
//         assert.isTrue(res._emittedHeader);
//       }
//     }
//   }
// }).export(module);

hello world

/*
 * simple-test.js: Simple tests for basic streaming and non-streaming HTTP requests with union.
 *
 * (C) 2011, Charlie Robbins & the Contributors
 * MIT LICENSE
 *
 */
var assert = require('assert'),
    ecstatic = require('ecstatic')(__dirname + '/fixtures/static'),
    request = require('request'),
    vows = require('vows'),
    union = require('../');
vows.describe('union/ecstatic').addBatch({
  "When using union with ecstatic": {
    topic: function () {
      union.createServer({
        before: [
          ecstatic
        ]
      }).listen(18082, this.callback);
    },
    "a request to /some-file.txt": {
      topic: function () {
        request({ uri: 'http://localhost:18082/some-file.txt' }, this.callback);
      },
      "should respond with `hello world`": function (err, res, body) {
        assert.isNull(err);
        assert.equal(body, 'hello world\n');
      }
    },
    "a request to /404.txt (which does not exist)": {
      topic: function () {
        request({ uri: 'http://localhost:18082/404.txt' }, this.callback);
      },
      "should respond with 404 status code": function (err, res, body) {
        assert.isNull(err);
        assert.equal(res.statusCode, 404);
      }
    }
  }
}).export(module);

/*
 * simple-test.js: Simple tests for basic streaming and non-streaming HTTP requests with union.
 *
 * (C) 2011, Charlie Robbins & the Contributors
 * MIT LICENSE
 *
 */
var assert = require('assert'),
    fs = require('fs'),
    path = require('path'),
    request = require('request'),
    vows = require('vows'),
    union = require('../lib/index'),
    macros = require('./helpers/macros');
var doubleWrite = false,
    server;
server = union.createServer({
  before: [
    function (req, res) {
      res.json(200, { 'hello': 'world' });
      res.emit('next');
    },
    function (req, res) {
      doubleWrite = true;
      res.json(200, { 'hello': 'world' });
      res.emit('next');
    }
  ]
});
vows.describe('union/double-write').addBatch({
  "When using union": {
    "an http server which attempts to write to the response twice": {
      topic: function () {
        server.listen(9091, this.callback);
      },
      "a GET request to `/foo`": {
        topic: function () {
          request({ uri: 'http://localhost:9091/foo' }, this.callback);
        },
        "it should respond with `{ 'hello': 'world' }`": function (err, res, body) {
          macros.assertValidResponse(err, res);
          assert.deepEqual(JSON.parse(body), { 'hello': 'world' });
        },
        "it should not write to the response twice": function () {
          assert.isFalse(doubleWrite);
        }
      }
    }
  }
}).addBatch({
  "When the tests are over": {
    "the server should close": function () {
      server.close();
    }
  }
}).export(module);

/*
 * simple-test.js: Simple tests for basic streaming and non-streaming HTTP requests with union.
 *
 * (C) 2011, Charlie Robbins & the Contributors
 * MIT LICENSE
 *
 */
var assert = require('assert'),
    connect = require('connect'),
    request = require('request'),
    vows = require('vows'),
    union = require('../');
vows.describe('union/body-parser').addBatch({
  "When using union with connect body parsing via urlencoded() or json()": {
    topic: function () {
      union.createServer({
        buffer: false,
        before: [
          connect.urlencoded(),
          connect.json(),
          function (req, res) {
            res.end(JSON.stringify(req.body, true, 2));
          }
        ]
      }).listen(8082, this.callback);
    },
    "a request to /": {
      topic: function () {
        request.post({
          uri: 'http://localhost:8082/',
          headers: {
            'content-type': 'application/json'
          },
          body: JSON.stringify({ a: "foo", b: "bar" })
        }, this.callback);
      },
      "should respond with a body-decoded object": function (err, res, body) {
        assert.isNull(err);
        assert.equal(res.statusCode, 200);
        assert.deepEqual(
          JSON.parse(body),
          { a: 'foo', b: 'bar' }
        );
      }
    }
  }
}).export(module);

var assert = require('assert'),
    vows = require('vows'),
    request = require('request'),
    union = require('../');
function stream_callback(cb) {
  return function () {
    var stream   = new union.ResponseStream();
    stream.once("pipe", function (req) {
      return cb ? cb(null,req) : undefined;
    });
    return stream;
  };
}
vows.describe('union/after').addBatch({
  'When using `union`': {
    'a union server with after middleware': {
      topic: function () {
        var self = this;
        union.createServer({
          after: [ stream_callback(), stream_callback(self.callback) ]
        }).listen(9000, function () {
          request.get('http://localhost:9000');
        });
      },
      'should preserve the request until the last call': function (req) {
        assert.equal(req.req.httpVersion, '1.1');
        assert.equal(req.req.url, '/');
        assert.equal(req.req.method, 'GET');
      }
    }
  }
}).export(module);

{
  "_from": "union@~0.5.0",
  "_id": "union@0.5.0",
  "_inBundle": false,
  "_integrity": "sha512-N6uOhuW6zO95P3Mel2I2zMsbsanvvtgn6jVqJv4vbVcz/JN0OkL9suomjQGmWtxJQXOCqUJvquc1sMeNz/IwlA==",
  "_location": "/union",
  "_phantomChildren": {},
  "_requested": {
    "type": "range",
    "registry": true,
    "raw": "union@~0.5.0",
    "name": "union",
    "escapedName": "union",
    "rawSpec": "~0.5.0",
    "saveSpec": null,
    "fetchSpec": "~0.5.0"
  },
  "_requiredBy": [
    "/http-server"
  ],
  "_resolved": "https://registry.npmjs.org/union/-/union-0.5.0.tgz",
  "_shasum": "b2c11be84f60538537b846edb9ba266ba0090075",
  "_spec": "union@~0.5.0",
  "_where": "/home/a/documents/pijul/nicoty/bitburner_scripts/node_modules/http-server",
  "author": {
    "name": "Charlie Robbins",
    "email": "charlie.robbins@gmail.com"
  },
  "bugs": {
    "url": "https://github.com/flatiron/union/issues"
  },
  "bundleDependencies": false,
  "dependencies": {
    "qs": "^6.4.0"
  },
  "deprecated": false,
  "description": "A hybrid buffered / streaming middleware kernel backwards compatible with connect.",
  "devDependencies": {
    "connect": "2.22.x",
    "director": "1.x.x",
    "ecstatic": "0.5.x",
    "request": "2.29.x",
    "vows": "0.8.0"
  },
  "engines": {
    "node": ">= 0.8.0"
  },
  "homepage": "https://github.com/flatiron/union#readme",
  "main": "./lib",
  "maintainers": [
    {
      "name": "dscape",
      "email": "nuno@nodejitsu.com"
    }
  ],
  "name": "union",
  "repository": {
    "type": "git",
    "url": "git+ssh://git@github.com/flatiron/union.git"
  },
  "scripts": {
    "test": "vows test/*-test.js --spec -i"
  },
  "version": "0.5.0"
}

/*
 * routing-stream.js: A Stream focused on connecting an arbitrary RequestStream and
 * ResponseStream through a given Router.
 *
 * (C) 2011, Charlie Robbins & the Contributors
 * MIT LICENSE
 *
 */
var util = require('util'),
    union = require('./index'),
    RequestStream = require('./request-stream'),
    ResponseStream = require('./response-stream');
//
// ### function RoutingStream (options)
//
//
var RoutingStream = module.exports = function (options) {
  options = options || {};
  RequestStream.call(this, options);
  this.before = options.before || [];
  this.after = options.after || [];
  this.response = options.response || options.res;
  this.headers = options.headers || {
    'x-powered-by': 'union ' + union.version
  };
  this.target = new ResponseStream({
    response: this.response,
    headers: this.headers
  });
  this.once('pipe', this.route);
};
util.inherits(RoutingStream, RequestStream);
//
// Called when this instance is piped to **by another stream**
//
RoutingStream.prototype.route = function (req) {
  //
  // When a `RoutingStream` is piped to:
  //
  // 1. Setup the pipe-chain between the `after` middleware, the abstract response
  //    and the concrete response.
  // 2. Attempt to dispatch to the `before` middleware, which represent things such as
  //    favicon, static files, application routing.
  // 3. If no match is found then pipe to the 404Stream
  //
  var self = this,
      after,
      error,
      i;
  //
  // Don't allow `this.target` to be writable on HEAD requests
  //
  this.target.writable = req.method !== 'HEAD';
  //
  // 1. Setup the pipe-chain between the `after` middleware, the abstract response
  //    and the concrete response.
  //
  after = [this.target].concat(this.after, this.response);
  for (i = 0; i < after.length - 1; i++) {
    //
    // attach req and res to all streams
    //
    after[i].req     = req;
    after[i + 1].req = req;
    after[i].res     = this.response;
    after[i + 1].res = this.response;
    after[i].pipe(after[i + 1]);
    //
    // prevent multiple responses and memory leaks
    //
    after[i].on('error', this.onError);
  }
  //
  // Helper function for dispatching to the 404 stream.
  //
  function notFound() {
    error = new Error('Not found');
    error.status = 404;
    self.onError(error);
  }
  //
  // 2. Attempt to dispatch to the `before` middleware, which represent things such as
  //    favicon, static files, application routing.
  //
  (function dispatch(i) {
    if (self.target.modified) {
      return;
    }
    else if (++i === self.before.length) {
      //
      // 3. If no match is found then pipe to the 404Stream
      //
      return notFound();
    }
    self.target.once('next', dispatch.bind(null, i));
    if (self.before[i].length === 3) {
      self.before[i](self, self.target, function (err) {
        if (err) {
          self.onError(err);
        } else {
          self.target.emit('next');
        }
      });
    }
    else {
      self.before[i](self, self.target);
    }
  })(-1);
};
RoutingStream.prototype.onError = function (err) {
  this.emit('error', err);
};

/*
 * response-stream.js: A Stream focused on writing any relevant information to
 * a raw http.ServerResponse object.
 *
 * (C) 2011, Charlie Robbins & the Contributors
 * MIT LICENSE
 *
 */
var util = require('util'),
    HttpStream = require('./http-stream');
var STATUS_CODES = require('http').STATUS_CODES;
//
// ### function ResponseStream (options)
//
//
var ResponseStream = module.exports = function (options) {
  var self = this,
      key;
  options = options || {};
  HttpStream.call(this, options);
  this.writeable = true;
  this.response = options.response;
  if (options.headers) {
    for (key in options.headers) {
      this.response.setHeader(key, options.headers[key]);
    }
  }
  //
  // Proxy `statusCode` changes to the actual `response.statusCode`.
  //
  Object.defineProperty(this, 'statusCode', {
    get: function () {
      return self.response.statusCode;
    },
    set: function (value) {
      self.response.statusCode = value;
    },
    enumerable: true,
    configurable: true
  });
  if (this.response) {
    this._headers = this.response._headers = this.response._headers || {};
    // Patch to node core
    this.response._headerNames = this.response._headerNames || {};
    //
    // Proxy to emit "header" event
    //
    this._renderHeaders = this.response._renderHeaders;
    this.response._renderHeaders = function () {
      if (!self._emittedHeader) {
        self._emittedHeader = true;
        self.headerSent = true;
        self._header = true;
        self.emit('header');
      }
      return self._renderHeaders.call(self.response);
    };
  }
};
util.inherits(ResponseStream, HttpStream);
ResponseStream.prototype.writeHead = function (statusCode, statusMessage, headers) {
  if (typeof statusMessage === 'string') {
    this.response.statusMessage = statusMessage;
  } else {
    this.response.statusMessage = this.response.statusMessage
      || STATUS_CODES[statusCode] || 'unknown';
    headers = statusMessage;
  }
  this.response.statusCode = statusCode;
  if (headers) {
    var keys = Object.keys(headers);
    for (var i = 0; i < keys.length; i++) {
      var k = keys[i];
      if (k) this.response.setHeader(k, headers[k]);
    }
  }
};
//
// Create pass-thru for the necessary
// `http.ServerResponse` methods.
//
['setHeader', 'getHeader', 'removeHeader', '_implicitHeader', 'addTrailers'].forEach(function (method) {
  ResponseStream.prototype[method] = function () {
    return this.response[method].apply(this.response, arguments);
  };
});
ResponseStream.prototype.json = function (obj) {
  if (!this.response.writable) {
    return;
  }
  if (typeof obj === 'number') {
    this.response.statusCode = obj;
    obj = arguments[1];
  }
  this.modified = true;
  if (!this.response._header && this.response.getHeader('content-type') !== 'application/json') {
    this.response.setHeader('content-type', 'application/json');
  }
  this.end(obj ? JSON.stringify(obj) : '');
};
ResponseStream.prototype.html = function (str) {
  if (!this.response.writable) {
    return;
  }
  if (typeof str === 'number') {
    this.response.statusCode = str;
    str = arguments[1];
  }
  this.modified = true;
  if (!this.response._header && this.response.getHeader('content-type') !== 'text/html') {
    this.response.setHeader('content-type', 'text/html');
  }
  this.end(str ? str: '');
};
ResponseStream.prototype.text = function (str) {
  if (!this.response.writable) {
    return;
  }
  if (typeof str === 'number') {
    this.response.statusCode = str;
    str = arguments[1];
  }
  this.modified = true;
  if (!this.response._header && this.response.getHeader('content-type') !== 'text/plain') {
    this.response.setHeader('content-type', 'text/plain');
  }
  this.end(str ? str: '');
};
ResponseStream.prototype.end = function (data) {
  if (data && this.writable) {
    this.emit('data', data);
  }
  this.modified = true;
  this.emit('end');
};
ResponseStream.prototype.pipe = function () {
  var self = this, 
      dest;
  self.dest = dest = HttpStream.prototype.pipe.apply(self, arguments);
  
  dest.on('drain', function() {
    self.emit('drain')
  })
  return dest;
};
ResponseStream.prototype.write = function (data) {
  this.modified = true;
  if (this.writable) {
    return this.dest.write(data);
  }
};
ResponseStream.prototype.redirect = function (path, status) {
  var url = '';
  if (~path.indexOf('://')) {
    url = path;
  } else {
    url += this.req.connection.encrypted ? 'https://' : 'http://';
    url += this.req.headers.host;
    url += (path[0] === '/') ? path : '/' + path;
  }
  this.res.writeHead(status || 302, { 'Location': url });
  this.end();
};

/*
 * http-stream.js: Idomatic buffered stream which pipes additional HTTP information.
 *
 * (C) 2011, Charlie Robbins & the Contributors
 * MIT LICENSE
 *
 */
var url = require('url'),
    util = require('util'),
    qs = require('qs'),
    HttpStream = require('./http-stream');
var RequestStream = module.exports = function (options) {
  options = options || {};
  HttpStream.call(this, options);
  this.on('pipe', this.pipeRequest);
  this.request = options.request;
};
util.inherits(RequestStream, HttpStream);
//
// ### function pipeRequest (source)
// #### @source {ServerRequest|HttpStream} Source stream piping to this instance
// Pipes additional HTTP request metadata from the `source` HTTP stream (either concrete or
// abstract) to this instance. e.g. url, headers, query, etc.
//
// Remark: Is there anything else we wish to pipe?
//
RequestStream.prototype.pipeRequest = function (source) {
  this.url = this.originalUrl = source.url;
  this.method = source.method;
  this.httpVersion = source.httpVersion;
  this.httpVersionMajor = source.httpVersionMajor;
  this.httpVersionMinor = source.httpVersionMinor;
  this.setEncoding = source.setEncoding;
  this.connection = source.connection;
  this.socket = source.socket;
  if (source.query) {
    this.query = source.query;
  }
  else {
    this.query = ~source.url.indexOf('?')
      ? qs.parse(url.parse(source.url).query)
      : {};
  }
};
// http.serverRequest methods
['setEncoding'].forEach(function (method) {
  RequestStream.prototype[method] = function () {
    return this.request[method].apply(this.request, arguments);
  };
});

/*
 * index.js: Top-level plugin exposing HTTP features in flatiron
 *
 * (C) 2011, Charlie Robbins & the Contributors
 * MIT LICENSE
 *
 */
var union = exports;
//
// Expose version information
//
exports.version = require('../package.json').version;
//
// Expose core union components
//
union.BufferedStream = require('./buffered-stream');
union.HttpStream     = require('./http-stream');
union.ResponseStream = require('./response-stream');
union.RoutingStream  = require('./routing-stream');
union.createServer   = require('./core').createServer;
union.errorHandler   = require('./core').errorHandler;

/*
 * http-stream.js: Idomatic buffered stream which pipes additional HTTP information.
 *
 * (C) 2011, Charlie Robbins & the Contributors
 * MIT LICENSE
 *
 */
var url = require('url'),
    util = require('util'),
    qs = require('qs'),
    BufferedStream = require('./buffered-stream');
var HttpStream = module.exports = function (options) {
  options = options || {};
  BufferedStream.call(this, options.limit);
  if (options.buffer === false) {
    this.buffer = false;
  }
  this.on('pipe', this.pipeState);
};
util.inherits(HttpStream, BufferedStream);
//
// ### function pipeState (source)
// #### @source {ServerRequest|HttpStream} Source stream piping to this instance
// Pipes additional HTTP metadata from the `source` HTTP stream (either concrete or
// abstract) to this instance. e.g. url, headers, query, etc.
//
// Remark: Is there anything else we wish to pipe?
//
HttpStream.prototype.pipeState = function (source) {
  this.headers = source.headers;
  this.trailers = source.trailers;
  this.method = source.method;
  if (source.url) {
    this.url = this.originalUrl = source.url;
  }
  if (source.query) {
    this.query = source.query;
  }
  else if (source.url) {
    this.query = ~source.url.indexOf('?')
      ? qs.parse(url.parse(source.url).query)
      : {};
  }
};

/*
 * core.js: Core functionality for the Flatiron HTTP (with SPDY support) plugin.
 *
 * (C) 2011, Charlie Robbins & the Contributors
 * MIT LICENSE
 *
 */
var http = require('http'),
    https = require('https'),
    fs = require('fs'),
    stream = require('stream'),
    HttpStream = require('./http-stream'),
    RoutingStream = require('./routing-stream');
var core = exports;
core.createServer = function (options) {
  var isArray = Array.isArray(options.after),
      credentials;
  if (!options) {
    throw new Error('options is required to create a server');
  }
  function requestHandler(req, res) {
    var routingStream = new RoutingStream({
      before: options.before,
      buffer: options.buffer,
      //
      // Remark: without new after is a huge memory leak that
      // pipes to every single open connection
      //
      after: isArray && options.after.map(function (After) {
        return new After;
      }),
      request: req,
      response: res,
      limit: options.limit,
      headers: options.headers
    });
    routingStream.on('error', function (err) {
      var fn = options.onError || core.errorHandler;
      fn(err, routingStream, routingStream.target, function () {
        routingStream.target.emit('next');
      });
    });
    req.pipe(routingStream);
  }
  //
  // both https and spdy requires same params
  //
  if (options.https || options.spdy) {
    if (options.https && options.spdy) {
      throw new Error('You shouldn\'t be using https and spdy simultaneously.');
    }
    var serverOptions,
        credentials,
        key = !options.spdy
          ? 'https'
          : 'spdy';
    serverOptions = options[key];
    if (!serverOptions.key || !serverOptions.cert) {
      throw new Error('Both options.' + key + '.`key` and options.' + key + '.`cert` are required.');
    }
    credentials = {
      key:  fs.readFileSync(serverOptions.key),
      cert: fs.readFileSync(serverOptions.cert)
    };
    if (serverOptions.ca) {
      serverOptions.ca = !Array.isArray(serverOptions.ca)
        ? [serverOptions.ca]
        : serverOptions.ca
      credentials.ca = serverOptions.ca.map(function (ca) {
        return fs.readFileSync(ca);
      });
    }
    if (options.spdy) {
      // spdy is optional so we require module here rather than on top
      var spdy = require('spdy');
      return spdy.createServer(credentials, requestHandler);
    }
    return https.createServer(credentials, requestHandler);
  }
  return http.createServer(requestHandler);
};
core.errorHandler = function error(err, req, res) {
  if (err) {
    (this.res || res).writeHead(err.status || 500, err.headers || { "Content-Type": "text/plain" });
    (this.res || res).end(err.message + "\n");
    return;
  }
  (this.res || res).writeHead(404, {"Content-Type": "text/plain"});
  (this.res || res).end("Not Found\n");
};

/*
 * buffered-stream.js: A simple(r) Stream which is partially buffered into memory.
 *
 * (C) 2010, Mikeal Rogers
 *
 * Adapted for Flatiron
 * (C) 2011, Charlie Robbins & the Contributors
 * MIT LICENSE
 *
 */
var events = require('events'),
    fs = require('fs'),
    stream = require('stream'),
    util = require('util');
//
// ### function BufferedStream (limit)
// #### @limit {number} **Optional** Size of the buffer to limit
// Constructor function for the BufferedStream object responsible for
// maintaining a stream interface which can also persist to memory
// temporarily.
//
var BufferedStream = module.exports = function (limit) {
  events.EventEmitter.call(this);
  if (typeof limit === 'undefined') {
    limit = Infinity;
  }
  this.limit = limit;
  this.size = 0;
  this.chunks = [];
  this.writable = true;
  this.readable = true;
  this._buffer = true;
};
util.inherits(BufferedStream, stream.Stream);
Object.defineProperty(BufferedStream.prototype, 'buffer', {
  get: function () {
    return this._buffer;
  },
  set: function (value) {
    if (!value && this.chunks) {
      var self = this;
      this.chunks.forEach(function (c) { self.emit('data', c) });
      if (this.ended) this.emit('end');
      this.size = 0;
      delete this.chunks;
    }
    this._buffer = value;
  }
});
BufferedStream.prototype.pipe = function () {
  var self = this,
      dest;
  if (self.resume) {
    self.resume();
  }
  dest = stream.Stream.prototype.pipe.apply(self, arguments);
  //
  // just incase you are piping to two streams, do not emit data twice.
  // note: you can pipe twice, but you need to pipe both streams in the same tick.
  // (this is normal for streams)
  //
  if (this.piped) {
    return dest;
  }
  process.nextTick(function () {
    if (self.chunks) {
      self.chunks.forEach(function (c) { self.emit('data', c) });
      self.size = 0;
      delete self.chunks;
    }
    if (!self.readable) {
      if (self.ended) {
        self.emit('end');
      }
      else if (self.closed) {
        self.emit('close');
      }
    }
  });
  this.piped = true;
  return dest;
};
BufferedStream.prototype.write = function (chunk) {
  if (!this.chunks || this.piped) {
    this.emit('data', chunk);
    return;
  }
  this.chunks.push(chunk);
  this.size += chunk.length;
  if (this.limit < this.size) {
    this.pause();
  }
};
BufferedStream.prototype.end = function () {
  this.readable = false;
  this.ended = true;
  this.emit('end');
};
BufferedStream.prototype.destroy = function () {
  this.readable = false;
  this.writable = false;
  delete this.chunks;
};
BufferedStream.prototype.close = function () {
  this.readable = false;
  this.closed = true;
};
if (!stream.Stream.prototype.pause) {
  BufferedStream.prototype.pause = function () {
    this.emit('pause');
  };
}
if (!stream.Stream.prototype.resume) {
  BufferedStream.prototype.resume = function () {
    this.emit('resume');
  };
}

var fs = require('fs'),
    union = require('union');
var server = union.createServer({
  before: [
    function (req, res) {
      fs.readFile(__dirname + '/index.html',
	  function (err, data) {
		if (err) {
		  res.writeHead(500);
		  return res.end('Error loading index.html');
		}
		res.writeHead(200);
		res.end(data);
	  });
    }
  ]
});
server.listen(9090);
var io = require('socket.io').listen(server);
io.sockets.on('connection', function (socket) {
  socket.emit('news', {hello: 'world'});
  socket.on('my other event', function (data) {
    console.log(data);
  });
});

<script src="/socket.io/socket.io.js"></script>
<script>
  var socket = io.connect('http://localhost');
  socket.on('news', function (data) {
    console.log(data);
    socket.emit('my other event', { my: 'data' });
  });
</script>

This folder contains an example of how to use Union with Socket.io.
First, you'll want to install both Union and Socket.io. Run this
command in the folder you placed these two files:
npm install union socket.io
You can run the server like so:
node server.js
Now open up your web browser to http://localhost and see the results
in the console!

// In order to run this example you need to
// generate local ssl certificate
var union = require('../../lib'),
    director = require('director');
var router = new director.http.Router();
var server = union.createServer({
  before: [
    function (req, res) {
      var found = router.dispatch(req, res);
      if (!found) {
        res.emit('next');
      }
    }
  ],
  spdy :{
    key: './certs/privatekey.pem',
    cert: './certs/certificate.pem'
  }
});
router.get(/foo/, function () {
  this.res.writeHead(200, { 'Content-Type': 'text/plain' })
  this.res.end('hello world\n');
});
server.listen(9090, function () {
  console.log('union with director running on 9090 with SPDY');
});

var fs = require('fs'),
    path = require('path'),
    union = require('../../lib'),
    director = require('director'),
    favicon = require('./middleware/favicon');
var router = new director.http.Router();
var server = union.createServer({
  before: [
    favicon(path.join(__dirname, 'favicon.png')),
    function (req, res) {
      var found = router.dispatch(req, res);
      if (!found) {
        res.emit('next');
      }
    }
  ]
});
router.get('/foo', function () {
  this.res.writeHead(200, { 'Content-Type': 'text/plain' });
  this.res.end('hello world\n');
});
router.post('/foo', { stream: true }, function () {
  var req = this.req,
      res = this.res,
      writeStream;
  writeStream = fs.createWriteStream(__dirname + '/' + Date.now() + '-foo.txt');
  req.pipe(writeStream);
  writeStream.on('close', function () {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('wrote to a stream!');
  });
});
router.get('/redirect', function () {
  this.res.redirect('http://www.google.com');
});
router.get('/custom_redirect', function () {
  this.res.redirect('/foo', 301);
});
router.get('/async', function () {
  var self = this;
  process.nextTick(function () {
    self.req.on('end', function () {
      self.res.end();
    })
    self.req.buffer = false;
  });
});
server.listen(9090);
console.log('union with director running on 9090');

var spawn = require('child_process').spawn,
    util = require('util'),
    ResponseStream = require('../../lib').ResponseStream;
    
/**
 * Accepts a writable stream, i.e. fs.WriteStream, and returns a StreamStack
 * whose 'write()' calls are transparently sent to a 'gzip' process before
 * being written to the target stream.
 */
var GzipEncode = module.exports = function GzipEncode(options) {
  ResponseStream.call(this, options);
  if (compression) {
    process.assert(compression >= 1 && compression <= 9);
    this.compression = compression;
  }
  this.on('pipe', this.encode);
}
util.inherits(GzipEncode, ResponseStream);
GzipEncode.prototype.encode = function (source) {
  this.source = source;
};
GzipEncode.prototype.pipe = function (dest) {
  if (!this.source) {
    throw new Error('GzipEncode is only pipeable once it has been piped to');
  }
  
  this.encoder = spawn('gzip', ['-'+this.compression]);
  this.encoder.stdout.pipe(dest);
  this.encoder.stdin.pipe(this.source);
};
inherits(GzipEncoderStack, StreamStack);
exports.GzipEncoderStack = GzipEncoderStack;
GzipEncoderStack.prototype.compression = 6;

var spawn = require('child_process').spawn,
    util = require('util'),
    RequestStream = require('../../lib').RequestStream;
var GzipDecode = module.exports = function GzipDecoder(options) {
  RequestStream.call(this, options);
  this.on('pipe', this.decode);
}
util.inherits(GzipDecode, RequestStream);
GzipDecode.prototype.decode = function (source) {
  this.decoder = spawn('gunzip');
  this.decoder.stdout.on('data', this._onGunzipData.bind(this));
  this.decoder.stdout.on('end', this._onGunzipEnd.bind(this));
  source.pipe(this.decoder);
}
GzipDecoderStack.prototype._onGunzipData = function (chunk) {
  this.emit('data', chunk);
}
GzipDecoderStack.prototype._onGunzipEnd = function () {
  this.emit('end');
}

/*!
 * Connect - favicon
 * Copyright(c) 2010 Sencha Inc.
 * Copyright(c) 2011 TJ Holowaychuk
 * MIT Licensed
 */
/**
 * Module dependencies.
 */
var crypto = require('crypto')
  , fs = require('fs');
/**
 * Favicon cache.
 */
var icon;
/**
 * Return md5 hash of the given string and optional encoding,
 * defaulting to hex.
 *
 *     utils.md5('wahoo');
 *     // => "e493298061761236c96b02ea6aa8a2ad"
 *
 * @param {String} str
 * @param {String} encoding
 * @return {String}
 * @api public
 */
exports.md5 = function (str, encoding) {
  return crypto
    .createHash('md5')
    .update(str)
    .digest(encoding || 'hex');
};
/**
 * By default serves the connect favicon, or the favicon
 * located by the given `path`.
 *
 * Options:
 *
 *   - `maxAge`  cache-control max-age directive, defaulting to 1 day
 *
 * Examples:
 *
 *     connect.createServer(
 *       connect.favicon()
 *     );
 *
 *     connect.createServer(
 *       connect.favicon(__dirname + '/public/favicon.ico')
 *     );
 *
 * @param {String} path
 * @param {Object} options
 * @return {Function}
 * @api public
 */
module.exports = function favicon(path, options) {
  var options = options || {}
    , path = path || __dirname + '/../public/favicon.ico'
    , maxAge = options.maxAge || 86400000;
  return function favicon(req, res, next) {
    if ('/favicon.ico' == req.url) {
      if (icon) {
        res.writeHead(200, icon.headers);
        res.end(icon.body);
      } else {
        fs.readFile(path, function (err, buf) {
          if (err) return next(err);
          icon = {
            headers: {
                'Content-Type': 'image/x-icon'
              , 'Content-Length': buf.length
              , 'ETag': '"' + exports.md5(buf) + '"'
              , 'Cache-Control': 'public, max-age=' + (maxAge / 1000)
            },
            body: buf
          };
          res.writeHead(200, icon.headers);
          res.end(icon.body);
        });
      }
    } else {
      next();
    }
  };
};

var fs = require('fs'),
    path = require('path'),
    union = require('../../lib');
var server = union.createServer({
  before: [ function (req,res) {
    if (req.url === "/foo") {
      res.text(201, "foo");
    }
  } ],
  after: [
    function LoggerStream() {
        var stream   = new union.ResponseStream();
        stream.once("pipe", function (req) {
          console.log({res: this.res.statusCode, method: this.req.method});
        });
        return stream;
    }
  ]
});
server.listen(9080);
console.log('union running on 9080');

<img src="https://github.com/flatiron/union/raw/master/union.png" />
# Synopsis
A hybrid streaming middleware kernel backwards compatible with connect.
# Motivation
The advantage to streaming middlewares is that they do not require buffering the entire stream in order to execute their function.
# Status
[![Build Status](https://secure.travis-ci.org/flatiron/union.png)](http://travis-ci.org/flatiron/union)
# Installation
There are a few ways to use `union`. Install the library using npm. You can add it to your `package.json` file as a dependancy
```bash
  $ [sudo] npm install union
```
## Usage
Union's request handling is [connect](https://github.com/senchalabs/connect)-compatible, meaning that all existing connect middlewares should work out-of-the-box with union.
**(Union 0.3.x is compatible with connect >= 2.1.0)**
In addition, the response object passed to middlewares listens for a "next" event, which is equivalent to calling `next()`. Flatiron middlewares are written in this manner, meaning they are not reverse-compatible with connect.
### A simple case
``` js
var fs = require('fs'),
    union = require('../lib'),
    director = require('director');
var router = new director.http.Router();
var server = union.createServer({
  before: [
    function (req, res) {
      var found = router.dispatch(req, res);
      if (!found) {
        res.emit('next');
      }
    }
  ]
});
router.get(/foo/, function () {
  this.res.writeHead(200, { 'Content-Type': 'text/plain' })
  this.res.end('hello world\n');
});
router.post(/foo/, { stream: true }, function () {
  var req = this.req,
      res = this.res,
      writeStream;
  writeStream = fs.createWriteStream(Date.now() + '-foo.txt');
  req.pipe(writeStream);
  writeStream.on('close', function () {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('wrote to a stream!');
  });
});
server.listen(9090);
console.log('union with director running on 9090');
```
To demonstrate the code, we use [director](https://github.com/flatiron/director). A light-weight, Client AND Server side URL-Router for Node.js and Single Page Apps!
### A case with connect
Code based on connect
```js
var connect = require('connect')
  , http = require('http');
var app = connect()
  .use(connect.favicon())
  .use(connect.logger('dev'))
  .use(connect.static('public'))
  .use(connect.directory('public'))
  .use(connect.cookieParser('my secret here'))
  .use(connect.session())
  .use(function (req, res) {
    res.end('Hello from Connect!\n');
  });
http.createServer(app).listen(3000);
```
Code based on union
```js
var connect = require('connect')
  , union = require('union');
var server = union.createServer({
  buffer: false,
  before: [
    connect.favicon(),
    connect.logger('dev'),
    connect.static('public'),
    connect.directory('public'),
    connect.cookieParser('my secret here'),
    connect.session(),
    function (req, res) {
      res.end('Hello from Connect!\n');
    },
  ]
}).listen(3000);
```
### SPDY enabled server example
# API
## union Static Members
### createServer(options)
The `options` object is required. Options include:
Specification
```
  function createServer(options)
  @param options {Object}
  An object literal that represents the configuration for the server.
    @option before {Array}
    The `before` value is an array of middlewares, which are used to route and serve incoming
    requests. For instance, in the example, `favicon` is a middleware which handles requests
    for `/favicon.ico`.
    @option after {Array}
    The `after` value is an array of functions that return stream filters,
    which are applied after the request handlers in `options.before`.
    Stream filters inherit from `union.ResponseStream`, which implements the
    Node.js core streams api with a bunch of other goodies.
    @option limit {Object}
    (optional) A value, passed to internal instantiations of `union.BufferedStream`.
    @option https {Object}
    (optional) A value that specifies the certificate and key necessary to create an instance of
    `https.Server`.
    @option spdy {Object}
    (optional) A value that specifies the certificate and key necessary to create an instance of
    `spdy.Server`.
    @option headers {Object}
    (optional) An object representing a set of headers to set in every outgoing response
```
Example
```js
var server = union.createServer({
  before: [
    favicon('./favicon.png'),
    function (req, res) {
      var found = router.dispatch(req, res);
      if (!found) {
        res.emit('next');
      }
    }
  ]
});
```
An example of the `https` or `spdy` option.
``` js
{
  cert: 'path/to/cert.pem',
  key: 'path/to/key.pem',
  ca: 'path/to/ca.pem'
}
```
An example of the `headers` option.
``` js
{
  'x-powered-by': 'your-sweet-application v10.9.8'
}
```
## Error Handling
Error handler is similiar to middlware but takes an extra argument for error at the beginning.
```js
var handle = function (err, req, res) {
  res.statusCode = err.status;
  res.end(req.headers);
};
var server = union.createServer({
  onError: handle,
  before: [
    favicon('./favicon.png'),
    function (req, res) {
      var found = router.dispatch(req, res);
      if (!found) {
        res.emit('next');
      }
    }
  ]
});
```
## BufferedStream Constructor
This constructor inherits from `Stream` and can buffer data up to `limit` bytes. It also implements `pause` and `resume` methods.
Specification
```
  function BufferedStream(limit)
  @param limit {Number}
  the limit for which the stream can be buffered
```
Example
```js
var bs = union.BufferedStream(n);
```
## HttpStream Constructor
This constructor inherits from `union.BufferedStream` and returns a stream with these extra properties:
Specification
```
  function HttpStream()
```
Example
```js
var hs = union.HttpStream();
```
## HttpStream Instance Members
### url
The url from the request.
Example
```js
httpStream.url = '';
```
### headers
The HTTP headers associated with the stream.
Example
```js
httpStream.headers = '';
```
### method
The HTTP method ("GET", "POST", etc).
Example
```js
httpStream.method = 'POST';
```
### query
The querystring associated with the stream (if applicable).
Example
```js
httpStream.query = '';
```
## ResponseStream Constructor
This constructor inherits from `union.HttpStream`, and is additionally writeable. Union supplies this constructor as a basic response stream middleware from which to inherit.
Specification
```
  function ResponseStream()
```
Example
```js
var rs = union.ResponseStream();
```
# Tests
All tests are written with [vows][0] and should be run with [npm][1]:
``` bash
  $ npm test
```
# Licence
(The MIT License)
Copyright (c) 2010-2012 Charlie Robbins & the Contributors
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
[0]: http://vowsjs.org
[1]: http://npmjs.org

Copyright (c) 2010 Charlie Robbins & the Contributors.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

0.3.4 / 2012-07-24
==================
  * Added SPDY support
  * Added http redirect utility function

language: node_js
node_js:
  - "0.10"
  - "0.12"
  - "4"
  - "6"
notifications:
  email:
    - travis@nodejitsu.com
  irc: "irc.freenode.org#nodejitsu"

package-lock.json binary