Executes a trailing invocation if it is enabled in the options.

@param {boolean} [bFinal=true] Whether this is the final invocation.
179332
function _invoke(bFinal) {
					bFinal = bFinal !== false;
					if (bFinal) {
						cancel();
					}
					if (mOptions.trailing) {
						invoke(vContext, vArguments, null, bFinal);
					}
				}
941077
@Cmd
	public void optional(final Closure<Void> closure) {
		log.info("Executing optional block ...");
		try {
			closure.call();
		} catch (final Exception ex) {
			log.error("Exception executing optional block: " + ex.getMessage(), ex);
			errors.add(ex);
		} catch (AssertionError err) {
			log.error("Assertion failed executing optional block: " + err.getMessage(), err);
			errors.add(err);
		}
		log.info("... finished execution of optional block");
	}
287471
@Override
  public void endVisit(FunctionInvocation node) {
    if (Objects.equals(node.getFunctionElement(), NIL_CHK_ELEM)) {
      VariableElement var = TreeUtil.getVariableElement(node.getArgument(0));
      if (var != null) {
        addSafeVar(var);
      }
    }
  }
253687
@Override
  public synchronized boolean cancel(boolean mayInterruptIfRunning) {
    if (isDone())
      return false;

    boolean cancelResult = super.cancel(mayInterruptIfRunning);
    if (delegate != null)
      cancelResult = delegate.cancel(mayInterruptIfRunning);
    Throwable failure = new CancellationException();
    complete(null, failure);
    executor.handleComplete(ExecutionResult.failure(failure), execution);
    return cancelResult;
  }
873584
function isFallbackCompositionEnd(topLevelType, nativeEvent) {
  switch (topLevelType) {
    case 'topKeyUp':
      // Command keys insert or clear IME input.
      return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
    case 'topKeyDown':
      // Expect IME keyCode on each keydown. If we get any other
      // code we must have exited earlier.
      return nativeEvent.keyCode !== START_KEYCODE;
    case 'topKeyPress':
    case 'topMouseDown':
    case 'topBlur':
      // Events are not possible without cancelling IME.
      return true;
    default:
      return false;
  }
}
1259636
function _exitIntro(targetElement, force) {
    var continueExit = true;

    // calling onbeforeexit callback
    //
    // If this callback return `false`, it would halt the process
    if (this._introBeforeExitCallback != undefined) {
        continueExit = this._introBeforeExitCallback.call(self);
    }

    // skip this check if `force` parameter is `true`
    // otherwise, if `onbeforeexit` returned `false`, don't exit the intro
    if (!force && continueExit === false) return;

    //remove overlay layers from the page
    var overlayLayers = targetElement.querySelectorAll('.introjs-overlay');

    if (overlayLayers && overlayLayers.length > 0) {
        for (var i = overlayLayers.length - 1; i >= 0; i--) {
            //for fade-out animation
            var overlayLayer = overlayLayers[i];
            overlayLayer.style.opacity = 0;
            setTimeout(
                function() {
                    if (this.parentNode) {
                        this.parentNode.removeChild(this);
                    }
                }.bind(overlayLayer),
                500
            );
        }
    }

    //remove all helper layers
    var helperLayer = targetElement.querySelector('.introjs-helperLayer');
    if (helperLayer) {
        helperLayer.parentNode.removeChild(helperLayer);
    }

    var referenceLayer = targetElement.querySelector('.introjs-tooltipReferenceLayer');
    if (referenceLayer) {
        referenceLayer.parentNode.removeChild(referenceLayer);
    }

    //remove disableInteractionLayer
    var disableInteractionLayer = targetElement.querySelector('.introjs-disableInteraction');
    if (disableInteractionLayer) {
        disableInteractionLayer.parentNode.removeChild(disableInteractionLayer);
    }

    //remove intro floating element
    var floatingElement = document.querySelector('.introjsFloatingElement');
    if (floatingElement) {
        floatingElement.parentNode.removeChild(floatingElement);
    }

    _removeShowElement();

    //remove `introjs-fixParent` class from the elements
    var fixParents = document.querySelectorAll('.introjs-fixParent');
    if (fixParents && fixParents.length > 0) {
        for (var i = fixParents.length - 1; i >= 0; i--) {
            fixParents[i].className = fixParents[i].className
                .replace(/introjs-fixParent/g, '')
                .replace(/^\s+|\s+$/g, '');
        }
    }

    //clean listeners
    if (window.removeEventListener) {
        window.removeEventListener('keydown', this._onKeyDown, true);
    } else if (document.detachEvent) {
        //IE
        document.detachEvent('onkeydown', this._onKeyDown);
    }

    //check if any callback is defined
    if (this._introExitCallback != undefined) {
        this._introExitCallback.call(self);
    }

    //set the step to zero
    this._currentStep = undefined;
}
1123622
function nope(options) {
  options.enabled = false;
  options.modify = modify;
  options.set = set;
  options.use = use;

  return introduce(function diagnopes() {
    return false;
  }, options);
}
696942
private Status executeAssume(Stmt.Assume stmt, CallStack frame, EnclosingScope scope) {
		//
		checkInvariants(frame,stmt.getCondition());
		return Status.NEXT;
	}
