Dallon Feldner dallonf

## typescript-memory-usage.ts
#!/usr/bin/env node

const { execSync } = require('child_process');
const fs = require('fs');
const path = require('path');

/**
 * Tests if TypeScript can run with the given memory amount
 * @param {number} memoryMB - Memory in megabytes
 * @returns {boolean} - True if successful, false if out of memory

## parseCoverage.js
import * as fs from "fs";

const coverage = JSON.parse(
    fs.readFileSync("coverage/coverage-final.json", "utf-8")
);

const output = Object.values(coverage).map((x) => {
    const path = x.path;
    const totalStatements = Object.keys(x.statementMap).length;
    const coveredStatements = Object.entries(x.s).filter(

## BaseReconciler.cs
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

[System.Serializable]
public abstract class BaseReconciler<TKey, TObject> : ISerializationCallbackReceiver where TObject : Object
{
  private Dictionary<TKey, TObject> managedObjects;
  private List<TObject> serializedManagedObjects;

## threadpool.rs
// importing a dependency from Cargo (the package manager)
extern crate threadpool;

use std::sync::{self, mpsc};
use std::thread;
use std::time;

// data type to keep a handle for a task
struct ThreadpoolTask<T> {
    rx: mpsc::Receiver<T>,

## superagent-nock-748.js
const nock    = require('nock');
const test    = require('tap').test;
const superagent = require('superagent');

test('reqheaders ignored #748 - test matching', t => {
    nock('http://www.example.com', {
        reqheaders: {
            'authorization': 'Bearer TOKEN'
        }
    })

## Conditional.jsx
function render1() {
  return (
    <div>
      { templates.length
        ? null
        : <div>Nothing to see here, move along...</div>
      }
    </div>
  );
}

## index.html
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
  </head>
  <body>
    <svg id="svgRoot">
      <g id="gElement">

      </g>

## co.d.ts
declare module 'co' {
  interface ICoStatic {
    <T>(coroutine: () => IterableIterator<any>): Promise<T>
    wrap<T>(coroutine: (...args: any[]) => IterableIterator<Promise<any>>): (...args: any[]) => Promise<T>
  }

  var co: ICoStatic;
  export default co;
}

## jsonify-bootstrap.js
let fs = require('fs');
let path = require('path');
let less = require('less');
let bluebird = require('bluebird');
let css = require('css');

async function execute() {
  let variablesLess = await bluebird.fromNode(cb => fs.readFile(path.join(__dirname, 'less/variables.less'), 'utf-8', cb));
  let [parseResult] = await bluebird.fromNode(cb => less.parse(variablesLess, cb));
  let varNames = parseResult.rules

## gist:3f365373ae971d278706
var FloatingElement = React.createClass({

  propTypes: {
    children: React.PropTypes.element.isRequired,
    floatingClassName: React.PropTypes.string
  },

  getDefaultProps() {
    return {
      floatingClassName: 'floating'
	#!/usr/bin/env node

	const { execSync } = require('child_process');
	const fs = require('fs');
	const path = require('path');

	/**
	* Tests if TypeScript can run with the given memory amount
	* @param {number} memoryMB - Memory in megabytes
	* @returns {boolean} - True if successful, false if out of memory
	import * as fs from "fs";

	const coverage = JSON.parse(
	fs.readFileSync("coverage/coverage-final.json", "utf-8")
	);

	const output = Object.values(coverage).map((x) => {
	const path = x.path;
	const totalStatements = Object.keys(x.statementMap).length;
	const coveredStatements = Object.entries(x.s).filter(
	using System.Collections.Generic;
	using System.Linq;
	using UnityEngine;

	[System.Serializable]
	public abstract class BaseReconciler<TKey, TObject> : ISerializationCallbackReceiver where TObject : Object
	{
	private Dictionary<TKey, TObject> managedObjects;
	private List<TObject> serializedManagedObjects;
	// importing a dependency from Cargo (the package manager)
	extern crate threadpool;

	use std::sync::{self, mpsc};
	use std::thread;
	use std::time;

	// data type to keep a handle for a task
	struct ThreadpoolTask<T> {
	rx: mpsc::Receiver<T>,
	const nock = require('nock');
	const test = require('tap').test;
	const superagent = require('superagent');

	test('reqheaders ignored #748 - test matching', t => {
	nock('http://www.example.com', {
	reqheaders: {
	'authorization': 'Bearer TOKEN'
	}
	})
	function render1() {
	return (
	<div>
	{ templates.length
	? null
	: <div>Nothing to see here, move along...</div>
	}
	</div>
	);
	}
	<!DOCTYPE html>
	<html>
	<head>
	<meta charset="utf-8">
	</head>
	<body>
	<svg id="svgRoot">
	<g id="gElement">

	</g>
	declare module 'co' {
	interface ICoStatic {
	<T>(coroutine: () => IterableIterator<any>): Promise<T>
	wrap<T>(coroutine: (...args: any[]) => IterableIterator<Promise<any>>): (...args: any[]) => Promise<T>
	}

	var co: ICoStatic;
	export default co;
	}
	let fs = require('fs');
	let path = require('path');
	let less = require('less');
	let bluebird = require('bluebird');
	let css = require('css');

	async function execute() {
	let variablesLess = await bluebird.fromNode(cb => fs.readFile(path.join(__dirname, 'less/variables.less'), 'utf-8', cb));
	let [parseResult] = await bluebird.fromNode(cb => less.parse(variablesLess, cb));
	let varNames = parseResult.rules
	var FloatingElement = React.createClass({

	propTypes: {
	children: React.PropTypes.element.isRequired,
	floatingClassName: React.PropTypes.string
	},

	getDefaultProps() {
	return {
	floatingClassName: 'floating'