zenparsing

const unwrapSymbol = Symbol();

function Definitely(x) {

    if (x == null || !(unwrapSymbol in x))
        return x;
    
    return x[unwrapSymbol];
}

zenparsing

Observable.from = function(iterable) {

    return new Observable((push, error, close) => {

        try { for (let x of iterable) push(x) }
        catch (x) { error(x) }
        finally { close() }
    });
};

zenparsing

async function* flattenStreams(asyncIterList) {

    function deferred() {
        let capability = {};
        capability.promise = new Promise((resolve, reject) => {
            capability.resolve = resolve;
            capability.reject = reject;
        });
        return capability;
    }

zenparsing

function toObservable(asyncIter) {
    return new Observable(sink => {
    
        let abort = false;
        
        (async _=> {
            try {
                for async (let x of asyncIter) {
                    if (abort) return;
                    sink.next(x);

zenparsing

function toObservable(asyncIter) {
    return new Observable(sink => {
    
        let abort = false;
        
        (async _=> {
            try {
                for async (let x of asyncIter) {
                    if (abort) return;
                    sink.next(x);

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

// 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.