1352515
function isLLSend (node) {
  return isMemberAccess(node,
          exactMatch(util.escapeRegExp(lowLevelCallTypes.SEND.type)),
          undefined, exactMatch(basicTypes.ADDRESS), exactMatch(lowLevelCallTypes.SEND.ident))
}
947478
function on(str, opts, cbk) {
      cbk = (_.isFunction(opts)) ? opts : cbk;
      cbk = cbk || function() {};
      opts = opts || {};
      ssn.server.on(str, function() {
        if (!ssn.server || (!ssn.authenticating && !ssn.authenticated)) {
          //console.log("Not Authenticated. Closing Session.", ssn.authenticating, ssn.authenticated);
          self.parent._send("vantage-close-downstream", "downstream", { sessionId: ssn.id });
          return;
        }
        cbk.apply(self, arguments);
      });
    }
905480
function doOnce(fn) {
    var called = false;
    return function() {
      if (called) throw new Error("Callback already called.");
      called = true;
      fn.apply(root, arguments);
    };
  }
50876
function exitConcurrent(opts) {
    var root = this.root(), i, n;

    for (i = 0, n = this.substates.length; i < n; i++) {
      exit.call(this.substates[i], opts);
    }

    callExitHandlers.call(this, opts.context);
    this.__isCurrent__ = false;
    if (this !== root) { trace.call(this, "State: [EXIT]   : " + this.path()); }

    return this;
  }
1279401
function _doOnce(fn) {
    var called = false;
    return function() {
      if (called) return;
      called = true;
      fn.apply(this, arguments);
    };
  }
1068916
function isIIFEStatement(node) {
    if (node.type === "ExpressionStatement") {
        let call = node.expression;

        if (call.type === "UnaryExpression") {
            call = call.argument;
        }
        return call.type === "CallExpression" && astUtils.isFunction(call.callee);
    }
    return false;
}
350810
public boolean register(Invocation invocation) {
        final long callId;
        boolean force = invocation.op.isUrgent() || invocation.isRetryCandidate();
        try {
            callId = force ? callIdSequence.forceNext() : callIdSequence.next();
        } catch (HazelcastOverloadException e) {
            throw new HazelcastOverloadException("Failed to start invocation due to overload: " + invocation, e);
        }
        try {
            // fails with IllegalStateException if the operation is already active
            setCallId(invocation.op, callId);
        } catch (IllegalStateException e) {
            callIdSequence.complete();
            throw e;
        }
        invocations.put(callId, invocation);
        if (!alive) {
            invocation.notifyError(new HazelcastInstanceNotActiveException());
            return false;
        }
        return true;
    }
22706
function callOnce(fn) {
  var called = false

  return calledOnceShim

  //-----------------------------------
  function calledOnceShim() {
    if (called) return
    called = true

    fn.apply(this, arguments)
  }
}
673361
function(enable, d) {
      if (!!enable) {
        isExpired = false;
        startMutation(d);
      } else {
        isExpired = true;
        stopMutation(d);
      }
      isEnabled = !!enable;
    }