get_the_generator

The timeline below displays how wordpress function get_the_generator has changed across different WordPress versions. If a version is not listed, refer to the next available version below.

WordPress Version: 6.1

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * {@see 'get_the_generator_$type'} filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . sanitize_url('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . sanitize_url('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . gmdate('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filters the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * Possible hook names include:
     *
     *  - `get_the_generator_atom`
     *  - `get_the_generator_comment`
     *  - `get_the_generator_export`
     *  - `get_the_generator_html`
     *  - `get_the_generator_rdf`
     *  - `get_the_generator_rss2`
     *  - `get_the_generator_xhtml`
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to wp_head().
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 5.8

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * {@see 'get_the_generator_$type'} filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . gmdate('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filters the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * Possible hook names include:
     *
     *  - `get_the_generator_atom`
     *  - `get_the_generator_comment`
     *  - `get_the_generator_export`
     *  - `get_the_generator_html`
     *  - `get_the_generator_rdf`
     *  - `get_the_generator_rss2`
     *  - `get_the_generator_xhtml`
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to wp_head().
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 5.3

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * {@see 'get_the_generator_$type'} filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . gmdate('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filters the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to wp_head().
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 9.5

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * {@see 'get_the_generator_$type'} filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filters the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to wp_head().
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 9.3

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * {@see 'get_the_generator_$type'} filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>https://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="https://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filters the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to wp_head().
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .20

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * {@see 'get_the_generator_$type'} filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filters the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to wp_head().
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 9.2

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * {@see 'get_the_generator_$type'} filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>https://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="https://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filters the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to wp_head().
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .10

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * {@see 'get_the_generator_$type'} filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filters the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to wp_head().
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 4.9

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * {@see 'get_the_generator_$type'} filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>https://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="https://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filters the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to wp_head().
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 8.6

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * {@see 'get_the_generator_$type'} filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filters the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to wp_head().
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 8.2

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * {@see 'get_the_generator_$type'} filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>https://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="https://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filters the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to wp_head().
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .10

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * {@see 'get_the_generator_$type'} filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filters the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to wp_head().
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 6.3

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * {@see 'get_the_generator_$type'} filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>https://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="https://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filters the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to wp_head().
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .20

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * {@see 'get_the_generator_$type'} filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filters the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to wp_head().
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 6.2

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * {@see 'get_the_generator_$type'} filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>https://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="https://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filters the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to wp_head().
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .11

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * {@see 'get_the_generator_$type'} filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filters the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to wp_head().
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 4.6

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * {@see 'get_the_generator_$type'} filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>https://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="https://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filters the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to wp_head().
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 5.4

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>https://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="https://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .30

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 5.3

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>https://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="https://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .20

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 5.2

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>https://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="https://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .14

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 4.4

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>https://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="https://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .30

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 4.3

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>https://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="https://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .20

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 4.2

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>https://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="https://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .15

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 4.4

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>https://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="https://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 3.4

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .30

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 3.3

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .20

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 3.2

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .16

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 4.3

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string|void The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 2.4

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .30

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 2.3

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .20

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 1.5

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .40

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 1.4

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .30

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 1.3

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .23

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 4.1

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, `$type`, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to {@see wp_head()}.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 0.4

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, $type, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to 'wp_head()'.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .30

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, $type, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to 'wp_head()'.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 0.3

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, $type, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to 'wp_head()'.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .23

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, $type, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to 'wp_head()'.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 3.9

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    /**
     * Filter the HTML for the retrieved generator type.
     *
     * The dynamic portion of the hook name, $type, refers to the generator type.
     *
     * @since 2.5.0
     *
     * @param string $gen  The HTML markup output to 'wp_head()'.
     * @param string $type The type of generator. Accepts 'html', 'xhtml', 'atom',
     *                     'rss2', 'rdf', 'comment', 'export'.
     */
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 8.4

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 * @uses apply_filters() Calls 'get_the_generator_$type' hook.
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .30

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 * @uses apply_filters() Calls 'get_the_generator_$type' hook.
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 8.3

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 * @uses apply_filters() Calls 'get_the_generator_$type' hook.
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .26

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 * @uses apply_filters() Calls 'get_the_generator_$type' hook.
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 7.5

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 * @uses apply_filters() Calls 'get_the_generator_$type' hook.
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .40

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 * @uses apply_filters() Calls 'get_the_generator_$type' hook.
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 7.4

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 * @uses apply_filters() Calls 'get_the_generator_$type' hook.
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .30

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 * @uses apply_filters() Calls 'get_the_generator_$type' hook.
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 7.3

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 * @uses apply_filters() Calls 'get_the_generator_$type' hook.
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: .26

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 * @uses apply_filters() Calls 'get_the_generator_$type' hook.
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . esc_attr(get_bloginfo('version')) . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="https://wordpress.org/" version="' . esc_attr(get_bloginfo_rss('version')) . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="' . esc_url_raw('https://wordpress.org/?v=' . get_bloginfo_rss('version')) . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo('version')) . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . esc_attr(get_bloginfo_rss('version')) . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}

WordPress Version: 3.7

/**
 * Creates the generator XML or Comment for RSS, ATOM, etc.
 *
 * Returns the correct generator type for the requested output format. Allows
 * for a plugin to filter generators on an individual basis using the
 * 'get_the_generator_{$type}' filter.
 *
 * @since 2.5.0
 * @uses apply_filters() Calls 'get_the_generator_$type' hook.
 *
 * @param string $type The type of generator to return - (html|xhtml|atom|rss2|rdf|comment|export).
 * @return string The HTML content for the generator.
 */
function get_the_generator($type = '')
{
    if (empty($type)) {
        $current_filter = current_filter();
        if (empty($current_filter)) {
            return;
        }
        switch ($current_filter) {
            case 'rss2_head':
            case 'commentsrss2_head':
                $type = 'rss2';
                break;
            case 'rss_head':
            case 'opml_head':
                $type = 'comment';
                break;
            case 'rdf_header':
                $type = 'rdf';
                break;
            case 'atom_head':
            case 'comments_atom_head':
            case 'app_head':
                $type = 'atom';
                break;
        }
    }
    switch ($type) {
        case 'html':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '">';
            break;
        case 'xhtml':
            $gen = '<meta name="generator" content="WordPress ' . get_bloginfo('version') . '" />';
            break;
        case 'atom':
            $gen = '<generator uri="http://wordpress.org/" version="' . get_bloginfo_rss('version') . '">WordPress</generator>';
            break;
        case 'rss2':
            $gen = '<generator>http://wordpress.org/?v=' . get_bloginfo_rss('version') . '</generator>';
            break;
        case 'rdf':
            $gen = '<admin:generatorAgent rdf:resource="http://wordpress.org/?v=' . get_bloginfo_rss('version') . '" />';
            break;
        case 'comment':
            $gen = '<!-- generator="WordPress/' . get_bloginfo('version') . '" -->';
            break;
        case 'export':
            $gen = '<!-- generator="WordPress/' . get_bloginfo_rss('version') . '" created="' . date('Y-m-d H:i') . '" -->';
            break;
    }
    return apply_filters("get_the_generator_{$type}", $gen, $type);
}