调用之前进行压栈的函数
@private
@param {Array} callQueue 调用队列
@param {Object} target flash对象
@return {Null}
13422
function _callFn(callQueue, target){
        var result = null;
        
        callQueue = callQueue.reverse();
        baidu.each(callQueue, function(item){
            result = target.call(item.fnName, item.params);
            item.callBack(result);
        });
    }
725274
private synchronized void createBlinkTask() {
        blinkTask = new Callable<Void>() {
            @Override public Void call() throws Exception {
                try {
                    Platform.runLater(() -> setLedOn(!isLedOn()));
                } finally {
                    if (!Thread.currentThread().isInterrupted()) {
                        // Schedule the same Callable with the current updateInterval
                        blinkFuture = blinkService.schedule(this, LED_BLINK_INTERVAL, TimeUnit.MILLISECONDS);
                    }
                }
                return null;
            }
        };
    }
37781
function _processActionQueue()
	{	
		if( _actionQueue.length > 0 ) {
			var stateEvent = _actionQueue.shift();
			
			if(!_currentState.getTarget(stateEvent.action)) {
				_processActionQueue();
			} 
			else {
			}	FSM.action( stateEvent.action, stateEvent.data );

			return false;
		}

		FSM.log('State transition Completed! Current State :: ' + _currentState.name );
		stateChanged.dispatch(_currentState);
	}
1130972
function(){
		var copy = [];

		// Handle recursive loops
		if ( queue.running ) {
			queue.waiting = true;
			return;
		}

		// Mark queue as running, then search for 
		queue.running = true;
		munit.each( queue.modules, function( assert, index ) {
			if ( ! queue.objects.length ) {
				return false;
			}
			else if ( ! munit.render.checkDepency( assert ) ) {
				return;
			}

			// Looking for specific key in queue object
			if ( munit.isString( assert.options.queue ) ) {
				munit.each( queue.objects, function( object, i ) {
					if ( object[ assert.options.queue ] ) {
						queue.modules[ index ] = null;
						queue.objects.splice( i, 1 );
						assert.queue = object;
						assert.trigger();
						return false;
					}
				});
			}
			// Any queue will do
			else {
				queue.modules[ index ] = null;
				assert.queue = queue.objects.shift();
				assert.trigger();
			}
		});

		// Clean out modules that completed (splicing causes iteration fails)
		queue.modules.forEach(function( assert ) {
			if ( assert !== null ) {
				copy.push( assert );
			}
		});
		queue.modules = copy;

		// Run again if check method was called during loop
		queue.running = false;
		if ( queue.waiting ) {
			queue.waiting = false;
			queue.check();
		}
	}
463126
function nextTick() {
  draining = true;
  var i, oldQueue;
  var len = queue.length;
  while (len) {
    oldQueue = queue;
    queue = [];
    i = -1;
    while (++i < len) {
      oldQueue[i]();
    }
    len = queue.length;
  }
  draining = false;
}
1075020
function chainCallback(cb, next) {
    var browser = this;

    return function queueWrapped() {
        try {
            if (cb) {cb.apply(browser, arguments);}
            next();
        } catch (e) {
            next(e);
        }
    };
}
128040
function(id, msg, result) {
        var q = queues[id], sc;
        if (q && q.onEnd) {
            sc = q.context || q;
            q.onEnd.call(sc, _returnData(q, msg, result));
        }
    }
