		@@ -1,1028 +0,2 @@
		'use strict';

		function createCommonjsModule(fn, module) {
		return module = { exports: {} }, fn(module, module.exports), module.exports;
		}

		var runtime = createCommonjsModule(function (module) {
		/**
		* Copyright (c) 2014-present, Facebook, Inc.
		*
		* This source code is licensed under the MIT license found in the
		* LICENSE file in the root directory of this source tree.
		*/

		!(function(global) {

		var Op = Object.prototype;
		var hasOwn = Op.hasOwnProperty;
		var undefined$1; // More compressible than void 0.
		var $Symbol = typeof Symbol === "function" ? Symbol : {};
		var iteratorSymbol = $Symbol.iterator \|\| "@@iterator";
		var asyncIteratorSymbol = $Symbol.asyncIterator \|\| "@@asyncIterator";
		var toStringTagSymbol = $Symbol.toStringTag \|\| "@@toStringTag";
		var runtime = global.regeneratorRuntime;
		if (runtime) {
		{
		// If regeneratorRuntime is defined globally and we're in a module,
		// make the exports object identical to regeneratorRuntime.
		module.exports = runtime;
		}
		// Don't bother evaluating the rest of this file if the runtime was
		// already defined globally.
		return;
		}

		// Define the runtime globally (as expected by generated code) as either
		// module.exports (if we're in a module) or a new, empty object.
		runtime = global.regeneratorRuntime = module.exports;

		function wrap(innerFn, outerFn, self, tryLocsList) {
		// If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
		var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
		var generator = Object.create(protoGenerator.prototype);
		var context = new Context(tryLocsList \|\| []);

		// The ._invoke method unifies the implementations of the .next,
		// .throw, and .return methods.
		generator._invoke = makeInvokeMethod(innerFn, self, context);

		return generator;
		}
		runtime.wrap = wrap;

		// Try/catch helper to minimize deoptimizations. Returns a completion
		// record like context.tryEntries[i].completion. This interface could
		// have been (and was previously) designed to take a closure to be
		// invoked without arguments, but in all the cases we care about we
		// already have an existing method we want to call, so there's no need
		// to create a new function object. We can even get away with assuming
		// the method takes exactly one argument, since that happens to be true
		// in every case, so we don't have to touch the arguments object. The
		// only additional allocation required is the completion record, which
		// has a stable shape and so hopefully should be cheap to allocate.
		function tryCatch(fn, obj, arg) {
		try {
		return { type: "normal", arg: fn.call(obj, arg) };
		} catch (err) {
		return { type: "throw", arg: err };
		}
		}

		var GenStateSuspendedStart = "suspendedStart";
		var GenStateSuspendedYield = "suspendedYield";
		var GenStateExecuting = "executing";
		var GenStateCompleted = "completed";

		// Returning this object from the innerFn has the same effect as
		// breaking out of the dispatch switch statement.
		var ContinueSentinel = {};

		// Dummy constructor functions that we use as the .constructor and
		// .constructor.prototype properties for functions that return Generator
		// objects. For full spec compliance, you may wish to configure your
		// minifier not to mangle the names of these two functions.
		function Generator() {}
		function GeneratorFunction() {}
		function GeneratorFunctionPrototype() {}

		// This is a polyfill for %IteratorPrototype% for environments that
		// don't natively support it.
		var IteratorPrototype = {};
		IteratorPrototype[iteratorSymbol] = function () {
		return this;
		};

		var getProto = Object.getPrototypeOf;
		var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
		if (NativeIteratorPrototype &&
		NativeIteratorPrototype !== Op &&
		hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
		// This environment has a native %IteratorPrototype%; use it instead
		// of the polyfill.
		IteratorPrototype = NativeIteratorPrototype;
		}

		var Gp = GeneratorFunctionPrototype.prototype =
		Generator.prototype = Object.create(IteratorPrototype);
		GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
		GeneratorFunctionPrototype.constructor = GeneratorFunction;
		GeneratorFunctionPrototype[toStringTagSymbol] =
		GeneratorFunction.displayName = "GeneratorFunction";

		// Helper for defining the .next, .throw, and .return methods of the
		// Iterator interface in terms of a single ._invoke method.
		function defineIteratorMethods(prototype) {
		["next", "throw", "return"].forEach(function(method) {
		prototype[method] = function(arg) {
		return this._invoke(method, arg);
		};
		});
		}

		runtime.isGeneratorFunction = function(genFun) {
		var ctor = typeof genFun === "function" && genFun.constructor;
		return ctor
		? ctor === GeneratorFunction \|\|
		// For the native GeneratorFunction constructor, the best we can
		// do is to check its .name property.
		(ctor.displayName \|\| ctor.name) === "GeneratorFunction"
		: false;
		};

		runtime.mark = function(genFun) {
		if (Object.setPrototypeOf) {
		Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
		} else {
		genFun.__proto__ = GeneratorFunctionPrototype;
		if (!(toStringTagSymbol in genFun)) {
		genFun[toStringTagSymbol] = "GeneratorFunction";
		}
		}
		genFun.prototype = Object.create(Gp);
		return genFun;
		};

		// Within the body of any async function, `await x` is transformed to
		// `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
		// `hasOwn.call(value, "__await")` to determine if the yielded value is
		// meant to be awaited.
		runtime.awrap = function(arg) {
		return { __await: arg };
		};

		function AsyncIterator(generator) {
		function invoke(method, arg, resolve, reject) {
		var record = tryCatch(generator[method], generator, arg);
		if (record.type === "throw") {
		reject(record.arg);
		} else {
		var result = record.arg;
		var value = result.value;
		if (value &&
		typeof value === "object" &&
		hasOwn.call(value, "__await")) {
		return Promise.resolve(value.__await).then(function(value) {
		invoke("next", value, resolve, reject);
		}, function(err) {
		invoke("throw", err, resolve, reject);
		});
		}

		return Promise.resolve(value).then(function(unwrapped) {
		// When a yielded Promise is resolved, its final value becomes
		// the .value of the Promise<{value,done}> result for the
		// current iteration.
		result.value = unwrapped;
		resolve(result);
		}, function(error) {
		// If a rejected Promise was yielded, throw the rejection back
		// into the async generator function so it can be handled there.
		return invoke("throw", error, resolve, reject);
		});
		}
		}

		var previousPromise;

		function enqueue(method, arg) {
		function callInvokeWithMethodAndArg() {
		return new Promise(function(resolve, reject) {
		invoke(method, arg, resolve, reject);
		});
		}

		return previousPromise =
		// If enqueue has been called before, then we want to wait until
		// all previous Promises have been resolved before calling invoke,
		// so that results are always delivered in the correct order. If
		// enqueue has not been called before, then it is important to
		// call invoke immediately, without waiting on a callback to fire,
		// so that the async generator function has the opportunity to do
		// any necessary setup in a predictable way. This predictability
		// is why the Promise constructor synchronously invokes its
		// executor callback, and why async functions synchronously
		// execute code before the first await. Since we implement simple
		// async functions in terms of async generators, it is especially
		// important to get this right, even though it requires care.
		previousPromise ? previousPromise.then(
		callInvokeWithMethodAndArg,
		// Avoid propagating failures to Promises returned by later
		// invocations of the iterator.
		callInvokeWithMethodAndArg
		) : callInvokeWithMethodAndArg();
		}

		// Define the unified helper method that is used to implement .next,
		// .throw, and .return (see defineIteratorMethods).
		this._invoke = enqueue;
		}

		defineIteratorMethods(AsyncIterator.prototype);
		AsyncIterator.prototype[asyncIteratorSymbol] = function () {
		return this;
		};
		runtime.AsyncIterator = AsyncIterator;

		// Note that simple async functions are implemented on top of
		// AsyncIterator objects; they just return a Promise for the value of
		// the final result produced by the iterator.
		runtime.async = function(innerFn, outerFn, self, tryLocsList) {
		var iter = new AsyncIterator(
		wrap(innerFn, outerFn, self, tryLocsList)
		);

		return runtime.isGeneratorFunction(outerFn)
		? iter // If outerFn is a generator, return the full iterator.
		: iter.next().then(function(result) {
		return result.done ? result.value : iter.next();
		});
		};

		function makeInvokeMethod(innerFn, self, context) {
		var state = GenStateSuspendedStart;

		return function invoke(method, arg) {
		if (state === GenStateExecuting) {
		throw new Error("Generator is already running");
		}

		if (state === GenStateCompleted) {
		if (method === "throw") {
		throw arg;
		}

		// Be forgiving, per 25.3.3.3.3 of the spec:
		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
		return doneResult();
		}

		context.method = method;
		context.arg = arg;

		while (true) {
		var delegate = context.delegate;
		if (delegate) {
		var delegateResult = maybeInvokeDelegate(delegate, context);
		if (delegateResult) {
		if (delegateResult === ContinueSentinel) continue;
		return delegateResult;
		}
		}

		if (context.method === "next") {
		// Setting context._sent for legacy support of Babel's
		// function.sent implementation.
		context.sent = context._sent = context.arg;

		} else if (context.method === "throw") {
		if (state === GenStateSuspendedStart) {
		state = GenStateCompleted;
		throw context.arg;
		}

		context.dispatchException(context.arg);

		} else if (context.method === "return") {
		context.abrupt("return", context.arg);
		}

		state = GenStateExecuting;

		var record = tryCatch(innerFn, self, context);
		if (record.type === "normal") {
		// If an exception is thrown from innerFn, we leave state ===
		// GenStateExecuting and loop back for another invocation.
		state = context.done
		? GenStateCompleted
		: GenStateSuspendedYield;

		if (record.arg === ContinueSentinel) {
		continue;
		}

		return {
		value: record.arg,
		done: context.done
		};

		} else if (record.type === "throw") {
		state = GenStateCompleted;
		// Dispatch the exception by looping back around to the
		// context.dispatchException(context.arg) call above.
		context.method = "throw";
		context.arg = record.arg;
		}
		}
		};
		}

		// Call delegate.iterator[context.method](context.arg) and handle the
		// result, either by returning a { value, done } result from the
		// delegate iterator, or by modifying context.method and context.arg,
		// setting context.delegate to null, and returning the ContinueSentinel.
		function maybeInvokeDelegate(delegate, context) {
		var method = delegate.iterator[context.method];
		if (method === undefined$1) {
		// A .throw or .return when the delegate iterator has no .throw
		// method always terminates the yield* loop.
		context.delegate = null;

		if (context.method === "throw") {
		if (delegate.iterator.return) {
		// If the delegate iterator has a return method, give it a
		// chance to clean up.
		context.method = "return";
		context.arg = undefined$1;
		maybeInvokeDelegate(delegate, context);

		if (context.method === "throw") {
		// If maybeInvokeDelegate(context) changed context.method from
		// "return" to "throw", let that override the TypeError below.
		return ContinueSentinel;
		}
		}

		context.method = "throw";
		context.arg = new TypeError(
		"The iterator does not provide a 'throw' method");
		}

		return ContinueSentinel;
		}

		var record = tryCatch(method, delegate.iterator, context.arg);

		if (record.type === "throw") {
		context.method = "throw";
		context.arg = record.arg;
		context.delegate = null;
		return ContinueSentinel;
		}

		var info = record.arg;

		if (! info) {
		context.method = "throw";
		context.arg = new TypeError("iterator result is not an object");
		context.delegate = null;
		return ContinueSentinel;
		}

		if (info.done) {
		// Assign the result of the finished delegate to the temporary
		// variable specified by delegate.resultName (see delegateYield).
		context[delegate.resultName] = info.value;

		// Resume execution at the desired location (see delegateYield).
		context.next = delegate.nextLoc;

		// If context.method was "throw" but the delegate handled the
		// exception, let the outer generator proceed normally. If
		// context.method was "next", forget context.arg since it has been
		// "consumed" by the delegate iterator. If context.method was
		// "return", allow the original .return call to continue in the
		// outer generator.
		if (context.method !== "return") {
		context.method = "next";
		context.arg = undefined$1;
		}

		} else {
		// Re-yield the result returned by the delegate method.
		return info;
		}

		// The delegate iterator is finished, so forget it and continue with
		// the outer generator.
		context.delegate = null;
		return ContinueSentinel;
		}

		// Define Generator.prototype.{next,throw,return} in terms of the
		// unified ._invoke helper method.
		defineIteratorMethods(Gp);

		Gp[toStringTagSymbol] = "Generator";

		// A Generator should always return itself as the iterator object when the
		// @@iterator function is called on it. Some browsers' implementations of the
		// iterator prototype chain incorrectly implement this, causing the Generator
		// object to not be returned from this call. This ensures that doesn't happen.
		// See https://github.com/facebook/regenerator/issues/274 for more details.
		Gp[iteratorSymbol] = function() {
		return this;
		};

		Gp.toString = function() {
		return "[object Generator]";
		};

		function pushTryEntry(locs) {
		var entry = { tryLoc: locs[0] };

		if (1 in locs) {
		entry.catchLoc = locs[1];
		}

		if (2 in locs) {
		entry.finallyLoc = locs[2];
		entry.afterLoc = locs[3];
		}

		this.tryEntries.push(entry);
		}

		function resetTryEntry(entry) {
		var record = entry.completion \|\| {};
		record.type = "normal";
		delete record.arg;
		entry.completion = record;
		}

		function Context(tryLocsList) {
		// The root entry object (effectively a try statement without a catch
		// or a finally block) gives us a place to store values thrown from
		// locations where there is no enclosing try statement.
		this.tryEntries = [{ tryLoc: "root" }];
		tryLocsList.forEach(pushTryEntry, this);
		this.reset(true);
		}

		runtime.keys = function(object) {
		var keys = [];
		for (var key in object) {
		keys.push(key);
		}
		keys.reverse();

		// Rather than returning an object with a next method, we keep
		// things simple and return the next function itself.
		return function next() {
		while (keys.length) {
		var key = keys.pop();
		if (key in object) {
		next.value = key;
		next.done = false;
		return next;
		}
		}

		// To avoid creating an additional object, we just hang the .value
		// and .done properties off the next function object itself. This
		// also ensures that the minifier will not anonymize the function.
		next.done = true;
		return next;
		};
		};

		function values(iterable) {
		if (iterable) {
		var iteratorMethod = iterable[iteratorSymbol];
		if (iteratorMethod) {
		return iteratorMethod.call(iterable);
		}

		if (typeof iterable.next === "function") {
		return iterable;
		}

		if (!isNaN(iterable.length)) {
		var i = -1, next = function next() {
		while (++i < iterable.length) {
		if (hasOwn.call(iterable, i)) {
		next.value = iterable[i];
		next.done = false;
		return next;
		}
		}

		next.value = undefined$1;
		next.done = true;

		return next;
		};

		return next.next = next;
		}
		}

		// Return an iterator with no values.
		return { next: doneResult };
		}
		runtime.values = values;

		function doneResult() {
		return { value: undefined$1, done: true };
		}

		Context.prototype = {
		constructor: Context,

		reset: function(skipTempReset) {
		this.prev = 0;
		this.next = 0;
		// Resetting context._sent for legacy support of Babel's
		// function.sent implementation.
		this.sent = this._sent = undefined$1;
		this.done = false;
		this.delegate = null;

		this.method = "next";
		this.arg = undefined$1;

		this.tryEntries.forEach(resetTryEntry);

		if (!skipTempReset) {
		for (var name in this) {
		// Not sure about the optimal order of these conditions:
		if (name.charAt(0) === "t" &&
		hasOwn.call(this, name) &&
		!isNaN(+name.slice(1))) {
		this[name] = undefined$1;
		}
		}
		}
		},

		stop: function() {
		this.done = true;

		var rootEntry = this.tryEntries[0];
		var rootRecord = rootEntry.completion;
		if (rootRecord.type === "throw") {
		throw rootRecord.arg;
		}

		return this.rval;
		},

		dispatchException: function(exception) {
		if (this.done) {
		throw exception;
		}

		var context = this;
		function handle(loc, caught) {
		record.type = "throw";
		record.arg = exception;
		context.next = loc;

		if (caught) {
		// If the dispatched exception was caught by a catch block,
		// then let that catch block handle the exception normally.
		context.method = "next";
		context.arg = undefined$1;
		}

		return !! caught;
		}

		for (var i = this.tryEntries.length - 1; i >= 0; --i) {
		var entry = this.tryEntries[i];
		var record = entry.completion;

		if (entry.tryLoc === "root") {
		// Exception thrown outside of any try block that could handle
		// it, so set the completion value of the entire function to
		// throw the exception.
		return handle("end");
		}

		if (entry.tryLoc <= this.prev) {
		var hasCatch = hasOwn.call(entry, "catchLoc");
		var hasFinally = hasOwn.call(entry, "finallyLoc");

		if (hasCatch && hasFinally) {
		if (this.prev < entry.catchLoc) {
		return handle(entry.catchLoc, true);
		} else if (this.prev < entry.finallyLoc) {
		return handle(entry.finallyLoc);
		}

		} else if (hasCatch) {
		if (this.prev < entry.catchLoc) {
		return handle(entry.catchLoc, true);
		}

		} else if (hasFinally) {
		if (this.prev < entry.finallyLoc) {
		return handle(entry.finallyLoc);
		}

		} else {
		throw new Error("try statement without catch or finally");
		}
		}
		}
		},

		abrupt: function(type, arg) {
		for (var i = this.tryEntries.length - 1; i >= 0; --i) {
		var entry = this.tryEntries[i];
		if (entry.tryLoc <= this.prev &&
		hasOwn.call(entry, "finallyLoc") &&
		this.prev < entry.finallyLoc) {
		var finallyEntry = entry;
		break;
		}
		}

		if (finallyEntry &&
		(type === "break" \|\|
		type === "continue") &&
		finallyEntry.tryLoc <= arg &&
		arg <= finallyEntry.finallyLoc) {
		// Ignore the finally entry if control is not jumping to a
		// location outside the try/catch block.
		finallyEntry = null;
		}

		var record = finallyEntry ? finallyEntry.completion : {};
		record.type = type;
		record.arg = arg;

		if (finallyEntry) {
		this.method = "next";
		this.next = finallyEntry.finallyLoc;
		return ContinueSentinel;
		}

		return this.complete(record);
		},

		complete: function(record, afterLoc) {
		if (record.type === "throw") {
		throw record.arg;
		}

		if (record.type === "break" \|\|
		record.type === "continue") {
		this.next = record.arg;
		} else if (record.type === "return") {
		this.rval = this.arg = record.arg;
		this.method = "return";
		this.next = "end";
		} else if (record.type === "normal" && afterLoc) {
		this.next = afterLoc;
		}

		return ContinueSentinel;
		},

		finish: function(finallyLoc) {
		for (var i = this.tryEntries.length - 1; i >= 0; --i) {
		var entry = this.tryEntries[i];
		if (entry.finallyLoc === finallyLoc) {
		this.complete(entry.completion, entry.afterLoc);
		resetTryEntry(entry);
		return ContinueSentinel;
		}
		}
		},

		"catch": function(tryLoc) {
		for (var i = this.tryEntries.length - 1; i >= 0; --i) {
		var entry = this.tryEntries[i];
		if (entry.tryLoc === tryLoc) {
		var record = entry.completion;
		if (record.type === "throw") {
		var thrown = record.arg;
		resetTryEntry(entry);
		}
		return thrown;
		}
		}

		// The context.catch method must only be called with a location
		// argument that corresponds to a known catch block.
		throw new Error("illegal catch attempt");
		},

		delegateYield: function(iterable, resultName, nextLoc) {
		this.delegate = {
		iterator: values(iterable),
		resultName: resultName,
		nextLoc: nextLoc
		};

		if (this.method === "next") {
		// Deliberately forget the last sent value so that we don't
		// accidentally pass it on to the delegate.
		this.arg = undefined$1;
		}

		return ContinueSentinel;
		}
		};
		})(
		// In sloppy mode, unbound `this` refers to the global object, fallback to
		// Function constructor if we're in global strict mode. That is sadly a form
		// of indirect eval which violates Content Security Policy.
		(function() {
		return this \|\| (typeof self === "object" && self);
		})() \|\| Function("return this")()
		);
		});

		/**
		* Copyright (c) 2014-present, Facebook, Inc.
		*
		* This source code is licensed under the MIT license found in the
		* LICENSE file in the root directory of this source tree.
		*/

		// This method of obtaining a reference to the global object needs to be
		// kept identical to the way it is obtained in runtime.js
		var g = (function() {
		return this \|\| (typeof self === "object" && self);
		})() \|\| Function("return this")();

		// Use `getOwnPropertyNames` because not all browsers support calling
		// `hasOwnProperty` on the global `self` object in a worker. See #183.
		var hadRuntime = g.regeneratorRuntime &&
		Object.getOwnPropertyNames(g).indexOf("regeneratorRuntime") >= 0;

		// Save the old regeneratorRuntime in case it needs to be restored later.
		var oldRuntime = hadRuntime && g.regeneratorRuntime;

		// Force reevalutation of runtime.js.
		g.regeneratorRuntime = undefined;

		var runtimeModule = runtime;

		if (hadRuntime) {
		// Restore the original runtime.
		g.regeneratorRuntime = oldRuntime;
		} else {
		// Remove the global property added by runtime.js.
		try {
		delete g.regeneratorRuntime;
		} catch(e) {
		g.regeneratorRuntime = undefined;
		}
		}

		var regenerator = runtimeModule;

		function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
		try {
		var info = gen[key](arg);
		var value = info.value;
		} catch (error) {
		reject(error);
		return;
		}

		if (info.done) {
		resolve(value);
		} else {
		Promise.resolve(value).then(_next, _throw);
		}
		}

		function _asyncToGenerator(fn) {
		return function () {
		var self = this,
		args = arguments;
		return new Promise(function (resolve, reject) {
		var gen = fn.apply(self, args);

		function _next(value) {
		asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
		}

		function _throw(err) {
		asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
		}

		_next(undefined);
		});
		};
		}

		function _defineProperty(obj, key, value) {
		if (key in obj) {
		Object.defineProperty(obj, key, {
		value: value,
		enumerable: true,
		configurable: true,
		writable: true
		});
		} else {
		obj[key] = value;
		}

		return obj;
		}

		function _asyncIterator(iterable) {
		var method;

		if (typeof Symbol === "function") {
		if (Symbol.asyncIterator) {
		method = iterable[Symbol.asyncIterator];
		if (method != null) return method.call(iterable);
		}

		if (Symbol.iterator) {
		method = iterable[Symbol.iterator];
		if (method != null) return method.call(iterable);
		}
		}

		throw new TypeError("Object is not async iterable");
		}

		var includeRe = /([^,()]*)([(),]\|$)/g;
		function getQuery(include) {
		if (!include) return {};
		includeRe.lastIndex = 0;
		var stack = [{}];

		do {
		// eslint-disable-next-line no-unused-vars
		var _includeRe$exec = includeRe.exec(include),
		_ = _includeRe$exec[0],
		key = _includeRe$exec[1],
		delim = _includeRe$exec[2];

		var query = stack[stack.length - 1];
		if (key) query[key] = true;

		switch (delim) {
		case '(':
		if (!key) throw 'parse.unexpected_open';
		query[key] = {};
		stack.push(query[key]);
		break;

		case ')':
		if (stack.length <= 1) throw 'parse.unexpected_close';
		stack.pop();
		}
		} while (includeRe.lastIndex < include.length);

		if (stack.length !== 1) throw 'parse.missing_close';
		return stack[0];
		}

		var url = require('url');

		var GraffyServer = function GraffyServer() {
		var _this = this;

		_defineProperty(this, "graffy", function (s) {
		_this.store = s;
		});

		_defineProperty(this, "http",
		/#__PURE__/
		function () {
		var _ref = _asyncToGenerator(
		/#__PURE__/
		regenerator.mark(function _callee(req, res) {
		var parsed, query, stream, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value, _value2;

		return regenerator.wrap(function _callee$(_context) {
		while (1) {
		switch (_context.prev = _context.next) {
		case 0:
		if (!_this.store) {
		res.writeHead(502);
		res.end('Server not ready');
		}

		if (!(req.method === 'GET')) {
		_context.next = 51;
		break;
		}

		parsed = url.parse(req.url, true);
		query = getQuery(parsed.query.include);

		if (!(req.headers['accept'] === 'text/event-stream')) {
		_context.next = 45;
		break;
		}

		res.setHeader('content-type', 'text/event-stream'); // TODO: Resumable subscriptions using timestamp ID.
		// const lastId = req.headers['last-event-id'];

		stream = _this.store.sub(query, {
		values: false
		});
		_iteratorNormalCompletion = true;
		_didIteratorError = false;
		_context.prev = 9;
		_iterator = _asyncIterator(stream);

		case 11:
		_context.next = 13;
		return _iterator.next();

		case 13:
		_step = _context.sent;
		_iteratorNormalCompletion = _step.done;
		_context.next = 17;
		return _step.value;

		case 17:
		_value = _context.sent;

		if (_iteratorNormalCompletion) {
		_context.next = 26;
		break;
		}

		value = _value;

		if (!(req.aborted \|\| res.finished)) {
		_context.next = 22;
		break;
		}

		return _context.abrupt("break", 26);

		case 22:
		res.write("data: " + JSON.stringify(value) + "\n\n");

		case 23:
		_iteratorNormalCompletion = true;
		_context.next = 11;
		break;

		case 26:
		_context.next = 32;
		break;

		case 28:
		_context.prev = 28;
		_context.t0 = _context["catch"](9);
		_didIteratorError = true;
		_iteratorError = _context.t0;

		case 32:
		_context.prev = 32;
		_context.prev = 33;

		if (!(!_iteratorNormalCompletion && _iterator.return != null)) {
		_context.next = 37;
		break;
		}

		_context.next = 37;
		return _iterator.return();

		case 37:
		_context.prev = 37;

		if (!_didIteratorError) {
		_context.next = 40;
		break;
		}

		throw _iteratorError;

		case 40:
		return _context.finish(37);

		case 41:
		return _context.finish(32);

		case 42:
		res.end();
		_context.next = 49;
		break;

		case 45:
		_context.next = 47;
		return _this.store.getRaw(query);

		case 47:
		_value2 = _context.sent;
		res.end(JSON.stringify(_value2));

		case 49:
		_context.next = 53;
		break;

		case 51:
		res.writeHead(501);
		res.end('Not implemented');

		case 53:
		case "end":
		return _context.stop();
		}
		}
		}, _callee, null, [[9, 28, 32, 42], [33,, 37, 41]]);
		}));

		return function (_x, _x2) {
		return _ref.apply(this, arguments);
		};
		}());
		}; // TODO: Write tests!

		module.exports = GraffyServer;
		'use strict';function createCommonjsModule(a,b){return b={exports:{}},a(b,b.exports),b.exports}var runtime=createCommonjsModule(function(a){!function(b){function c(a,b,c,d){var f=b&&b.prototype instanceof e?b:e,g=Object.create(f.prototype),h=new n(d\|\|[]);return g._invoke=j(a,c,h),g}function d(a,b,c){try{return{type:"normal",arg:a.call(b,c)}}catch(a){return{type:"throw",arg:a}}}function e(){}function f(){}function g(){}function h(a){["next","throw","return"].forEach(function(b){a[b]=function(a){return this._invoke(b,a)}})}function i(a){function b(c,e,f,g){var h=d(a[c],a,e);if("throw"===h.type)g(h.arg);else{var i=h.arg,j=i.value;return j&&"object"==typeof j&&s.call(j,"__await")?Promise.resolve(j.__await).then(function(a){b("next",a,f,g)},function(a){b("throw",a,f,g)}):Promise.resolve(j).then(function(a){i.value=a,f(i)},function(a){return b("throw",a,f,g)})}}function c(a,c){function d(){return new Promise(function(d,e){b(a,c,d,e)})}return e=e?e.then(d,d):d()}var e;this._invoke=c}function j(a,b,c){var e="suspendedStart";return function(f,g){if(e==="executing")throw new Error("Generator is already running");if("completed"===e){if("throw"===f)throw g;return p()}for(c.method=f,c.arg=g;;){var h=c.delegate;if(h){var i=k(h,c);if(i){if(i===y)continue;return i}}if("next"===c.method)c.sent=c._sent=c.arg;else if("throw"===c.method){if("suspendedStart"===e)throw e="completed",c.arg;c.dispatchException(c.arg)}else"return"===c.method&&c.abrupt("return",c.arg);e="executing";var j=d(a,b,c);if("normal"===j.type){if(e=c.done?"completed":"suspendedYield",j.arg===y)continue;return{value:j.arg,done:c.done}}"throw"===j.type&&(e="completed",c.method="throw",c.arg=j.arg)}}}function k(a,b){var c=a.iterator[b.method];if(c===q){if(b.delegate=null,"throw"===b.method){if(a.iterator.return&&(b.method="return",b.arg=q,k(a,b),"throw"===b.method))return y;b.method="throw",b.arg=new TypeError("The iterator does not provide a 'throw' method")}return y}var e=d(c,a.iterator,b.arg);if("throw"===e.type)return b.method="throw",b.arg=e.arg,b.delegate=null,y;var f=e.arg;if(!f)return b.method="throw",b.arg=new TypeError("iterator result is not an object"),b.delegate=null,y;if(f.done)b[a.resultName]=f.value,b.next=a.nextLoc,"return"!==b.method&&(b.method="next",b.arg=q);else return f;return b.delegate=null,y}function l(a){var b={tryLoc:a[0]};1 in a&&(b.catchLoc=a[1]),2 in a&&(b.finallyLoc=a[2],b.afterLoc=a[3]),this.tryEntries.push(b)}function m(a){var b=a.completion\|\|{};b.type="normal",delete b.arg,a.completion=b}function n(a){this.tryEntries=[{tryLoc:"root"}],a.forEach(l,this),this.reset(!0)}function o(a){if(a){var b=a[u];if(b)return b.call(a);if("function"==typeof a.next)return a;if(!isNaN(a.length)){var c=-1,d=function b(){for(;++c<a.length;)if(s.call(a,c))return b.value=a[c],b.done=!1,b;return b.value=q,b.done=!0,b};return d.next=d}}return{next:p}}function p(){return{value:q,done:!0}}var q,r=Object.prototype,s=r.hasOwnProperty,t="function"==typeof Symbol?Symbol:{},u=t.iterator\|\|"@@iterator",v=t.asyncIterator\|\|"@@asyncIterator",w=t.toStringTag\|\|"@@toStringTag",x=b.regeneratorRuntime;if(x)return void(a.exports=x);x=b.regeneratorRuntime=a.exports,x.wrap=c;var y={},z={};z[u]=function(){return this};var A=Object.getPrototypeOf,B=A&&A(A(o([])));B&&B!==r&&s.call(B,u)&&(z=B);var C=g.prototype=e.prototype=Object.create(z);f.prototype=C.constructor=g,g.constructor=f,g[w]=f.displayName="GeneratorFunction",x.isGeneratorFunction=function(a){var b="function"==typeof a&&a.constructor;return!!b&&(b===f\|\|"GeneratorFunction"===(b.displayName\|\|b.name))},x.mark=function(a){return Object.setPrototypeOf?Object.setPrototypeOf(a,g):(a.__proto__=g,!(w in a)&&(a[w]="GeneratorFunction")),a.prototype=Object.create(C),a},x.awrap=function(a){return{__await:a}},h(i.prototype),i.prototype[v]=function(){return this},x.AsyncIterator=i,x.async=function(a,b,d,e){var f=new i(c(a,b,d,e));return x.isGeneratorFunction(b)?f:f.next().then(function(a){return a.done?a.value:f.next()})},h(C),C[w]="Generator",C[u]=function(){return this},C.toString=function(){return"[object Generator]"},x.keys=function(a){var b=[];for(var c in a)b.push(c);return b.reverse(),function c(){for(;b.length;){var d=b.pop();if(d in a)return c.value=d,c.done=!1,c}return c.done=!0,c}},x.values=o,n.prototype={constructor:n,reset:function c(a){if(this.prev=0,this.next=0,this.sent=this._sent=q,this.done=!1,this.delegate=null,this.method="next",this.arg=q,this.tryEntries.forEach(m),!a)for(var b in this)"t"===b.charAt(0)&&s.call(this,b)&&!isNaN(+b.slice(1))&&(this[b]=q)},stop:function c(){this.done=!0;var a=this.tryEntries[0],b=a.completion;if("throw"===b.type)throw b.arg;return this.rval},dispatchException:function j(a){function b(b,d){return f.type="throw",f.arg=a,c.next=b,d&&(c.method="next",c.arg=q),!!d}if(this.done)throw a;for(var c=this,d=this.tryEntries.length-1;0<=d;--d){var e=this.tryEntries[d],f=e.completion;if("root"===e.tryLoc)return b("end");if(e.tryLoc<=this.prev){var g=s.call(e,"catchLoc"),h=s.call(e,"finallyLoc");if(g&&h){if(this.prev<e.catchLoc)return b(e.catchLoc,!0);if(this.prev<e.finallyLoc)return b(e.finallyLoc)}else if(g){if(this.prev<e.catchLoc)return b(e.catchLoc,!0);}else if(!h)throw new Error("try statement without catch or finally");else if(this.prev<e.finallyLoc)return b(e.finallyLoc)}}},abrupt:function g(a,b){for(var c,d=this.tryEntries.length-1;0<=d;--d)if(c=this.tryEntries[d],c.tryLoc<=this.prev&&s.call(c,"finallyLoc")&&this.prev<c.finallyLoc){var e=c;break}e&&("break"===a\|\|"continue"===a)&&e.tryLoc<=b&&b<=e.finallyLoc&&(e=null);var f=e?e.completion:{};return f.type=a,f.arg=b,e?(this.method="next",this.next=e.finallyLoc,y):this.complete(f)},complete:function c(a,b){if("throw"===a.type)throw a.arg;return"break"===a.type\|\|"continue"===a.type?this.next=a.arg:"return"===a.type?(this.rval=this.arg=a.arg,this.method="return",this.next="end"):"normal"===a.type&&b&&(this.next=b),y},finish:function d(a){for(var b,c=this.tryEntries.length-1;0<=c;--c)if(b=this.tryEntries[c],b.finallyLoc===a)return this.complete(b.completion,b.afterLoc),m(b),y},catch:function f(a){for(var b,c=this.tryEntries.length-1;0<=c;--c)if(b=this.tryEntries[c],b.tryLoc===a){var d=b.completion;if("throw"===d.type){var e=d.arg;m(b)}return e}throw new Error("illegal catch attempt")},delegateYield:function d(a,b,c){return this.delegate={iterator:o(a),resultName:b,nextLoc:c},"next"===this.method&&(this.arg=q),y}}}(function(){return this\|\|"object"==typeof self&&self}()\|\|Function("return this")())}),g=function(){return this\|\|"object"==typeof self&&self}()\|\|Function("return this")(),hadRuntime=g.regeneratorRuntime&&0<=Object.getOwnPropertyNames(g).indexOf("regeneratorRuntime"),oldRuntime=hadRuntime&&g.regeneratorRuntime;g.regeneratorRuntime=void 0;var runtimeModule=runtime;if(hadRuntime)g.regeneratorRuntime=oldRuntime;else try{delete g.regeneratorRuntime}catch(a){g.regeneratorRuntime=void 0}var regenerator=runtimeModule;function asyncGeneratorStep(a,b,c,d,e,f,g){try{var h=a[f](g),i=h.value}catch(a){return void c(a)}h.done?b(i):Promise.resolve(i).then(d,e)}function _asyncToGenerator(a){return function(){var b=this,c=arguments;return new Promise(function(d,e){function f(a){asyncGeneratorStep(h,d,e,f,g,"next",a)}function g(a){asyncGeneratorStep(h,d,e,f,g,"throw",a)}var h=a.apply(b,c);f(void 0)})}}function _defineProperty(a,b,c){return b in a?Object.defineProperty(a,b,{value:c,enumerable:!0,configurable:!0,writable:!0}):a[b]=c,a}function _asyncIterator(a){var b;if("function"==typeof Symbol){if(Symbol.asyncIterator&&(b=a[Symbol.asyncIterator],null!=b))return b.call(a);if(Symbol.iterator&&(b=a[Symbol.iterator],null!=b))return b.call(a)}throw new TypeError("Object is not async iterable")}var includeRe=/([^,()]*)([(),]\|$)/g;function getQuery(a){if(!a)return{};includeRe.lastIndex=0;var b=[{}];do{var c=includeRe.exec(a),d=c[0],e=c[1],f=c[2],g=b[b.length-1];switch(e&&(g[e]=!0),f){case"(":if(!e)throw"parse.unexpected_open";g[e]={},b.push(g[e]);break;case")":if(1>=b.length)throw"parse.unexpected_close";b.pop();}}while(includeRe.lastIndex<a.length);if(1!==b.length)throw"parse.missing_close";return b[0]}var url=require("url"),GraffyServer=function(){var a=this;_defineProperty(this,"graffy",function(b){a.store=b}),_defineProperty(this,"http",function(){var b=_asyncToGenerator(regenerator.mark(function b(c,d){var e,f,g,h,i,j,k,l,m,n,o;return regenerator.wrap(function(b){for(;;)switch(b.prev=b.next){case 0:if(a.store\|\|(d.writeHead(502),d.end("Server not ready")),"GET"!==c.method){b.next=51;break}if(e=url.parse(c.url,!0),f=getQuery(e.query.include),"text/event-stream"!==c.headers.accept){b.next=45;break}d.setHeader("content-type","text/event-stream"),g=a.store.sub(f,{values:!1}),h=!0,i=!1,b.prev=9,k=_asyncIterator(g);case 11:return b.next=13,k.next();case 13:return l=b.sent,h=l.done,b.next=17,l.value;case 17:if(m=b.sent,h){b.next=26;break}if(n=m,!(c.aborted\|\|d.finished)){b.next=22;break}return b.abrupt("break",26);case 22:d.write("data: "+JSON.stringify(n)+"\n\n");case 23:h=!0,b.next=11;break;case 26:b.next=32;break;case 28:b.prev=28,b.t0=b["catch"](9),i=!0,j=b.t0;case 32:if(b.prev=32,b.prev=33,h\|\|null==k.return){b.next=37;break}return b.next=37,k.return();case 37:if(b.prev=37,!i){b.next=40;break}throw j;case 40:return b.finish(37);case 41:return b.finish(32);case 42:d.end(),b.next=49;break;case 45:return b.next=47,a.store.getRaw(f);case 47:o=b.sent,d.end(JSON.stringify(o));case 49:b.next=53;break;case 51:d.writeHead(501),d.end("Not implemented");case 53:case"end":return b.stop();}},b,null,[[9,28,32,42],[33,,37,41]])}));return function(){return b.apply(this,arguments)}}())};module.exports=GraffyServer;
		//# sourceMappingURL=bundle.js.map

package.json

		{
		"name": "@graffy/server",
		"version": "0.6.0",
		"version": "0.7.1",
		"author": "aravind (github.com/aravindet)",
		@@ -5,0 +5,0 @@ "description": "HTTP Server for Graffy",

bundle.mjs

Sorry, the diff of this file is not supported yet

@graffy/server - npm Package Compare versions

New alerts

Worsened metrics