The following three functions are global once enabled!

@param array $arguments from Content.

@return String block with the parsed code.
327003
public static function TweetHandler($arguments)
    {
        if (!isset($arguments['id'])) {
            return null;
        }
        if (substr($arguments['id'], 0, 4) === 'http') {
            list($unneeded, $id) = explode('/status/', $arguments['id']);
        } else {
            $id = $arguments['id'];
        }
        $data = json_decode(file_get_contents('https://api.twitter.com/1/statuses/oembed.json?id=' . $id . '&omit_script=true&lang=en'), 1);

        return $data['html'];
    }
271548
private function _replacement($arguments)
    {
        if (empty($arguments)) {
            return '';
        }

        $i = 1;
        $j = 0;
        // loop through the patterns
        while (isset($this->_patterns[$j])) {
            $pattern = $this->_patterns[$j++];
            // do we have a result?
            if (isset($arguments[$i]) && ($arguments[$i] != '')) {
                $replacement = $pattern[self::REPLACEMENT];

                if (is_array($replacement) && isset($replacement['fn'])) {

                    if (isset($replacement['data'])) {
                        $this->buffer = $replacement['data'];
                    }
                    return call_user_func(array(&$this, $replacement['fn']), $arguments, $i);

                } elseif (is_int($replacement)) {
                    return $arguments[$replacement + $i];

                }
                $delete = ($this->escapeChar == ''
                    || strpos($arguments[$i], $this->escapeChar) === false)
                    ? '' : "\x01" . $arguments[$i] . "\x01";
                return $delete . $replacement;

                // skip over references to sub-expressions
            } else {
                $i += $pattern[self::LENGTH];
            }
        }
    }
191231
private function _parseArgs(array $args)
	{
		$arg = '';
		if(count($args) > 0)
		{
			foreach($args as $number => $argument)
			{
				if($number === 0)
				{
					$arg .= $argument;
				}
				else
				{
					$arg .= ', ' . $argument;
				}
			}
		}

		return $arg;
	}
936467
public static function constructStringFromArguments(array $arguments): string
    {
        $result = '';
        foreach ($arguments as $argument) {
            $result .= ' ' . $argument;
        }

        return $result;
    }
750730
public function raw($ability, $arguments = [])
    {
        $arguments = Arr::wrap($arguments);

        $user = $this->resolveUser();

        // First we will call the "before" callbacks for the Gate. If any of these give
        // back a non-null response, we will immediately return that result in order
        // to let the developers override all checks for some authorization cases.
        $result = $this->callBeforeCallbacks(
            $user, $ability, $arguments
        );

        if (is_null($result)) {
            $result = $this->callAuthCallback($user, $ability, $arguments);
        }

        // After calling the authorization callback, we will call the "after" callbacks
        // that are registered with the Gate, which allows a developer to do logging
        // if that is required for this application. Then we'll return the result.
        return $this->callAfterCallbacks(
            $user, $ability, $arguments, $result
        );
    }
1263166
public function arguments(array $arguments = [])
    {
        if (empty($arguments)) {
            return $this->arguments;
        }

        foreach ($arguments as $key => $value) {
            if (!isset($this->requirements[$key])) {
                $this->arguments[$key] = $value;
                continue;
            }

            $this->assertArgumentValue($key, $this->requirements[$key], $value);
            $this->arguments[$key] = $value;
        }

        return $this->arguments;
    }
200997
protected function handleFunctionCall(array $arguments)
    {
        $invocation = $this->invocations->recordCall($arguments);
        if (null !== $this->callMap && $this->callMap->hasResultFor('function', $invocation)) {
            return $this->callMap->resultFor('function', $arguments, $invocation);
        }

        if ($this->parentCallsAllowed) {
            $originalFunction = $this->invocations->name();
            return $originalFunction(...$arguments);
        }

        return null;
    }
250474
protected function generate($content, array $arguments)
    {
        foreach ($arguments as $name => $value) {
            if (is_array($value)) {
                $value = implode(', ', $value);
            }
            $content = preg_replace('/\{\s*\$'.$name.'\s*\}/', $value, $content);
        }

        return $content;
    }
766271
protected function resolveArgumentsParameters(array $arguments)
    {
        foreach ($arguments as $argument => &$value) {
            if (is_string($value) === false || preg_match('/%[\S_\-]+%/', $value, $matches) === false) {
                continue;
            }

            $name = $matches[0];

            if (array_key_exists($name, $this->parameters) === false) {
                continue;
            }

            if (is_string($this->parameters[$name])) {
                $value = str_replace($name, $this->parameters[$name], (string) $value);

                continue;
            }

            $value = $this->parameters[$name];
        }

        return $arguments;
    }
471704
private function renderArgument($argument)
    {
        if (is_array($argument)) {
            $argument = json_encode($argument);
        } elseif (null === $argument) {
            $argument = 'null';
        } elseif (is_string($argument)) {
            $argument = '"' . $argument . '"';
        }

        return $argument;
    }
544650
public function filterPrefix(array $arguments)
    {
        if (empty($arguments)) {
            throw new \InvalidArgumentException('At least one argument needed');
        }

        $path = &$arguments[0];

        if (!\is_string($path)) {
            throw new \InvalidArgumentException('First argument should be a string');
        }

        [$prefix, $path] = $this->getPrefixAndPath($path);

        return [$prefix, $arguments];
    }
818229
private function executeMethod(array $arguments)
    {
        if ($this->reflection->isStatic()) {
            return $this->reflection->invokeArgs(null, $arguments);
        } elseif (is_object($this->callback[0])) {
            return $this->reflection->invokeArgs($this->callback[0], $arguments);
        }
        $instance = new $this->callback[0]();
        return $this->reflection->invokeArgs($instance, $arguments);
    }
1005163
private static function parseCommands(array $arguments):array
    {
        $commands = [];
        foreach ($arguments as $one) {
            if (strpos($one, '--') === false) {
                $commands[] = $one;
            }
        }
        return ($commands);
    }
150812
public function setArguments($arguments)
    {
        $parameters = array_merge($this->getDefaults(), $this->arguments);

        $this->arguments = array_merge($parameters, $arguments);

        return $this;
    }
754704
public function args(array $arguments)
    {
        // provide a new instance of the scheduler class if this
        // is the first method that was called.  This allows for
        // $scheduler->opts() to return a new instance of the
        // scheduler when it's first called
        if (count($this->options) == 0) {
            $scheduler = App::make(get_called_class());
            $scheduler->setArguments($arguments);

            return $scheduler;
        }

        $this->setArguments($arguments);

        return $this;
    }
892528
public function execute(...$arguments)
    {
        $options = $this->getOptions();
        if ($options->version) {
            $this->logger->writeln($this->name() . ' - ' . static::VERSION);
            $this->logger->writeln('console core: ' . static::CORE_VERSION);

            return;
        }

        // show list and help by default
        $help = $this->getCommand('help');
        $help->setOptions($options);
        if ($help || $options->help) {
            $help->executeWrapper($arguments);

            return;
        }

        throw new CommandNotFoundException($this, 'help');
    }
344439
private function convertArgument($argument)
    {
        if (is_string($argument) && 0 < strlen($argument) && '@' === $argument[0]) {
            $argument = new Reference(substr($argument, 1));
        }

        return $argument;
    }