642044
function QueueEntry(url, success, error, queue) {
    var _this = this;

    // A list of callbacks that will be called. Supports multiple callbacks.
    this.callbacks = {
        success: [success],
        error: [error]
        /**
         * @type {string}
         */
    };this.url = url;
    /**
     * Passes all the arguments to LoadSuccess
     * @type {function}
     */
    this.success = function () {
        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
        }

        runCallbacks(_this.callbacks.success, function (callback) {
            callback.apply(undefined, [url].concat(args));
        });
    };
    /**
     * @type {function}
     * @param {Error} errorObject
     */
    this.error = function (errorObject) {
        runCallbacks(_this.callbacks.success, function (callback) {
            callback(url, errorObject);
        });
    };

    /**
     * Cancels loading - removes the image
     */
    this.cancel = function () {
        queue.cancel(_this);
    };

    /**
     * @type {LoadTask|null}
     */
    this.task = null;
}
878592
function(target) {
	target.adapter = exports;
	target.query = execQuery.bind(target);

	// Tedious cannot execute more than one query at a time, so we have to
	// implement a queue for queries, just in case someone tries to set
	// multiple queries in a row (like node-any-db-adapter-spec tests do).
	target._queue = [];
	target._waitingForQueryToFinish = false;
	var _execNextInQueue = function(){
		if (target._waitingForQueryToFinish) {
			return;
		}

		var query = target._queue.shift();

		if (query) {
			target._waitingForQueryToFinish = true;
			target.emit('query', query);

			query.once('close', function(){
				target._waitingForQueryToFinish = false;
				target.execNextInQueue();
			});

			target.execSql(query._request);
		}
	};
	target.execNextInQueue = function(query){
		if (query) {
			target._queue.push(query);
		}

		if (target._isConnected) {
			process.nextTick(_execNextInQueue);
		}
	};

	return target;
}
1309958
function() {
    var maxWait, swfProtocol, previousState = _flashState.sandboxed;
    if (!_isBrowserSupported()) {
      _flashState.ready = false;
      ZeroClipboard.emit({
        type: "error",
        name: "browser-unsupported"
      });
      return;
    }
    _detectSandbox();
    if (typeof _flashState.ready !== "boolean") {
      _flashState.ready = false;
    }
    if (_flashState.sandboxed !== previousState && _flashState.sandboxed === true) {
      _flashState.ready = false;
      ZeroClipboard.emit({
        type: "error",
        name: "flash-sandboxed"
      });
    } else if (!ZeroClipboard.isFlashUnusable() && _flashState.bridge === null) {
      swfProtocol = _getSwfPathProtocol();
      if (swfProtocol && swfProtocol !== _window.location.protocol) {
        ZeroClipboard.emit({
          type: "error",
          name: "flash-insecure"
        });
      } else {
        maxWait = _globalConfig.flashLoadTimeout;
        if (typeof maxWait === "number" && maxWait >= 0) {
          _flashCheckTimeout = _setTimeout(function() {
            if (typeof _flashState.deactivated !== "boolean") {
              _flashState.deactivated = true;
            }
            if (_flashState.deactivated === true) {
              ZeroClipboard.emit({
                type: "error",
                name: "flash-deactivated"
              });
            }
          }, maxWait);
        }
        _flashState.overdue = false;
        _embedSwf();
      }
    }
  }
137622
public void setTargetQueue(String queue)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "setTargetQueue", queue);

    targetQueue = queue;

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "setTargetQueue");
  }
1306287
function ( target, callback ) {
            if ( typeof Array.prototype.map === 'function' ) {
                this.map = function ( target, callback ) {
                    if ( this.is(target) ) {
                        return target.map( callback );
                    } else {
                        throw new Error('[ixBand] "map()" ' + MSG_NOT_ARRAY);
                    }
                };
            } else {
                this.map = function ( target, callback ) {
                    if ( this.is(target) ) {
                        var tArray = target,
                            aryNum = tArray.length,
                            result = [], i;
    
                        for ( i = 0; i < aryNum; ++i ) {
                            var state = callback.call( this , tArray[i], i, tArray );
                            result.push( state );
                        }
                        return result;
                    } else {
                        throw new Error('[ixBand] "map()" ' + MSG_NOT_ARRAY);
                    }
                };
            }
    
            return this.map( target, callback );
        }
1286728
function(type, callback) {
                var deferred = $q.defer();

                this.isAvailable().then(function() {
                    quickActionHandler[type] = callback;
                    window.ThreeDeeTouch.onHomeIconPressed = createQuickActionHandler(quickActionHandler);
                    deferred.resolve(true);
                },
                function(err) {
                    deferred.reject(err);
                });

                return deferred.promise;
            }
