closes Kint::_wrapStart() started html tags and displays callee information

@param array $callee caller information taken from debug backtrace
@param array $prevCaller previous caller information taken from debug backtrace

@return string
354245
public static function _wrapEnd( $callee, $prevCaller )
	{
		if ( !Kint::$displayCalledFrom ) {
			return '</div>';
		}

		$callingFunction = '';
		if ( isset( $prevCaller['class'] ) ) {
			$callingFunction = $prevCaller['class'];
		}
		if ( isset( $prevCaller['type'] ) ) {
			$callingFunction .= $prevCaller['type'];
		}
		if ( isset( $prevCaller['function'] ) && !in_array( $prevCaller['function'], Kint::$_statements ) ) {
			$callingFunction .= $prevCaller['function'] . '()';
		}
		$callingFunction and $callingFunction = " in ({$callingFunction})";


		$calleeInfo = isset( $callee['file'] )
			? 'Called from ' . self::shortenPath( $callee['file'], $callee['line'] )
			: '';


		return $calleeInfo || $callingFunction
			? "<footer>{$calleeInfo}{$callingFunction}</footer></div>"
			: "</div>";
	}
87378
protected function resolveBefore($before)
    {
        $getBefore = $this->resolveMiddleware($before);

        return function (Request $request, Application $app) use ($getBefore) {
            $callback = $getBefore($request);
            if (!is_callable($callback)) {
                return null;
            }

            return $callback($request, $app);
        };
    }
942734
public function setCallbackWrapper(?callable $callbackWrapper): callable
    {
        $previousWrapper = $this->callbackWrapper;
        $this->callbackWrapper = $callbackWrapper ?? function (callable $callback, ItemInterface $item, bool &$save, CacheInterface $pool, \Closure $setMetadata, ?LoggerInterface $logger) {
            return $callback($item, $save);
        };

        return $previousWrapper;
    }
514455
public function onStart($text)
    {
        // process of smileys and other special characters
        if ($this->getParam('convertSmileys'))
            $text = Smiley::convertSmileys($text);
        if ($this->getParam('convertSymbols'))
            $text = Smiley::convertSymbols($text);

        // if a specific pre-parse function was defined, it is called
        /** @var callable $func */
        $func = $this->getParam('preParseFunction');
        if (isset($func))
            $text = $func($text);
        return ($text);
    }
1373814
protected function splatToCallUserFuncArray($callee, $variables)
    {
        $totalVars = count($variables);
        $splatVar = $variables[$totalVars - 1];
        $mergeVars = [];
        for ($i = 0; $i < $totalVars - 1; $i++) {
            $mergeVars[] = $variables[$i];
        }

        return new Expr\FuncCall(
            new Name('call_user_func_array'),
            [
                $callee,
                new Expr\FuncCall(
                    new Name('array_merge'),
                    [new Expr\Array_($mergeVars), $splatVar]
                )
            ]
        );
    }
1191807
function getPrevious(): \Closure {
    return function($value, \Mustache_LambdaHelper $helper) {
      return UrlHelper::previous($helper->render($value) ?: null);
    };
  }
74218
protected function getLeadingLinePointer(File $phpcsFile, $fromStackPtr, $toStackPtr)
    {
        $tokens         = $phpcsFile->getTokens();
        $fromToken      = $tokens[$fromStackPtr];
        $prevCommentPtr = $phpcsFile->findPrevious(
            T_COMMENT,
            ($fromStackPtr - 1),
            $toStackPtr
        );

        if ($prevCommentPtr === false) {
            return $fromStackPtr;
        }

        $prevCommentToken = $tokens[$prevCommentPtr];

        if ($prevCommentToken['line'] === ($fromToken['line'] - 1)
            && $prevCommentToken['column'] === $fromToken['column']
        ) {
            return $prevCommentPtr;
        }

        return $fromStackPtr;
    }
