discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/@glimmer/util.js

@@ -1,189 +0,0 @@
-function unwrap(val) {
-    if (val === null || val === undefined) throw new Error(`Expected value to be present`);
-    return val;
-}
-function expect(val, message) {
-    if (val === null || val === undefined) throw new Error(message);
-    return val;
-}
-function unreachable(message = 'unreachable') {
-    return new Error(message);
-}
-
-// import Logger from './logger';
-// let alreadyWarned = false;
-function debugAssert(test, msg) {
-    // if (!alreadyWarned) {
-    //   alreadyWarned = true;
-    //   Logger.warn("Don't leave debug assertions on in public builds");
-    // }
-    if (!test) {
-        throw new Error(msg || 'assertion failure');
-    }
-}
-
-const { keys: objKeys } = Object;
-function assign(obj) {
-    for (let i = 1; i < arguments.length; i++) {
-        let assignment = arguments[i];
-        if (assignment === null || typeof assignment !== 'object') continue;
-        let keys = objKeys(assignment);
-        for (let j = 0; j < keys.length; j++) {
-            let key = keys[j];
-            obj[key] = assignment[key];
-        }
-    }
-    return obj;
-}
-function fillNulls(count) {
-    let arr = new Array(count);
-    for (let i = 0; i < count; i++) {
-        arr[i] = null;
-    }
-    return arr;
-}
-
-let GUID = 0;
-function initializeGuid(object) {
-    return object._guid = ++GUID;
-}
-function ensureGuid(object) {
-    return object._guid || initializeGuid(object);
-}
-
-const SERIALIZATION_FIRST_NODE_STRING = '%+b:0%';
-function isSerializationFirstNode(node) {
-    return node.nodeValue === SERIALIZATION_FIRST_NODE_STRING;
-}
-
-function dict() {
-    return Object.create(null);
-}
-class DictSet {
-    constructor() {
-        this.dict = dict();
-    }
-    add(obj) {
-        if (typeof obj === 'string') this.dict[obj] = obj;else this.dict[ensureGuid(obj)] = obj;
-        return this;
-    }
-    delete(obj) {
-        if (typeof obj === 'string') delete this.dict[obj];else if (obj._guid) delete this.dict[obj._guid];
-    }
-}
-class Stack {
-    constructor() {
-        this.stack = [];
-        this.current = null;
-    }
-    get size() {
-        return this.stack.length;
-    }
-    push(item) {
-        this.current = item;
-        this.stack.push(item);
-    }
-    pop() {
-        let item = this.stack.pop();
-        let len = this.stack.length;
-        this.current = len === 0 ? null : this.stack[len - 1];
-        return item === undefined ? null : item;
-    }
-    isEmpty() {
-        return this.stack.length === 0;
-    }
-}
-
-class ListNode {
-    constructor(value) {
-        this.next = null;
-        this.prev = null;
-        this.value = value;
-    }
-}
-class LinkedList {
-    constructor() {
-        this.clear();
-    }
-    head() {
-        return this._head;
-    }
-    tail() {
-        return this._tail;
-    }
-    clear() {
-        this._head = this._tail = null;
-    }
-    toArray() {
-        let out = [];
-        this.forEachNode(n => out.push(n));
-        return out;
-    }
-    nextNode(node) {
-        return node.next;
-    }
-    forEachNode(callback) {
-        let node = this._head;
-        while (node !== null) {
-            callback(node);
-            node = node.next;
-        }
-    }
-    insertBefore(node, reference = null) {
-        if (reference === null) return this.append(node);
-        if (reference.prev) reference.prev.next = node;else this._head = node;
-        node.prev = reference.prev;
-        node.next = reference;
-        reference.prev = node;
-        return node;
-    }
-    append(node) {
-        let tail = this._tail;
-        if (tail) {
-            tail.next = node;
-            node.prev = tail;
-            node.next = null;
-        } else {
-            this._head = node;
-        }
-        return this._tail = node;
-    }
-    remove(node) {
-        if (node.prev) node.prev.next = node.next;else this._head = node.next;
-        if (node.next) node.next.prev = node.prev;else this._tail = node.prev;
-        return node;
-    }
-}
-class ListSlice {
-    constructor(head, tail) {
-        this._head = head;
-        this._tail = tail;
-    }
-    forEachNode(callback) {
-        let node = this._head;
-        while (node !== null) {
-            callback(node);
-            node = this.nextNode(node);
-        }
-    }
-    head() {
-        return this._head;
-    }
-    tail() {
-        return this._tail;
-    }
-    toArray() {
-        let out = [];
-        this.forEachNode(n => out.push(n));
-        return out;
-    }
-    nextNode(node) {
-        if (node === this._tail) return null;
-        return node.next;
-    }
-}
-const EMPTY_SLICE = new ListSlice(null, null);
-
-const EMPTY_ARRAY = Object.freeze([]);
-
-export { debugAssert as assert, assign, fillNulls, ensureGuid, initializeGuid, isSerializationFirstNode, SERIALIZATION_FIRST_NODE_STRING, Stack, DictSet, dict, EMPTY_SLICE, LinkedList, ListNode, ListSlice, EMPTY_ARRAY, unwrap, expect, unreachable };