1254228
function makeCallback(entryCaller, entryStack, shadow = false) {
  /**
   * This callback should be called when an asynchronous error occurred.
   * @param {(string|Error)} messageOrError A message string or an _Error_ object at the point of actual error.
   * @returns {Error} An error with the updated stack which includes the callee.
   */
  function cb(messageOrError) {
    const caller = getCallerFromArguments(arguments)
    const { stack: errorStack } = new Error()
    const calleeStackLine = getCalleeStackLine(errorStack)
    const isError = messageOrError instanceof Error
    const message = isError ? messageOrError.message : messageOrError

    const stackHeading = getStackHeading(message)
    const entryHasCallee = caller !== null && entryCaller === caller
    const stackMessage = [
      stackHeading,
      ...(entryHasCallee || shadow ? [entryStack] : [
        calleeStackLine,
        entryStack,
      ]),
    ].join('\n')

    const stack = cleanStack(stackMessage)
    const properties = { message, stack }
    const e = isError ? messageOrError : new Error()

    return /** @type {Error} */ (Object.assign(/** @type {!Object} */ (e), properties))
  }

  return cb
}
796007
function  (fn, context, rate, warningThreshold) {

        var queue = [],
            timeout;

        function next () {

            if (queue.length === 0) {
                timeout = null;
                return;
            }

            fn.apply(context, queue.shift());

            timeout = setTimeout(next, rate);
        }

        return function () {

            if (!timeout) {
                timeout = setTimeout(next, rate);
                fn.apply(context, arguments);
                return;
            }

            queue.push(arguments);

            if (queue.length * rate > warningThreshold) {
                console.warn("[WARNING] Rate limited function call will be delayed by", ((queue.length * rate) / 1000).toFixed(3), "secs");
            }
        };
    }
557442
function(id, loaded) {
        var q = queues[id], msg, w, d, h, n, url, s,
            insertBefore;

        if (q.timer) {
            // q.timer.cancel();
            clearTimeout(q.timer);
        }

        if (q.aborted) {
            msg = "transaction " + id + " was aborted";
            _fail(id, msg);
            return;
        }

        if (loaded) {
            q.url.shift(); 
            if (q.varName) {
                q.varName.shift(); 
            }
        } else {
            // This is the first pass: make sure the url is an array
            q.url = (L.isString(q.url)) ? [q.url] : q.url;
            if (q.varName) {
                q.varName = (L.isString(q.varName)) ? [q.varName] : q.varName;
            }
        }

        w = q.win; 
        d = w.document; 
        h = d.getElementsByTagName("head")[0];

        if (q.url.length === 0) {
            _finish(id);
            return;
        } 

        url = q.url[0];

        // if the url is undefined, this is probably a trailing comma problem in IE
        if (!url) {
            q.url.shift(); 
            return _next(id);
        }


        if (q.timeout) {
            // q.timer = L.later(q.timeout, q, _timeout, id);
            q.timer = setTimeout(function() { 
                _timeout(id);
            }, q.timeout);
        }

        if (q.type === "script") {
            n = _scriptNode(url, w, q.attributes);
        } else {
            n = _linkNode(url, w, q.attributes);
        }

        // track this node's load progress
        _track(q.type, n, id, url, w, q.url.length);

        // add the node to the queue so we can return it to the user supplied callback
        q.nodes.push(n);

        // add it to the head or insert it before 'insertBefore'.  Work around IE
        // bug if there is a base tag.
        insertBefore = q.insertBefore || 
                       d.getElementsByTagName('base')[0];

        if (insertBefore) {
            s = _get(insertBefore, id);
            if (s) {
                s.parentNode.insertBefore(n, s);
            }
        } else {
            h.appendChild(n);
        }
        

        // FireFox does not support the onload event for link nodes, so there is
        // no way to make the css requests synchronous. This means that the css 
        // rules in multiple files could be applied out of order in this browser
        // if a later request returns before an earlier one.  Safari too.
        if ((ua.webkit || ua.gecko) && q.type === "css") {
            _next(id, url);
        }
    }
1041640
function(fn) {
				funcGuard(fn);
				if (completeQueue !== noop) {
					throw new Error('queue `then` already set');
				}
				if (!err) {
					completeQueue = fn;
					if (!remaining) {
						complete = true;
						completeQueue(tasks);
					}
				}
				return q;
			}