1182048
protected function newlineBefore(Node $node, $close = FALSE) {
    $prev = $node->previousToken();
    if ($prev instanceof WhitespaceNode) {
      $prev_ws = $prev->previousToken();
      if ($prev_ws instanceof CommentNode && $prev_ws->isLineComment() && $prev->getNewlineCount() === 0) {
        $prev->setText($this->getIndent($close));
      }
      else {
        $prev->setText($this->getNewlineIndent($prev, $close));
      }
    }
    else {
      if ($prev instanceof CommentNode && $prev->isLineComment()) {
        if ($this->indentLevel > 0) {
          $node->before(Token::whitespace($this->getIndent($close)));
        }
      }
      else {
        $node->before(Token::whitespace($this->getNewlineIndent(NULL, $close)));
      }
    }
  }
86774
public function setHeader($aHeader = null)
    {
        if (is_null($aHeader) && $this->getMethod() == "POST") {
            $sHost = $this->getHost();

            $aHeader = array();
            $aHeader[] = 'POST /cgi-bin/webscr HTTP/1.1';
            $aHeader[] = 'Content-Type: multipart/form-data';
            if (isset($sHost)) {
                $aHeader[] = 'Host: ' . $sHost;
            }
            $aHeader[] = 'Connection: close';
        }
        $this->_aHeader = $aHeader;
    }
628771
private function checkLinesBeforeFirstContent($openPointer, $startPointer)
    {
        $tokens = $this->tokens;

        $lines = \substr($tokens[$openPointer]['content'], 0, \strlen('/**'));
        $lines .= TokenHelper::getContent($this->phpcsFile, $openPointer + 1, $startPointer - 1);
        $linesCount = $this->countLines($lines);

        if ($linesCount === 0) {
            return;
        }

        $this->phpcsFile->addError(
            \sprintf('No lines allowed before first content, found %d.', $linesCount),
            $startPointer,
            'LineBeforeFirstContent'
        );
    }
421088
public function onBefore(BeforeEvent $event)
    {
        $request = $event->getRequest();
        $options = $request->getConfig();

        $videoManagerId = isset($options['videoManagerId']) ? $options['videoManagerId'] : null;
        $token = $this->tokenManager->getToken($videoManagerId);

        if (null !== $token) {
            $request->setHeader('Authorization', sprintf(self::AUTH_BEARER, $token));
        }
    }
1094598
public static <T> AsyncCallback<T> before (AsyncCallback<T> target,
                                               final Function<T, Void> preOp)
    {
        return new ChainedCallback<T, T>(target) {
            @Override public void onSuccess (T result) {
                preOp.apply(result);
                forwardSuccess(result);
            }
        };
    }
156033
public function onBefore($event, callable $listener)
    {
        $this->checkEvent($event);

        if (!isset($this->beforeListeners[$event])) {
            $this->beforeListeners[$event] = [];
        }
        $this->beforeListeners[$event][] = $listener;

        return $this;
    }
1247483
protected function BeforeGather()
    {  
        if ($this->IsTriggered() && $this->Elements()->Check(Request::MethodArray($this->Method())))
        {
            return $this->OnSuccess();
        }
        return parent::BeforeGather();
    }
465725
private function before(callable $before): void
    {
        if ($before instanceof Closure) {
            $this->options["before"] = $before->bindTo($this);
        } else {
            $this->options["before"] = $before;
        }
    }
590856
public function setStartCallable(callable $startCallable): self
    {
        assert($this->checkProcedureStartOrEndCallableSignature($startCallable));

        $this->startCallable = $startCallable;

        return $this;
    }
705372
protected function run(MonadInterface $prevResult, callable $next = null)
    {
        try {
            $result = call_user_func($this->codeBlock, $prevResult);
            return ($result instanceof MonadInterface) ? $result : Success::unit($result);
        } catch (Exception $error) {
            return Error::unit($error);
        }
    }