data/dist/es/@glimmer/vm.js

@@ -1,27 +0,0 @@
-/**
- * Registers
- *
- * For the most part, these follows MIPS naming conventions, however the
- * register numbers are different.
- */
-var Register;
-(function (Register) {
-    // $0 or $pc (program counter): pointer into `program` for the next insturction; -1 means exit
-    Register[Register["pc"] = 0] = "pc";
-    // $1 or $ra (return address): pointer into `program` for the return
-    Register[Register["ra"] = 1] = "ra";
-    // $2 or $fp (frame pointer): pointer into the `evalStack` for the base of the stack
-    Register[Register["fp"] = 2] = "fp";
-    // $3 or $sp (stack pointer): pointer into the `evalStack` for the top of the stack
-    Register[Register["sp"] = 3] = "sp";
-    // $4-$5 or $s0-$s1 (saved): callee saved general-purpose registers
-    Register[Register["s0"] = 4] = "s0";
-    Register[Register["s1"] = 5] = "s1";
-    // $6-$7 or $t0-$t1 (temporaries): caller saved general-purpose registers
-    Register[Register["t0"] = 6] = "t0";
-    Register[Register["t1"] = 7] = "t1";
-    // $8 or $v0 (return value)
-    Register[Register["v0"] = 8] = "v0";
-})(Register || (Register = {}));
-
-export { Register };

data/dist/es/@glimmer/wire-format.js

@@ -1,56 +0,0 @@
-var Opcodes;
-(function (Opcodes) {
-    // Statements
-    Opcodes[Opcodes["Text"] = 0] = "Text";
-    Opcodes[Opcodes["Append"] = 1] = "Append";
-    Opcodes[Opcodes["Comment"] = 2] = "Comment";
-    Opcodes[Opcodes["Modifier"] = 3] = "Modifier";
-    Opcodes[Opcodes["Block"] = 4] = "Block";
-    Opcodes[Opcodes["Component"] = 5] = "Component";
-    Opcodes[Opcodes["DynamicComponent"] = 6] = "DynamicComponent";
-    Opcodes[Opcodes["OpenElement"] = 7] = "OpenElement";
-    Opcodes[Opcodes["OpenSplattedElement"] = 8] = "OpenSplattedElement";
-    Opcodes[Opcodes["FlushElement"] = 9] = "FlushElement";
-    Opcodes[Opcodes["CloseElement"] = 10] = "CloseElement";
-    Opcodes[Opcodes["StaticAttr"] = 11] = "StaticAttr";
-    Opcodes[Opcodes["DynamicAttr"] = 12] = "DynamicAttr";
-    Opcodes[Opcodes["AttrSplat"] = 13] = "AttrSplat";
-    Opcodes[Opcodes["Yield"] = 14] = "Yield";
-    Opcodes[Opcodes["Partial"] = 15] = "Partial";
-    Opcodes[Opcodes["DynamicArg"] = 16] = "DynamicArg";
-    Opcodes[Opcodes["StaticArg"] = 17] = "StaticArg";
-    Opcodes[Opcodes["TrustingAttr"] = 18] = "TrustingAttr";
-    Opcodes[Opcodes["Debugger"] = 19] = "Debugger";
-    Opcodes[Opcodes["ClientSideStatement"] = 20] = "ClientSideStatement";
-    // Expressions
-    Opcodes[Opcodes["Unknown"] = 21] = "Unknown";
-    Opcodes[Opcodes["Get"] = 22] = "Get";
-    Opcodes[Opcodes["MaybeLocal"] = 23] = "MaybeLocal";
-    Opcodes[Opcodes["HasBlock"] = 24] = "HasBlock";
-    Opcodes[Opcodes["HasBlockParams"] = 25] = "HasBlockParams";
-    Opcodes[Opcodes["Undefined"] = 26] = "Undefined";
-    Opcodes[Opcodes["Helper"] = 27] = "Helper";
-    Opcodes[Opcodes["Concat"] = 28] = "Concat";
-    Opcodes[Opcodes["ClientSideExpression"] = 29] = "ClientSideExpression";
-})(Opcodes || (Opcodes = {}));
-
-function is(variant) {
-    return function (value) {
-        return Array.isArray(value) && value[0] === variant;
-    };
-}
-// Statements
-const isModifier = is(Opcodes.Modifier);
-const isFlushElement = is(Opcodes.FlushElement);
-const isAttrSplat = is(Opcodes.AttrSplat);
-function isAttribute(val) {
-    return val[0] === Opcodes.StaticAttr || val[0] === Opcodes.DynamicAttr || val[0] === Opcodes.TrustingAttr;
-}
-function isArgument(val) {
-    return val[0] === Opcodes.StaticArg || val[0] === Opcodes.DynamicArg;
-}
-// Expressions
-const isGet = is(Opcodes.Get);
-const isMaybeLocal = is(Opcodes.MaybeLocal);
-
-export { is, isModifier, isFlushElement, isAttrSplat, isAttribute, isArgument, isGet, isMaybeLocal, Opcodes as Ops };

