zenparsing

(function() { 'use strict';

function consume(observable, gen) {

    return new Promise((resolve, reject) => {
            
        if (typeof gen === "function") {
            // Prime the generator to accept values
            gen = gen();
            gen.next();

zenparsing

class X {
    constructor(len) {
        let target = Object.create(new.target.prototype);

        let handler = {
            // handler stuff - special logic for "length" and integer properties
            // Otherwise, use target's properties
        };

        return Reflect.construct(Proxy, [target, handler], new.target);

zenparsing

function zip(list) {

    return new Observable(sink => {

        function trySend() {

            // If every buffer has at least one element, then send an array
            // containing every first element and remove those elements from the
            // buffer
            if (streams.every(s => s.buffer.length > 0))

zenparsing

// For a nested stream, emits the elements of the inner stream contained within the
// most recent outer stream
function switch(stream, n) {

    return new Observable(sink => {

        let inner = [];

        let outer = stream.subscribe({

zenparsing

// Use this gist to get syntax highlighted code for use in word processors.  Just preview a comment
// that contains code.

zenparsing

A context object is associated with any AST node which may have "strictness". Each context has a strictness state: UNKOWN, STRICT, and NOT_STRICT. In order to account for arrow functions, parenthesized expressions are also assigned a context.

When a context C is pushed:

• set C.parent to the current context object
• set C.strictError to null
• if C.parent.strict is STRICT
  • set C.strict to STRICT
• else
• set C.strict to UNKNOWN

zenparsing

function enqueueMicrotask(fn) {

    // Enqueue a function on the System-defined FIFO
    // microtask queue.
}

var $status = "Promise#status",
    $value = "Promise#value",
    $onResolve = "Promise#onResolve",
    $onReject = "Promise#onReject";

zenparsing

// OK if a script, but not ok if a "module".
// We'll have to remember this error and location as we parse.
with (x) {}

// The export declaration means that we need to throw a parse error 
// using the location of the "with" statement.
export const A = "a";

// V8 doesn't remember strict mode errors like this, and the V8 team has
// previously objected to features which seem to require it.

zenparsing

const DELETED_TOKEN = {};

/*

A map class, implemented with private slots, which has the following properties:

- The presence of a mapping k => v in a SlotMap does not by itself make k or v reachable
- For each mapping k => v in a SlotMap m (whether m is reachable or not), if k is reachable then v is reachable

*/

zenparsing

function takeUntil(control) {

    return new Observable((next, cancel) => new Promise((resolve, reject) => {
        this.forEach(next, cancel).then(resolve, reject);
        control.forEach(resolve, cancel).catch(reject);
    }));
}

function switch() {