data/dist/es/backburner.js

@@ -1,936 +0,0 @@
-const SET_TIMEOUT = setTimeout;
-const NOOP = () => { };
-function buildPlatform(flush) {
-    let next;
-    let clearNext = NOOP;
-    if (typeof MutationObserver === 'function') {
-        let iterations = 0;
-        let observer = new MutationObserver(flush);
-        let node = document.createTextNode('');
-        observer.observe(node, { characterData: true });
-        next = () => {
-            iterations = ++iterations % 2;
-            node.data = '' + iterations;
-            return iterations;
-        };
-    }
-    else if (typeof Promise === 'function') {
-        const autorunPromise = Promise.resolve();
-        next = () => autorunPromise.then(flush);
-    }
-    else {
-        next = () => SET_TIMEOUT(flush, 0);
-    }
-    return {
-        setTimeout(fn, ms) {
-            return setTimeout(fn, ms);
-        },
-        clearTimeout(timerId) {
-            return clearTimeout(timerId);
-        },
-        now() {
-            return Date.now();
-        },
-        next,
-        clearNext,
-    };
-}
-
-const NUMBER = /\d+/;
-const TIMERS_OFFSET = 6;
-function isCoercableNumber(suspect) {
-    let type = typeof suspect;
-    return type === 'number' && suspect === suspect || type === 'string' && NUMBER.test(suspect);
-}
-function getOnError(options) {
-    return options.onError || (options.onErrorTarget && options.onErrorTarget[options.onErrorMethod]);
-}
-function findItem(target, method, collection) {
-    let index = -1;
-    for (let i = 0, l = collection.length; i < l; i += 4) {
-        if (collection[i] === target && collection[i + 1] === method) {
-            index = i;
-            break;
-        }
-    }
-    return index;
-}
-function findTimerItem(target, method, collection) {
-    let index = -1;
-    for (let i = 2, l = collection.length; i < l; i += 6) {
-        if (collection[i] === target && collection[i + 1] === method) {
-            index = i - 2;
-            break;
-        }
-    }
-    return index;
-}
-function getQueueItems(items, queueItemLength, queueItemPositionOffset = 0) {
-    let queueItems = [];
-    for (let i = 0; i < items.length; i += queueItemLength) {
-        let maybeError = items[i + 3 /* stack */ + queueItemPositionOffset];
-        let queueItem = {
-            target: items[i + 0 /* target */ + queueItemPositionOffset],
-            method: items[i + 1 /* method */ + queueItemPositionOffset],
-            args: items[i + 2 /* args */ + queueItemPositionOffset],
-            stack: maybeError !== undefined && 'stack' in maybeError ? maybeError.stack : ''
-        };
-        queueItems.push(queueItem);
-    }
-    return queueItems;
-}
-
-function binarySearch(time, timers) {
-    let start = 0;
-    let end = timers.length - TIMERS_OFFSET;
-    let middle;
-    let l;
-    while (start < end) {
-        // since timers is an array of pairs 'l' will always
-        // be an integer
-        l = (end - start) / TIMERS_OFFSET;
-        // compensate for the index in case even number
-        // of pairs inside timers
-        middle = start + l - (l % TIMERS_OFFSET);
-        if (time >= timers[middle]) {
-            start = middle + TIMERS_OFFSET;
-        }
-        else {
-            end = middle;
-        }
-    }
-    return (time >= timers[start]) ? start + TIMERS_OFFSET : start;
-}
-
-const QUEUE_ITEM_LENGTH = 4;
-class Queue {
-    constructor(name, options = {}, globalOptions = {}) {
-        this._queueBeingFlushed = [];
-        this.targetQueues = new Map();
-        this.index = 0;
-        this._queue = [];
-        this.name = name;
-        this.options = options;
-        this.globalOptions = globalOptions;
-    }
-    stackFor(index) {
-        if (index < this._queue.length) {
-            let entry = this._queue[index * 3 + QUEUE_ITEM_LENGTH];
-            if (entry) {
-                return entry.stack;
-            }
-            else {
-                return null;
-            }
-        }
-    }
-    flush(sync) {
-        let { before, after } = this.options;
-        let target;
-        let method;
-        let args;
-        let errorRecordedForStack;
-        this.targetQueues.clear();
-        if (this._queueBeingFlushed.length === 0) {
-            this._queueBeingFlushed = this._queue;
-            this._queue = [];
-        }
-        if (before !== undefined) {
-            before();
-        }
-        let invoke;
-        let queueItems = this._queueBeingFlushed;
-        if (queueItems.length > 0) {
-            let onError = getOnError(this.globalOptions);
-            invoke = onError ? this.invokeWithOnError : this.invoke;
-            for (let i = this.index; i < queueItems.length; i += QUEUE_ITEM_LENGTH) {
-                this.index += QUEUE_ITEM_LENGTH;
-                method = queueItems[i + 1];
-                // method could have been nullified / canceled during flush
-                if (method !== null) {
-                    //
-                    //    ** Attention intrepid developer **
-                    //
-                    //    To find out the stack of this task when it was scheduled onto
-                    //    the run loop, add the following to your app.js:
-                    //
-                    //    Ember.run.backburner.DEBUG = true; // NOTE: This slows your app, don't leave it on in production.
-                    //
-                    //    Once that is in place, when you are at a breakpoint and navigate
-                    //    here in the stack explorer, you can look at `errorRecordedForStack.stack`,
-                    //    which will be the captured stack when this job was scheduled.
-                    //
-                    //    One possible long-term solution is the following Chrome issue:
-                    //       https://bugs.chromium.org/p/chromium/issues/detail?id=332624
-                    //
-                    target = queueItems[i];
-                    args = queueItems[i + 2];
-                    errorRecordedForStack = queueItems[i + 3]; // Debugging assistance
-                    invoke(target, method, args, onError, errorRecordedForStack);
-                }
-                if (this.index !== this._queueBeingFlushed.length &&
-                    this.globalOptions.mustYield && this.globalOptions.mustYield()) {
-                    return 1 /* Pause */;
-                }
-            }
-        }
-        if (after !== undefined) {
-            after();
-        }
-        this._queueBeingFlushed.length = 0;
-        this.index = 0;
-        if (sync !== false && this._queue.length > 0) {
-            // check if new items have been added
-            this.flush(true);
-        }
-    }
-    hasWork() {
-        return this._queueBeingFlushed.length > 0 || this._queue.length > 0;
-    }
-    cancel({ target, method }) {
-        let queue = this._queue;
-        let targetQueueMap = this.targetQueues.get(target);
-        if (targetQueueMap !== undefined) {
-            targetQueueMap.delete(method);
-        }
-        let index = findItem(target, method, queue);
-        if (index > -1) {
-            queue.splice(index, QUEUE_ITEM_LENGTH);
-            return true;
-        }
-        // if not found in current queue
-        // could be in the queue that is being flushed
-        queue = this._queueBeingFlushed;
-        index = findItem(target, method, queue);
-        if (index > -1) {
-            queue[index + 1] = null;
-            return true;
-        }
-        return false;
-    }
-    push(target, method, args, stack) {
-        this._queue.push(target, method, args, stack);
-        return {
-            queue: this,
-            target,
-            method
-        };
-    }
-    pushUnique(target, method, args, stack) {
-        let localQueueMap = this.targetQueues.get(target);
-        if (localQueueMap === undefined) {
-            localQueueMap = new Map();
-            this.targetQueues.set(target, localQueueMap);
-        }
-        let index = localQueueMap.get(method);
-        if (index === undefined) {
-            let queueIndex = this._queue.push(target, method, args, stack) - QUEUE_ITEM_LENGTH;
-            localQueueMap.set(method, queueIndex);
-        }
-        else {
-            let queue = this._queue;
-            queue[index + 2] = args; // replace args
-            queue[index + 3] = stack; // replace stack
-        }
-        return {
-            queue: this,
-            target,
-            method
-        };
-    }
-    _getDebugInfo(debugEnabled) {
-        if (debugEnabled) {
-            let debugInfo = getQueueItems(this._queue, QUEUE_ITEM_LENGTH);
-            return debugInfo;
-        }
-        return undefined;
-    }
-    invoke(target, method, args /*, onError, errorRecordedForStack */) {
-        if (args === undefined) {
-            method.call(target);
-        }
-        else {
-            method.apply(target, args);
-        }
-    }
-    invokeWithOnError(target, method, args, onError, errorRecordedForStack) {
-        try {
-            if (args === undefined) {
-                method.call(target);
-            }
-            else {
-                method.apply(target, args);
-            }
-        }
-        catch (error) {
-            onError(error, errorRecordedForStack);
-        }
-    }
-}
-
-class DeferredActionQueues {
-    constructor(queueNames = [], options) {
-        this.queues = {};
-        this.queueNameIndex = 0;
-        this.queueNames = queueNames;
-        queueNames.reduce(function (queues, queueName) {
-            queues[queueName] = new Queue(queueName, options[queueName], options);
-            return queues;
-        }, this.queues);
-    }
-    /**
-     * @method schedule
-     * @param {String} queueName
-     * @param {Any} target
-     * @param {Any} method
-     * @param {Any} args
-     * @param {Boolean} onceFlag
-     * @param {Any} stack
-     * @return queue
-     */
-    schedule(queueName, target, method, args, onceFlag, stack) {
-        let queues = this.queues;
-        let queue = queues[queueName];
-        if (queue === undefined) {
-            throw new Error(`You attempted to schedule an action in a queue (${queueName}) that doesn\'t exist`);
-        }
-        if (method === undefined || method === null) {
-            throw new Error(`You attempted to schedule an action in a queue (${queueName}) for a method that doesn\'t exist`);
-        }
-        this.queueNameIndex = 0;
-        if (onceFlag) {
-            return queue.pushUnique(target, method, args, stack);
-        }
-        else {
-            return queue.push(target, method, args, stack);
-        }
-    }
-    /**
-     * DeferredActionQueues.flush() calls Queue.flush()
-     *
-     * @method flush
-     * @param {Boolean} fromAutorun
-     */
-    flush(fromAutorun = false) {
-        let queue;
-        let queueName;
-        let numberOfQueues = this.queueNames.length;
-        while (this.queueNameIndex < numberOfQueues) {
-            queueName = this.queueNames[this.queueNameIndex];
-            queue = this.queues[queueName];
-            if (queue.hasWork() === false) {
-                this.queueNameIndex++;
-                if (fromAutorun && this.queueNameIndex < numberOfQueues) {
-                    return 1 /* Pause */;
-                }
-            }
-            else {
-                if (queue.flush(false /* async */) === 1 /* Pause */) {
-                    return 1 /* Pause */;
-                }
-            }
-        }
-    }
-    /**
-     * Returns debug information for the current queues.
-     *
-     * @method _getDebugInfo
-     * @param {Boolean} debugEnabled
-     * @returns {IDebugInfo | undefined}
-     */
-    _getDebugInfo(debugEnabled) {
-        if (debugEnabled) {
-            let debugInfo = {};
-            let queue;
-            let queueName;
-            let numberOfQueues = this.queueNames.length;
-            let i = 0;
-            while (i < numberOfQueues) {
-                queueName = this.queueNames[i];
-                queue = this.queues[queueName];
-                debugInfo[queueName] = queue._getDebugInfo(debugEnabled);
-                i++;
-            }
-            return debugInfo;
-        }
-        return;
-    }
-}
-
-function iteratorDrain (fn) {
-    let iterator = fn();
-    let result = iterator.next();
-    while (result.done === false) {
-        result.value();
-        result = iterator.next();
-    }
-}
-
-const noop = function () { };
-const DISABLE_SCHEDULE = Object.freeze([]);
-function parseArgs() {
-    let length = arguments.length;
-    let args;
-    let method;
-    let target;
-    if (length === 0) {
-    }
-    else if (length === 1) {
-        target = null;
-        method = arguments[0];
-    }
-    else {
-        let argsIndex = 2;
-        let methodOrTarget = arguments[0];
-        let methodOrArgs = arguments[1];
-        let type = typeof methodOrArgs;
-        if (type === 'function') {
-            target = methodOrTarget;
-            method = methodOrArgs;
-        }
-        else if (methodOrTarget !== null && type === 'string' && methodOrArgs in methodOrTarget) {
-            target = methodOrTarget;
-            method = target[methodOrArgs];
-        }
-        else if (typeof methodOrTarget === 'function') {
-            argsIndex = 1;
-            target = null;
-            method = methodOrTarget;
-        }
-        if (length > argsIndex) {
-            let len = length - argsIndex;
-            args = new Array(len);
-            for (let i = 0; i < len; i++) {
-                args[i] = arguments[i + argsIndex];
-            }
-        }
-    }
-    return [target, method, args];
-}
-function parseTimerArgs() {
-    let [target, method, args] = parseArgs(...arguments);
-    let wait = 0;
-    let length = args !== undefined ? args.length : 0;
-    if (length > 0) {
-        let last = args[length - 1];
-        if (isCoercableNumber(last)) {
-            wait = parseInt(args.pop(), 10);
-        }
-    }
-    return [target, method, args, wait];
-}
-function parseDebounceArgs() {
-    let target;
-    let method;
-    let isImmediate;
-    let args;
-    let wait;
-    if (arguments.length === 2) {
-        method = arguments[0];
-        wait = arguments[1];
-        target = null;
-    }
-    else {
-        [target, method, args] = parseArgs(...arguments);
-        if (args === undefined) {
-            wait = 0;
-        }
-        else {
-            wait = args.pop();
-            if (!isCoercableNumber(wait)) {
-                isImmediate = wait === true;
-                wait = args.pop();
-            }
-        }
-    }
-    wait = parseInt(wait, 10);
-    return [target, method, args, wait, isImmediate];
-}
-let UUID = 0;
-let beginCount = 0;
-let endCount = 0;
-let beginEventCount = 0;
-let endEventCount = 0;
-let runCount = 0;
-let joinCount = 0;
-let deferCount = 0;
-let scheduleCount = 0;
-let scheduleIterableCount = 0;
-let deferOnceCount = 0;
-let scheduleOnceCount = 0;
-let setTimeoutCount = 0;
-let laterCount = 0;
-let throttleCount = 0;
-let debounceCount = 0;
-let cancelTimersCount = 0;
-let cancelCount = 0;
-let autorunsCreatedCount = 0;
-let autorunsCompletedCount = 0;
-let deferredActionQueuesCreatedCount = 0;
-let nestedDeferredActionQueuesCreated = 0;
-class Backburner {
-    constructor(queueNames, options) {
-        this.DEBUG = false;
-        this.currentInstance = null;
-        this.instanceStack = [];
-        this._eventCallbacks = {
-            end: [],
-            begin: []
-        };
-        this._timerTimeoutId = null;
-        this._timers = [];
-        this._autorun = null;
-        this.queueNames = queueNames;
-        this.options = options || {};
-        if (typeof this.options.defaultQueue === 'string') {
-            this._defaultQueue = this.options.defaultQueue;
-        }
-        else {
-            this._defaultQueue = this.queueNames[0];
-        }
-        this._onBegin = this.options.onBegin || noop;
-        this._onEnd = this.options.onEnd || noop;
-        this._boundRunExpiredTimers = this._runExpiredTimers.bind(this);
-        this._boundAutorunEnd = () => {
-            autorunsCompletedCount++;
-            // if the autorun was already flushed, do nothing
-            if (this._autorun === null) {
-                return;
-            }
-            this._autorun = null;
-            this._end(true /* fromAutorun */);
-        };
-        let builder = this.options._buildPlatform || buildPlatform;
-        this._platform = builder(this._boundAutorunEnd);
-    }
-    get counters() {
-        return {
-            begin: beginCount,
-            end: endCount,
-            events: {
-                begin: beginEventCount,
-                end: endEventCount,
-            },
-            autoruns: {
-                created: autorunsCreatedCount,
-                completed: autorunsCompletedCount,
-            },
-            run: runCount,
-            join: joinCount,
-            defer: deferCount,
-            schedule: scheduleCount,
-            scheduleIterable: scheduleIterableCount,
-            deferOnce: deferOnceCount,
-            scheduleOnce: scheduleOnceCount,
-            setTimeout: setTimeoutCount,
-            later: laterCount,
-            throttle: throttleCount,
-            debounce: debounceCount,
-            cancelTimers: cancelTimersCount,
-            cancel: cancelCount,
-            loops: {
-                total: deferredActionQueuesCreatedCount,
-                nested: nestedDeferredActionQueuesCreated,
-            },
-        };
-    }
-    get defaultQueue() {
-        return this._defaultQueue;
-    }
-    /*
-      @method begin
-      @return instantiated class DeferredActionQueues
-    */
-    begin() {
-        beginCount++;
-        let options = this.options;
-        let previousInstance = this.currentInstance;
-        let current;
-        if (this._autorun !== null) {
-            current = previousInstance;
-            this._cancelAutorun();
-        }
-        else {
-            if (previousInstance !== null) {
-                nestedDeferredActionQueuesCreated++;
-                this.instanceStack.push(previousInstance);
-            }
-            deferredActionQueuesCreatedCount++;
-            current = this.currentInstance = new DeferredActionQueues(this.queueNames, options);
-            beginEventCount++;
-            this._trigger('begin', current, previousInstance);
-        }
-        this._onBegin(current, previousInstance);
-        return current;
-    }
-    end() {
-        endCount++;
-        this._end(false);
-    }
-    on(eventName, callback) {
-        if (typeof callback !== 'function') {
-            throw new TypeError(`Callback must be a function`);
-        }
-        let callbacks = this._eventCallbacks[eventName];
-        if (callbacks !== undefined) {
-            callbacks.push(callback);
-        }
-        else {
-            throw new TypeError(`Cannot on() event ${eventName} because it does not exist`);
-        }
-    }
-    off(eventName, callback) {
-        let callbacks = this._eventCallbacks[eventName];
-        if (!eventName || callbacks === undefined) {
-            throw new TypeError(`Cannot off() event ${eventName} because it does not exist`);
-        }
-        let callbackFound = false;
-        if (callback) {
-            for (let i = 0; i < callbacks.length; i++) {
-                if (callbacks[i] === callback) {
-                    callbackFound = true;
-                    callbacks.splice(i, 1);
-                    i--;
-                }
-            }
-        }
-        if (!callbackFound) {
-            throw new TypeError(`Cannot off() callback that does not exist`);
-        }
-    }
-    run() {
-        runCount++;
-        let [target, method, args] = parseArgs(...arguments);
-        return this._run(target, method, args);
-    }
-    join() {
-        joinCount++;
-        let [target, method, args] = parseArgs(...arguments);
-        return this._join(target, method, args);
-    }
-    /**
-     * @deprecated please use schedule instead.
-     */
-    defer(queueName, target, method, ...args) {
-        deferCount++;
-        return this.schedule(queueName, target, method, ...args);
-    }
-    schedule(queueName, ..._args) {
-        scheduleCount++;
-        let [target, method, args] = parseArgs(..._args);
-        let stack = this.DEBUG ? new Error() : undefined;
-        return this._ensureInstance().schedule(queueName, target, method, args, false, stack);
-    }
-    /*
-      Defer the passed iterable of functions to run inside the specified queue.
-  
-      @method scheduleIterable
-      @param {String} queueName
-      @param {Iterable} an iterable of functions to execute
-      @return method result
-    */
-    scheduleIterable(queueName, iterable) {
-        scheduleIterableCount++;
-        let stack = this.DEBUG ? new Error() : undefined;
-        return this._ensureInstance().schedule(queueName, null, iteratorDrain, [iterable], false, stack);
-    }
-    /**
-     * @deprecated please use scheduleOnce instead.
-     */
-    deferOnce(queueName, target, method, ...args) {
-        deferOnceCount++;
-        return this.scheduleOnce(queueName, target, method, ...args);
-    }
-    scheduleOnce(queueName, ..._args) {
-        scheduleOnceCount++;
-        let [target, method, args] = parseArgs(..._args);
-        let stack = this.DEBUG ? new Error() : undefined;
-        return this._ensureInstance().schedule(queueName, target, method, args, true, stack);
-    }
-    setTimeout() {
-        setTimeoutCount++;
-        return this.later(...arguments);
-    }
-    later() {
-        laterCount++;
-        let [target, method, args, wait] = parseTimerArgs(...arguments);
-        return this._later(target, method, args, wait);
-    }
-    throttle() {
-        throttleCount++;
-        let [target, method, args, wait, isImmediate = true] = parseDebounceArgs(...arguments);
-        let index = findTimerItem(target, method, this._timers);
-        let timerId;
-        if (index === -1) {
-            timerId = this._later(target, method, isImmediate ? DISABLE_SCHEDULE : args, wait);
-            if (isImmediate) {
-                this._join(target, method, args);
-            }
-        }
-        else {
-            timerId = this._timers[index + 1];
-            let argIndex = index + 4;
-            if (this._timers[argIndex] !== DISABLE_SCHEDULE) {
-                this._timers[argIndex] = args;
-            }
-        }
-        return timerId;
-    }
-    debounce() {
-        debounceCount++;
-        let [target, method, args, wait, isImmediate = false] = parseDebounceArgs(...arguments);
-        let index = findTimerItem(target, method, this._timers);
-        let timerId;
-        if (index === -1) {
-            timerId = this._later(target, method, isImmediate ? DISABLE_SCHEDULE : args, wait);
-            if (isImmediate) {
-                this._join(target, method, args);
-            }
-        }
-        else {
-            let executeAt = this._platform.now() + wait || this._timers[index];
-            this._timers[index] = executeAt;
-            let argIndex = index + 4;
-            if (this._timers[argIndex] !== DISABLE_SCHEDULE) {
-                this._timers[argIndex] = args;
-            }
-            timerId = this._timers[index + 1];
-            if (index === 0) {
-                this._reinstallTimerTimeout();
-            }
-        }
-        return timerId;
-    }
-    cancelTimers() {
-        cancelTimersCount++;
-        this._clearTimerTimeout();
-        this._timers = [];
-        this._cancelAutorun();
-    }
-    hasTimers() {
-        return this._timers.length > 0 || this._autorun !== null;
-    }
-    cancel(timer) {
-        cancelCount++;
-        if (timer === null || timer === undefined) {
-            return false;
-        }
-        let timerType = typeof timer;
-        if (timerType === 'number') { // we're cancelling a setTimeout or throttle or debounce
-            return this._cancelLaterTimer(timer);
-        }
-        else if (timerType === 'object' && timer.queue && timer.method) { // we're cancelling a deferOnce
-            return timer.queue.cancel(timer);
-        }
-        return false;
-    }
-    ensureInstance() {
-        this._ensureInstance();
-    }
-    /**
-     * Returns debug information related to the current instance of Backburner
-     *
-     * @method getDebugInfo
-     * @returns {Object | undefined} Will return and Object containing debug information if
-     * the DEBUG flag is set to true on the current instance of Backburner, else undefined.
-     */
-    getDebugInfo() {
-        if (this.DEBUG) {
-            return {
-                counters: this.counters,
-                timers: getQueueItems(this._timers, TIMERS_OFFSET, 2),
-                instanceStack: [this.currentInstance, ...this.instanceStack]
-                    .map((deferredActionQueue) => deferredActionQueue && deferredActionQueue._getDebugInfo(this.DEBUG))
-            };
-        }
-        return undefined;
-    }
-    _end(fromAutorun) {
-        let currentInstance = this.currentInstance;
-        let nextInstance = null;
-        if (currentInstance === null) {
-            throw new Error(`end called without begin`);
-        }
-        // Prevent double-finally bug in Safari 6.0.2 and iOS 6
-        // This bug appears to be resolved in Safari 6.0.5 and iOS 7
-        let finallyAlreadyCalled = false;
-        let result;
-        try {
-            result = currentInstance.flush(fromAutorun);
-        }
-        finally {
-            if (!finallyAlreadyCalled) {
-                finallyAlreadyCalled = true;
-                if (result === 1 /* Pause */) {
-                    this._scheduleAutorun();
-                }
-                else {
-                    this.currentInstance = null;
-                    if (this.instanceStack.length > 0) {
-                        nextInstance = this.instanceStack.pop();
-                        this.currentInstance = nextInstance;
-                    }
-                    this._trigger('end', currentInstance, nextInstance);
-                    this._onEnd(currentInstance, nextInstance);
-                }
-            }
-        }
-    }
-    _join(target, method, args) {
-        if (this.currentInstance === null) {
-            return this._run(target, method, args);
-        }
-        if (target === undefined && args === undefined) {
-            return method();
-        }
-        else {
-            return method.apply(target, args);
-        }
-    }
-    _run(target, method, args) {
-        let onError = getOnError(this.options);
-        this.begin();
-        if (onError) {
-            try {
-                return method.apply(target, args);
-            }
-            catch (error) {
-                onError(error);
-            }
-            finally {
-                this.end();
-            }
-        }
-        else {
-            try {
-                return method.apply(target, args);
-            }
-            finally {
-                this.end();
-            }
-        }
-    }
-    _cancelAutorun() {
-        if (this._autorun !== null) {
-            this._platform.clearNext(this._autorun);
-            this._autorun = null;
-        }
-    }
-    _later(target, method, args, wait) {
-        let stack = this.DEBUG ? new Error() : undefined;
-        let executeAt = this._platform.now() + wait;
-        let id = UUID++;
-        if (this._timers.length === 0) {
-            this._timers.push(executeAt, id, target, method, args, stack);
-            this._installTimerTimeout();
-        }
-        else {
-            // find position to insert
-            let i = binarySearch(executeAt, this._timers);
-            this._timers.splice(i, 0, executeAt, id, target, method, args, stack);
-            // always reinstall since it could be out of sync
-            this._reinstallTimerTimeout();
-        }
-        return id;
-    }
-    _cancelLaterTimer(timer) {
-        for (let i = 1; i < this._timers.length; i += TIMERS_OFFSET) {
-            if (this._timers[i] === timer) {
-                this._timers.splice(i - 1, TIMERS_OFFSET);
-                if (i === 0) {
-                    this._reinstallTimerTimeout();
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     Trigger an event. Supports up to two arguments. Designed around
-     triggering transition events from one run loop instance to the
-     next, which requires an argument for the  instance and then
-     an argument for the next instance.
-  
-     @private
-     @method _trigger
-     @param {String} eventName
-     @param {any} arg1
-     @param {any} arg2
-     */
-    _trigger(eventName, arg1, arg2) {
-        let callbacks = this._eventCallbacks[eventName];
-        if (callbacks !== undefined) {
-            for (let i = 0; i < callbacks.length; i++) {
-                callbacks[i](arg1, arg2);
-            }
-        }
-    }
-    _runExpiredTimers() {
-        this._timerTimeoutId = null;
-        if (this._timers.length > 0) {
-            this.begin();
-            this._scheduleExpiredTimers();
-            this.end();
-        }
-    }
-    _scheduleExpiredTimers() {
-        let timers = this._timers;
-        let i = 0;
-        let l = timers.length;
-        let defaultQueue = this._defaultQueue;
-        let n = this._platform.now();
-        for (; i < l; i += TIMERS_OFFSET) {
-            let executeAt = timers[i];
-            if (executeAt > n) {
-                break;
-            }
-            let args = timers[i + 4];
-            if (args !== DISABLE_SCHEDULE) {
-                let target = timers[i + 2];
-                let method = timers[i + 3];
-                let stack = timers[i + 5];
-                this.currentInstance.schedule(defaultQueue, target, method, args, false, stack);
-            }
-        }
-        timers.splice(0, i);
-        this._installTimerTimeout();
-    }
-    _reinstallTimerTimeout() {
-        this._clearTimerTimeout();
-        this._installTimerTimeout();
-    }
-    _clearTimerTimeout() {
-        if (this._timerTimeoutId === null) {
-            return;
-        }
-        this._platform.clearTimeout(this._timerTimeoutId);
-        this._timerTimeoutId = null;
-    }
-    _installTimerTimeout() {
-        if (this._timers.length === 0) {
-            return;
-        }
-        let minExpiresAt = this._timers[0];
-        let n = this._platform.now();
-        let wait = Math.max(0, minExpiresAt - n);
-        this._timerTimeoutId = this._platform.setTimeout(this._boundRunExpiredTimers, wait);
-    }
-    _ensureInstance() {
-        let currentInstance = this.currentInstance;
-        if (currentInstance === null) {
-            currentInstance = this.begin();
-            this._scheduleAutorun();
-        }
-        return currentInstance;
-    }
-    _scheduleAutorun() {
-        autorunsCreatedCount++;
-        const next = this._platform.next;
-        this._autorun = next();
-    }
-}
-Backburner.Queue = Queue;
-
-export default Backburner;
-export { buildPlatform };
-//# sourceMappingURL=backburner.js.map