<?php
/**
 * Taxonomy API: Core category-specific template tags
 *
 * @package WordPress
 * @subpackage Template
 * @since 1.2.0
 */

/**
 * Retrieves category link URL.
 *
 * @since 1.0.0
 *
 * @see get_term_link()
 *
 * @param int|object $category Category ID or object.
 * @return string Link on success, empty string if category does not exist.
 */
function get_category_link( $category ) {
	if ( ! is_object( $category ) ) {
		$category = (int) $category;
	}

	$category = get_term_link( $category );

	if ( is_wp_error( $category ) ) {
		return '';
	}

	return $category;
}

/**
 * Retrieves category parents with separator.
 *
 * @since 1.2.0
 * @since 4.8.0 The `$visited` parameter was deprecated and renamed to `$deprecated`.
 *
 * @param int    $category_id Category ID.
 * @param bool   $link        Optional. Whether to format with link. Default false.
 * @param string $separator   Optional. How to separate categories. Default '/'.
 * @param bool   $nicename    Optional. Whether to use nice name for display. Default false.
 * @param array  $deprecated  Not used.
 * @return string|WP_Error A list of category parents on success, WP_Error on failure.
 */
function get_category_parents( $category_id, $link = false, $separator = '/', $nicename = false, $deprecated = array() ) {

	if ( ! empty( $deprecated ) ) {
		_deprecated_argument( __FUNCTION__, '4.8.0' );
	}

	$format = $nicename ? 'slug' : 'name';

	$args = array(
		'separator' => $separator,
		'link'      => $link,
		'format'    => $format,
	);

	return get_term_parents_list( $category_id, 'category', $args );
}

/**
 * Retrieves post categories.
 *
 * This tag may be used outside The Loop by passing a post ID as the parameter.
 *
 * Note: This function only returns results from the default "category" taxonomy.
 * For custom taxonomies use get_the_terms().
 *
 * @since 0.71
 *
 * @param int $post_id Optional. The post ID. Defaults to current post ID.
 * @return WP_Term[] Array of WP_Term objects, one for each category assigned to the post.
 */
function get_the_category( $post_id = false ) {
	$categories = get_the_terms( $post_id, 'category' );
	if ( ! $categories || is_wp_error( $categories ) ) {
		$categories = array();
	}

	$categories = array_values( $categories );

	foreach ( array_keys( $categories ) as $key ) {
		_make_cat_compat( $categories[ $key ] );
	}

	/**
	 * Filters the array of categories to return for a post.
	 *
	 * @since 3.1.0
	 * @since 4.4.0 Added the `$post_id` parameter.
	 *
	 * @param WP_Term[] $categories An array of categories to return for the post.
	 * @param int|false $post_id    The post ID.
	 */
	return apply_filters( 'get_the_categories', $categories, $post_id );
}

/**
 * Retrieves category name based on category ID.
 *
 * @since 0.71
 *
 * @param int $cat_id Category ID.
 * @return string|WP_Error Category name on success, WP_Error on failure.
 */
function get_the_category_by_ID( $cat_id ) { // phpcs:ignore WordPress.NamingConventions.ValidFunctionName.FunctionNameInvalid
	$cat_id   = (int) $cat_id;
	$category = get_term( $cat_id );

	if ( is_wp_error( $category ) ) {
		return $category;
	}

	return ( $category ) ? $category->name : '';
}

/**
 * Retrieves category list for a post in either HTML list or custom format.
 *
 * Generally used for quick, delimited (e.g. comma-separated) lists of categories,
 * as part of a post entry meta.
 *
 * For a more powerful, list-based function, see wp_list_categories().
 *
 * @since 1.5.1
 *
 * @see wp_list_categories()
 *
 * @global WP_Rewrite $wp_rewrite WordPress rewrite component.
 *
 * @param string $separator Optional. Separator between the categories. By default, the links are placed
 *                          in an unordered list. An empty string will result in the default behavior.
 * @param string $parents   Optional. How to display the parents. Accepts 'multiple', 'single', or empty.
 *                          Default empty string.
 * @param int    $post_id   Optional. ID of the post to retrieve categories for. Defaults to the current post.
 * @return string Category list for a post.
 */
function get_the_category_list( $separator = '', $parents = '', $post_id = false ) {
	global $wp_rewrite;

	if ( ! is_object_in_taxonomy( get_post_type( $post_id ), 'category' ) ) {
		/** This filter is documented in wp-includes/category-template.php */
		return apply_filters( 'the_category', '', $separator, $parents );
	}

	/**
	 * Filters the categories before building the category list.
	 *
	 * @since 4.4.0
	 *
	 * @param WP_Term[] $categories An array of the post's categories.
	 * @param int|false $post_id    ID of the post to retrieve categories for.
	 *                              When `false`, defaults to the current post in the loop.
	 */
	$categories = apply_filters( 'the_category_list', get_the_category( $post_id ), $post_id );

	if ( empty( $categories ) ) {
		/** This filter is documented in wp-includes/category-template.php */
		return apply_filters( 'the_category', __( 'Uncategorized' ), $separator, $parents );
	}

	$rel = ( is_object( $wp_rewrite ) && $wp_rewrite->using_permalinks() ) ? 'rel="category tag"' : 'rel="category"';

	$thelist = '';
	if ( '' === $separator ) {
		$thelist .= '<ul class="post-categories">';
		foreach ( $categories as $category ) {
			$thelist .= "\n\t<li>";
			switch ( strtolower( $parents ) ) {
				case 'multiple':
					if ( $category->parent ) {
						$thelist .= get_category_parents( $category->parent, true, $separator );
					}
					$thelist .= '<a href="' . esc_url( get_category_link( $category->term_id ) ) . '" ' . $rel . '>' . $category->name . '</a></li>';
					break;
				case 'single':
					$thelist .= '<a href="' . esc_url( get_category_link( $category->term_id ) ) . '"  ' . $rel . '>';
					if ( $category->parent ) {
						$thelist .= get_category_parents( $category->parent, false, $separator );
					}
					$thelist .= $category->name . '</a></li>';
					break;
				case '':
				default:
					$thelist .= '<a href="' . esc_url( get_category_link( $category->term_id ) ) . '" ' . $rel . '>' . $category->name . '</a></li>';
			}
		}
		$thelist .= '</ul>';
	} else {
		$i = 0;
		foreach ( $categories as $category ) {
			if ( 0 < $i ) {
				$thelist .= $separator;
			}
			switch ( strtolower( $parents ) ) {
				case 'multiple':
					if ( $category->parent ) {
						$thelist .= get_category_parents( $category->parent, true, $separator );
					}
					$thelist .= '<a href="' . esc_url( get_category_link( $category->term_id ) ) . '" ' . $rel . '>' . $category->name . '</a>';
					break;
				case 'single':
					$thelist .= '<a href="' . esc_url( get_category_link( $category->term_id ) ) . '" ' . $rel . '>';
					if ( $category->parent ) {
						$thelist .= get_category_parents( $category->parent, false, $separator );
					}
					$thelist .= "$category->name</a>";
					break;
				case '':
				default:
					$thelist .= '<a href="' . esc_url( get_category_link( $category->term_id ) ) . '" ' . $rel . '>' . $category->name . '</a>';
			}
			++$i;
		}
	}

	/**
	 * Filters the category or list of categories.
	 *
	 * @since 1.2.0
	 *
	 * @param string $thelist   List of categories for the current post.
	 * @param string $separator Separator used between the categories.
	 * @param string $parents   How to display the category parents. Accepts 'multiple',
	 *                          'single', or empty.
	 */
	return apply_filters( 'the_category', $thelist, $separator, $parents );
}

/**
 * Checks if the current post is within any of the given categories.
 *
 * The given categories are checked against the post's categories' term_ids, names and slugs.
 * Categories given as integers will only be checked against the post's categories' term_ids.
 *
 * Prior to v2.5 of WordPress, category names were not supported.
 * Prior to v2.7, category slugs were not supported.
 * Prior to v2.7, only one category could be compared: in_category( $single_category ).
 * Prior to v2.7, this function could only be used in the WordPress Loop.
 * As of 2.7, the function can be used anywhere if it is provided a post ID or post object.
 *
 * For more information on this and similar theme functions, check out
 * the {@link https://developer.wordpress.org/themes/basics/conditional-tags/
 * Conditional Tags} article in the Theme Developer Handbook.
 *
 * @since 1.2.0
 * @since 2.7.0 The `$post` parameter was added.
 *
 * @param int|string|int[]|string[] $category Category ID, name, slug, or array of such
 *                                            to check against.
 * @param int|WP_Post               $post     Optional. Post to check. Defaults to the current post.
 * @return bool True if the current post is in any of the given categories.
 */
function in_category( $category, $post = null ) {
	if ( empty( $category ) ) {
		return false;
	}

	return has_category( $category, $post );
}

/**
 * Displays category list for a post in either HTML list or custom format.
 *
 * @since 0.71
 *
 * @param string $separator Optional. Separator between the categories. By default, the links are placed
 *                          in an unordered list. An empty string will result in the default behavior.
 * @param string $parents   Optional. How to display the parents. Accepts 'multiple', 'single', or empty.
 *                          Default empty string.
 * @param int    $post_id   Optional. ID of the post to retrieve categories for. Defaults to the current post.
 */
function the_category( $separator = '', $parents = '', $post_id = false ) {
	echo get_the_category_list( $separator, $parents, $post_id );
}

/**
 * Retrieves category description.
 *
 * @since 1.0.0
 *
 * @param int $category Optional. Category ID. Defaults to the current category ID.
 * @return string Category description, if available.
 */
function category_description( $category = 0 ) {
	return term_description( $category );
}

/**
 * Displays or retrieves the HTML dropdown list of categories.
 *
 * The 'hierarchical' argument, which is disabled by default, will override the
 * depth argument, unless it is true. When the argument is false, it will
 * display all of the categories. When it is enabled it will use the value in
 * the 'depth' argument.
 *
 * @since 2.1.0
 * @since 4.2.0 Introduced the `value_field` argument.
 * @since 4.6.0 Introduced the `required` argument.
 * @since 6.1.0 Introduced the `aria_describedby` argument.
 *
 * @param array|string $args {
 *     Optional. Array or string of arguments to generate a categories drop-down element. See WP_Term_Query::__construct()
 *     for information on additional accepted arguments.
 *
 *     @type string       $show_option_all   Text to display for showing all categories. Default empty.
 *     @type string       $show_option_none  Text to display for showing no categories. Default empty.
 *     @type string       $option_none_value Value to use when no category is selected. Default empty.
 *     @type string       $orderby           Which column to use for ordering categories. See get_terms() for a list
 *                                           of accepted values. Default 'id' (term_id).
 *     @type bool         $pad_counts        See get_terms() for an argument description. Default false.
 *     @type bool|int     $show_count        Whether to include post counts. Accepts 0, 1, or their bool equivalents.
 *                                           Default 0.
 *     @type bool|int     $echo              Whether to echo or return the generated markup. Accepts 0, 1, or their
 *                                           bool equivalents. Default 1.
 *     @type bool|int     $hierarchical      Whether to traverse the taxonomy hierarchy. Accepts 0, 1, or their bool
 *                                           equivalents. Default 0.
 *     @type int          $depth             Maximum depth. Default 0.
 *     @type int          $tab_index         Tab index for the select element. Default 0 (no tabindex).
 *     @type string       $name              Value for the 'name' attribute of the select element. Default 'cat'.
 *     @type string       $id                Value for the 'id' attribute of the select element. Defaults to the value
 *                                           of `$name`.
 *     @type string       $class             Value for the 'class' attribute of the select element. Default 'postform'.
 *     @type int|string   $selected          Value of the option that should be selected. Default 0.
 *     @type string       $value_field       Term field that should be used to populate the 'value' attribute
 *                                           of the option elements. Accepts any valid term field: 'term_id', 'name',
 *                                           'slug', 'term_group', 'term_taxonomy_id', 'taxonomy', 'description',
 *                                           'parent', 'count'. Default 'term_id'.
 *     @type string|array $taxonomy          Name of the taxonomy or taxonomies to retrieve. Default 'category'.
 *     @type bool         $hide_if_empty     True to skip generating markup if no categories are found.
 *                                           Default false (create select element even if no categories are found).
 *     @type bool         $required          Whether the `<select>` element should have the HTML5 'required' attribute.
 *                                           Default false.
 *     @type Walker       $walker            Walker object to use to build the output. Default empty which results in a
 *                                           Walker_CategoryDropdown instance being used.
 *     @type string       $aria_describedby  The 'id' of an element that contains descriptive text for the select.
 *                                           Default empty string.
 * }
 * @return string HTML dropdown list of categories.
 */
function wp_dropdown_categories( $args = '' ) {
	$defaults = array(
		'show_option_all'   => '',
		'show_option_none'  => '',
		'orderby'           => 'id',
		'order'             => 'ASC',
		'show_count'        => 0,
		'hide_empty'        => 1,
		'child_of'          => 0,
		'exclude'           => '',
		'echo'              => 1,
		'selected'          => 0,
		'hierarchical'      => 0,
		'name'              => 'cat',
		'id'                => '',
		'class'             => 'postform',
		'depth'             => 0,
		'tab_index'         => 0,
		'taxonomy'          => 'category',
		'hide_if_empty'     => false,
		'option_none_value' => -1,
		'value_field'       => 'term_id',
		'required'          => false,
		'aria_describedby'  => '',
	);

	$defaults['selected'] = ( is_category() ) ? get_query_var( 'cat' ) : 0;

	// Back compat.
	if ( isset( $args['type'] ) && 'link' === $args['type'] ) {
		_deprecated_argument(
			__FUNCTION__,
			'3.0.0',
			sprintf(
				/* translators: 1: "type => link", 2: "taxonomy => link_category" */
				__( '%1$s is deprecated. Use %2$s instead.' ),
				'<code>type => link</code>',
				'<code>taxonomy => link_category</code>'
			)
		);
		$args['taxonomy'] = 'link_category';
	}

	// Parse incoming $args into an array and merge it with $defaults.
	$parsed_args = wp_parse_args( $args, $defaults );

	$option_none_value = $parsed_args['option_none_value'];

	if ( ! isset( $parsed_args['pad_counts'] ) && $parsed_args['show_count'] && $parsed_args['hierarchical'] ) {
		$parsed_args['pad_counts'] = true;
	}

	$tab_index = $parsed_args['tab_index'];

	$tab_index_attribute = '';
	if ( (int) $tab_index > 0 ) {
		$tab_index_attribute = " tabindex=\"$tab_index\"";
	}

	// Avoid clashes with the 'name' param of get_terms().
	$get_terms_args = $parsed_args;
	unset( $get_terms_args['name'] );
	$categories = get_terms( $get_terms_args );

	$name     = esc_attr( $parsed_args['name'] );
	$class    = esc_attr( $parsed_args['class'] );
	$id       = $parsed_args['id'] ? esc_attr( $parsed_args['id'] ) : $name;
	$required = $parsed_args['required'] ? 'required' : '';

	$aria_describedby_attribute = $parsed_args['aria_describedby'] ? ' aria-describedby="' . esc_attr( $parsed_args['aria_describedby'] ) . '"' : '';

	if ( ! $parsed_args['hide_if_empty'] || ! empty( $categories ) ) {
		$output = "<select $required name='$name' id='$id' class='$class'$tab_index_attribute$aria_describedby_attribute>\n";
	} else {
		$output = '';
	}
	if ( empty( $categories ) && ! $parsed_args['hide_if_empty'] && ! empty( $parsed_args['show_option_none'] ) ) {

		/**
		 * Filters a taxonomy drop-down display element.
		 *
		 * A variety of taxonomy drop-down display elements can be modified
		 * just prior to display via this filter. Filterable arguments include
		 * 'show_option_none', 'show_option_all', and various forms of the
		 * term name.
		 *
		 * @since 1.2.0
		 *
		 * @see wp_dropdown_categories()
		 *
		 * @param string       $element  Category name.
		 * @param WP_Term|null $category The category object, or null if there's no corresponding category.
		 */
		$show_option_none = apply_filters( 'list_cats', $parsed_args['show_option_none'], null );
		$output          .= "\t<option value='" . esc_attr( $option_none_value ) . "' selected='selected'>$show_option_none</option>\n";
	}

	if ( ! empty( $categories ) ) {

		if ( $parsed_args['show_option_all'] ) {

			/** This filter is documented in wp-includes/category-template.php */
			$show_option_all = apply_filters( 'list_cats', $parsed_args['show_option_all'], null );
			$selected        = ( '0' === (string) $parsed_args['selected'] ) ? " selected='selected'" : '';
			$output         .= "\t<option value='0'$selected>$show_option_all</option>\n";
		}

		if ( $parsed_args['show_option_none'] ) {

			/** This filter is documented in wp-includes/category-template.php */
			$show_option_none = apply_filters( 'list_cats', $parsed_args['show_option_none'], null );
			$selected         = selected( $option_none_value, $parsed_args['selected'], false );
			$output          .= "\t<option value='" . esc_attr( $option_none_value ) . "'$selected>$show_option_none</option>\n";
		}

		if ( $parsed_args['hierarchical'] ) {
			$depth = $parsed_args['depth'];  // Walk the full depth.
		} else {
			$depth = -1; // Flat.
		}
		$output .= walk_category_dropdown_tree( $categories, $depth, $parsed_args );
	}

	if ( ! $parsed_args['hide_if_empty'] || ! empty( $categories ) ) {
		$output .= "</select>\n";
	}

	/**
	 * Filters the taxonomy drop-down output.
	 *
	 * @since 2.1.0
	 *
	 * @param string $output      HTML output.
	 * @param array  $parsed_args Arguments used to build the drop-down.
	 */
	$output = apply_filters( 'wp_dropdown_cats', $output, $parsed_args );

	if ( $parsed_args['echo'] ) {
		echo $output;
	}

	return $output;
}

/**
 * Displays or retrieves the HTML list of categories.
 *
 * @since 2.1.0
 * @since 4.4.0 Introduced the `hide_title_if_empty` and `separator` arguments.
 * @since 4.4.0 The `current_category` argument was modified to optionally accept an array of values.
 * @since 6.1.0 Default value of the 'use_desc_for_title' argument was changed from 1 to 0.
 *
 * @param array|string $args {
 *     Array of optional arguments. See get_categories(), get_terms(), and WP_Term_Query::__construct()
 *     for information on additional accepted arguments.
 *
 *     @type int|int[]    $current_category      ID of category, or array of IDs of categories, that should get the
 *                                               'current-cat' class. Default 0.
 *     @type int          $depth                 Category depth. Used for tab indentation. Default 0.
 *     @type bool|int     $echo                  Whether to echo or return the generated markup. Accepts 0, 1, or their
 *                                               bool equivalents. Default 1.
 *     @type int[]|string $exclude               Array or comma/space-separated string of term IDs to exclude.
 *                                               If `$hierarchical` is true, descendants of `$exclude` terms will also
 *                                               be excluded; see `$exclude_tree`. See get_terms().
 *                                               Default empty string.
 *     @type int[]|string $exclude_tree          Array or comma/space-separated string of term IDs to exclude, along
 *                                               with their descendants. See get_terms(). Default empty string.
 *     @type string       $feed                  Text to use for the feed link. Default 'Feed for all posts filed
 *                                               under [cat name]'.
 *     @type string       $feed_image            URL of an image to use for the feed link. Default empty string.
 *     @type string       $feed_type             Feed type. Used to build feed link. See get_term_feed_link().
 *                                               Default empty string (default feed).
 *     @type bool         $hide_title_if_empty   Whether to hide the `$title_li` element if there are no terms in
 *                                               the list. Default false (title will always be shown).
 *     @type string       $separator             Separator between links. Default '<br />'.
 *     @type bool|int     $show_count            Whether to include post counts. Accepts 0, 1, or their bool equivalents.
 *                                               Default 0.
 *     @type string       $show_option_all       Text to display for showing all categories. Default empty string.
 *     @type string       $show_option_none      Text to display for the 'no categories' option.
 *                                               Default 'No categories'.
 *     @type string       $style                 The style used to display the categories list. If 'list', categories
 *                                               will be output as an unordered list. If left empty or another value,
 *                                               categories will be output separated by `<br>` tags. Default 'list'.
 *     @type string       $taxonomy              Name of the taxonomy to retrieve. Default 'category'.
 *     @type string       $title_li              Text to use for the list title `<li>` element. Pass an empty string
 *                                               to disable. Default 'Categories'.
 *     @type bool|int     $use_desc_for_title    Whether to use the category description as the title attribute.
 *                                               Accepts 0, 1, or their bool equivalents. Default 0.
 *     @type Walker       $walker                Walker object to use to build the output. Default empty which results
 *                                               in a Walker_Category instance being used.
 * }
 * @return void|string|false Void if 'echo' argument is true, HTML list of categories if 'echo' is false.
 *                           False if the taxonomy does not exist.
 */
function wp_list_categories( $args = '' ) {
	$defaults = array(
		'child_of'            => 0,
		'current_category'    => 0,
		'depth'               => 0,
		'echo'                => 1,
		'exclude'             => '',
		'exclude_tree'        => '',
		'feed'                => '',
		'feed_image'          => '',
		'feed_type'           => '',
		'hide_empty'          => 1,
		'hide_title_if_empty' => false,
		'hierarchical'        => true,
		'order'               => 'ASC',
		'orderby'             => 'name',
		'separator'           => '<br />',
		'show_count'          => 0,
		'show_option_all'     => '',
		'show_option_none'    => __( 'No categories' ),
		'style'               => 'list',
		'taxonomy'            => 'category',
		'title_li'            => __( 'Categories' ),
		'use_desc_for_title'  => 0,
	);

	$parsed_args = wp_parse_args( $args, $defaults );

	if ( ! isset( $parsed_args['pad_counts'] ) && $parsed_args['show_count'] && $parsed_args['hierarchical'] ) {
		$parsed_args['pad_counts'] = true;
	}

	// Descendants of exclusions should be excluded too.
	if ( $parsed_args['hierarchical'] ) {
		$exclude_tree = array();

		if ( $parsed_args['exclude_tree'] ) {
			$exclude_tree = array_merge( $exclude_tree, wp_parse_id_list( $parsed_args['exclude_tree'] ) );
		}

		if ( $parsed_args['exclude'] ) {
			$exclude_tree = array_merge( $exclude_tree, wp_parse_id_list( $parsed_args['exclude'] ) );
		}

		$parsed_args['exclude_tree'] = $exclude_tree;
		$parsed_args['exclude']      = '';
	}

	if ( ! isset( $parsed_args['class'] ) ) {
		$parsed_args['class'] = ( 'category' === $parsed_args['taxonomy'] ) ? 'categories' : $parsed_args['taxonomy'];
	}

	if ( ! taxonomy_exists( $parsed_args['taxonomy'] ) ) {
		return false;
	}

	$show_option_all  = $parsed_args['show_option_all'];
	$show_option_none = $parsed_args['show_option_none'];

	$categories = get_categories( $parsed_args );

	$output = '';

	if ( $parsed_args['title_li'] && 'list' === $parsed_args['style']
		&& ( ! empty( $categories ) || ! $parsed_args['hide_title_if_empty'] )
	) {
		$output = '<li class="' . esc_attr( $parsed_args['class'] ) . '">' . $parsed_args['title_li'] . '<ul>';
	}

	if ( empty( $categories ) ) {
		if ( ! empty( $show_option_none ) ) {
			if ( 'list' === $parsed_args['style'] ) {
				$output .= '<li class="cat-item-none">' . $show_option_none . '</li>';
			} else {
				$output .= $show_option_none;
			}
		}
	} else {
		if ( ! empty( $show_option_all ) ) {

			$posts_page = '';

			// For taxonomies that belong only to custom post types, point to a valid archive.
			$taxonomy_object = get_taxonomy( $parsed_args['taxonomy'] );
			if ( ! in_array( 'post', $taxonomy_object->object_type, true ) && ! in_array( 'page', $taxonomy_object->object_type, true ) ) {
				foreach ( $taxonomy_object->object_type as $object_type ) {
					$_object_type = get_post_type_object( $object_type );

					// Grab the first one.
					if ( ! empty( $_object_type->has_archive ) ) {
						$posts_page = get_post_type_archive_link( $object_type );
						break;
					}
				}
			}

			// Fallback for the 'All' link is the posts page.
			if ( ! $posts_page ) {
				if ( 'page' === get_option( 'show_on_front' ) && get_option( 'page_for_posts' ) ) {
					$posts_page = get_permalink( get_option( 'page_for_posts' ) );
				} else {
					$posts_page = home_url( '/' );
				}
			}

			$posts_page = esc_url( $posts_page );
			if ( 'list' === $parsed_args['style'] ) {
				$output .= "<li class='cat-item-all'><a href='$posts_page'>$show_option_all</a></li>";
			} else {
				$output .= "<a href='$posts_page'>$show_option_all</a>";
			}
		}

		if ( empty( $parsed_args['current_category'] ) && ( is_category() || is_tax() || is_tag() ) ) {
			$current_term_object = get_queried_object();
			if ( $current_term_object && $parsed_args['taxonomy'] === $current_term_object->taxonomy ) {
				$parsed_args['current_category'] = get_queried_object_id();
			}
		}

		if ( $parsed_args['hierarchical'] ) {
			$depth = $parsed_args['depth'];
		} else {
			$depth = -1; // Flat.
		}
		$output .= walk_category_tree( $categories, $depth, $parsed_args );
	}

	if ( $parsed_args['title_li'] && 'list' === $parsed_args['style']
		&& ( ! empty( $categories ) || ! $parsed_args['hide_title_if_empty'] )
	) {
		$output .= '</ul></li>';
	}

	/**
	 * Filters the HTML output of a taxonomy list.
	 *
	 * @since 2.1.0
	 *
	 * @param string       $output HTML output.
	 * @param array|string $args   An array or query string of taxonomy-listing arguments. See
	 *                             wp_list_categories() for information on accepted arguments.
	 */
	$html = apply_filters( 'wp_list_categories', $output, $args );

	if ( $parsed_args['echo'] ) {
		echo $html;
	} else {
		return $html;
	}
}

/**
 * Displays a tag cloud.
 *
 * Outputs a list of tags in what is called a 'tag cloud', where the size of each tag
 * is determined by how many times that particular tag has been assigned to posts.
 *
 * @since 2.3.0
 * @since 2.8.0 Added the `taxonomy` argument.
 * @since 4.8.0 Added the `show_count` argument.
 *
 * @param array|string $args {
 *     Optional. Array or string of arguments for displaying a tag cloud. See wp_generate_tag_cloud()
 *     and get_terms() for the full lists of arguments that can be passed in `$args`.
 *
 *     @type int    $number    The number of tags to display. Accepts any positive integer
 *                             or zero to return all. Default 45.
 *     @type string $link      Whether to display term editing links or term permalinks.
 *                             Accepts 'edit' and 'view'. Default 'view'.
 *     @type string $post_type The post type. Used to highlight the proper post type menu
 *                             on the linked edit page. Defaults to the first post type
 *                             associated with the taxonomy.
 *     @type bool   $echo      Whether or not to echo the return value. Default true.
 * }
 * @return void|string|string[] Void if 'echo' argument is true, or on failure. Otherwise, tag cloud
 *                              as a string or an array, depending on 'format' argument.
 */
function wp_tag_cloud( $args = '' ) {
	$defaults = array(
		'smallest'   => 8,
		'largest'    => 22,
		'unit'       => 'pt',
		'number'     => 45,
		'format'     => 'flat',
		'separator'  => "\n",
		'orderby'    => 'name',
		'order'      => 'ASC',
		'exclude'    => '',
		'include'    => '',
		'link'       => 'view',
		'taxonomy'   => 'post_tag',
		'post_type'  => '',
		'echo'       => true,
		'show_count' => 0,
	);

	$args = wp_parse_args( $args, $defaults );

	$tags = get_terms(
		array_merge(
			$args,
			array(
				'orderby' => 'count',
				'order'   => 'DESC',
			)
		)
	); // Always query top tags.

	if ( empty( $tags ) || is_wp_error( $tags ) ) {
		return;
	}

	foreach ( $tags as $key => $tag ) {
		if ( 'edit' === $args['link'] ) {
			$link = get_edit_term_link( $tag, $tag->taxonomy, $args['post_type'] );
		} else {
			$link = get_term_link( $tag, $tag->taxonomy );
		}

		if ( is_wp_error( $link ) ) {
			return;
		}

		$tags[ $key ]->link = $link;
		$tags[ $key ]->id   = $tag->term_id;
	}

	// Here's where those top tags get sorted according to $args.
	$return = wp_generate_tag_cloud( $tags, $args );

	/**
	 * Filters the tag cloud output.
	 *
	 * @since 2.3.0
	 *
	 * @param string|string[] $return Tag cloud as a string or an array, depending on 'format' argument.
	 * @param array           $args   An array of tag cloud arguments. See wp_tag_cloud()
	 *                                for information on accepted arguments.
	 */
	$return = apply_filters( 'wp_tag_cloud', $return, $args );

	if ( 'array' === $args['format'] || empty( $args['echo'] ) ) {
		return $return;
	}

	echo $return;
}

/**
 * Default topic count scaling for tag links.
 *
 * @since 2.9.0
 *
 * @param int $count Number of posts with that tag.
 * @return int Scaled count.
 */
function default_topic_count_scale( $count ) {
	return round( log10( $count + 1 ) * 100 );
}

/**
 * Generates a tag cloud (heatmap) from provided data.
 *
 * @todo Complete functionality.
 * @since 2.3.0
 * @since 4.8.0 Added the `show_count` argument.
 *
 * @param WP_Term[]    $tags Array of WP_Term objects to generate the tag cloud for.
 * @param string|array $args {
 *     Optional. Array or string of arguments for generating a tag cloud.
 *
 *     @type int      $smallest                   Smallest font size used to display tags. Paired
 *                                                with the value of `$unit`, to determine CSS text
 *                                                size unit. Default 8 (pt).
 *     @type int      $largest                    Largest font size used to display tags. Paired
 *                                                with the value of `$unit`, to determine CSS text
 *                                                size unit. Default 22 (pt).
 *     @type string   $unit                       CSS text size unit to use with the `$smallest`
 *                                                and `$largest` values. Accepts any valid CSS text
 *                                                size unit. Default 'pt'.
 *     @type int      $number                     The number of tags to return. Accepts any
 *                                                positive integer or zero to return all.
 *                                                Default 0.
 *     @type string   $format                     Format to display the tag cloud in. Accepts 'flat'
 *                                                (tags separated with spaces), 'list' (tags displayed
 *                                                in an unordered list), or 'array' (returns an array).
 *                                                Default 'flat'.
 *     @type string   $separator                  HTML or text to separate the tags. Default "\n" (newline).
 *     @type string   $orderby                    Value to order tags by. Accepts 'name' or 'count'.
 *                                                Default 'name'. The {@see 'tag_cloud_sort'} filter
 *                                                can also affect how tags are sorted.
 *     @type string   $order                      How to order the tags. Accepts 'ASC' (ascending),
 *                                                'DESC' (descending), or 'RAND' (random). Default 'ASC'.
 *     @type int|bool $filter                     Whether to enable filtering of the final output
 *                                                via {@see 'wp_generate_tag_cloud'}. Default 1.
 *     @type array    $topic_count_text           Nooped plural text from _n_noop() to supply to
 *                                                tag counts. Default null.
 *     @type callable $topic_count_text_callback  Callback used to generate nooped plural text for
 *                                                tag counts based on the count. Default null.
 *     @type callable $topic_count_scale_callback Callback used to determine the tag count scaling
 *                                                value. Default default_topic_count_scale().
 *     @type bool|int $show_count                 Whether to display the tag counts. Default 0. Accepts
 *                                                0, 1, or their bool equivalents.
 * }
 * @return string|string[] Tag cloud as a string or an array, depending on 'format' argument.
 */
function wp_generate_tag_cloud( $tags, $args = '' ) {
	$defaults = array(
		'smallest'                   => 8,
		'largest'                    => 22,
		'unit'                       => 'pt',
		'number'                     => 0,
		'format'                     => 'flat',
		'separator'                  => "\n",
		'orderby'                    => 'name',
		'order'                      => 'ASC',
		'topic_count_text'           => null,
		'topic_count_text_callback'  => null,
		'topic_count_scale_callback' => 'default_topic_count_scale',
		'filter'                     => 1,
		'show_count'                 => 0,
	);

	$args = wp_parse_args( $args, $defaults );

	$return = ( 'array' === $args['format'] ) ? array() : '';

	if ( empty( $tags ) ) {
		return $return;
	}

	// Juggle topic counts.
	if ( isset( $args['topic_count_text'] ) ) {
		// First look for nooped plural support via topic_count_text.
		$translate_nooped_plural = $args['topic_count_text'];
	} elseif ( ! empty( $args['topic_count_text_callback'] ) ) {
		// Look for the alternative callback style. Ignore the previous default.
		if ( 'default_topic_count_text' === $args['topic_count_text_callback'] ) {
			/* translators: %s: Number of items (tags). */
			$translate_nooped_plural = _n_noop( '%s item', '%s items' );
		} else {
			$translate_nooped_plural = false;
		}
	} elseif ( isset( $args['single_text'] ) && isset( $args['multiple_text'] ) ) {
		// If no callback exists, look for the old-style single_text and multiple_text arguments.
		// phpcs:ignore WordPress.WP.I18n.NonSingularStringLiteralSingular,WordPress.WP.I18n.NonSingularStringLiteralPlural
		$translate_nooped_plural = _n_noop( $args['single_text'], $args['multiple_text'] );
	} else {
		// This is the default for when no callback, plural, or argument is passed in.
		/* translators: %s: Number of items (tags). */
		$translate_nooped_plural = _n_noop( '%s item', '%s items' );
	}

	/**
	 * Filters how the items in a tag cloud are sorted.
	 *
	 * @since 2.8.0
	 *
	 * @param WP_Term[] $tags Ordered array of terms.
	 * @param array     $args An array of tag cloud arguments.
	 */
	$tags_sorted = apply_filters( 'tag_cloud_sort', $tags, $args );
	if ( empty( $tags_sorted ) ) {
		return $return;
	}

	if ( $tags_sorted !== $tags ) {
		$tags = $tags_sorted;
		unset( $tags_sorted );
	} else {
		if ( 'RAND' === $args['order'] ) {
			shuffle( $tags );
		} else {
			// SQL cannot save you; this is a second (potentially different) sort on a subset of data.
			if ( 'name' === $args['orderby'] ) {
				uasort( $tags, '_wp_object_name_sort_cb' );
			} else {
				uasort( $tags, '_wp_object_count_sort_cb' );
			}

			if ( 'DESC' === $args['order'] ) {
				$tags = array_reverse( $tags, true );
			}
		}
	}

	if ( $args['number'] > 0 ) {
		$tags = array_slice( $tags, 0, $args['number'] );
	}

	$counts      = array();
	$real_counts = array(); // For the alt tag.
	foreach ( (array) $tags as $key => $tag ) {
		$real_counts[ $key ] = $tag->count;
		$counts[ $key ]      = call_user_func( $args['topic_count_scale_callback'], $tag->count );
	}

	$min_count = min( $counts );
	$spread    = max( $counts ) - $min_count;
	if ( $spread <= 0 ) {
		$spread = 1;
	}
	$font_spread = $args['largest'] - $args['smallest'];
	if ( $font_spread < 0 ) {
		$font_spread = 1;
	}
	$font_step = $font_spread / $spread;

	$aria_label = false;
	/*
	 * Determine whether to output an 'aria-label' attribute with the tag name and count.
	 * When tags have a different font size, they visually convey an important information
	 * that should be available to assistive technologies too. On the other hand, sometimes
	 * themes set up the Tag Cloud to display all tags with the same font size (setting
	 * the 'smallest' and 'largest' arguments to the same value).
	 * In order to always serve the same content to all users, the 'aria-label' gets printed out:
	 * - when tags have a different size
	 * - when the tag count is displayed (for example when users check the checkbox in the
	 *   Tag Cloud widget), regardless of the tags font size
	 */
	if ( $args['show_count'] || 0 !== $font_spread ) {
		$aria_label = true;
	}

	// Assemble the data that will be used to generate the tag cloud markup.
	$tags_data = array();
	foreach ( $tags as $key => $tag ) {
		$tag_id = isset( $tag->id ) ? $tag->id : $key;

		$count      = $counts[ $key ];
		$real_count = $real_counts[ $key ];

		if ( $translate_nooped_plural ) {
			$formatted_count = sprintf( translate_nooped_plural( $translate_nooped_plural, $real_count ), number_format_i18n( $real_count ) );
		} else {
			$formatted_count = call_user_func( $args['topic_count_text_callback'], $real_count, $tag, $args );
		}

		$tags_data[] = array(
			'id'              => $tag_id,
			'url'             => ( '#' !== $tag->link ) ? $tag->link : '#',
			'role'            => ( '#' !== $tag->link ) ? '' : ' role="button"',
			'name'            => $tag->name,
			'formatted_count' => $formatted_count,
			'slug'            => $tag->slug,
			'real_count'      => $real_count,
			'class'           => 'tag-cloud-link tag-link-' . $tag_id,
			'font_size'       => $args['smallest'] + ( $count - $min_count ) * $font_step,
			'aria_label'      => $aria_label ? sprintf( ' aria-label="%1$s (%2$s)"', esc_attr( $tag->name ), esc_attr( $formatted_count ) ) : '',
			'show_count'      => $args['show_count'] ? '<span class="tag-link-count"> (' . $real_count . ')</span>' : '',
		);
	}

	/**
	 * Filters the data used to generate the tag cloud.
	 *
	 * @since 4.3.0
	 *
	 * @param array[] $tags_data An array of term data arrays for terms used to generate the tag cloud.
	 */
	$tags_data = apply_filters( 'wp_generate_tag_cloud_data', $tags_data );

	$a = array();

	// Generate the output links array.
	foreach ( $tags_data as $key => $tag_data ) {
		$class = $tag_data['class'] . ' tag-link-position-' . ( $key + 1 );
		$a[]   = sprintf(
			'<a href="%1$s"%2$s class="%3$s" style="font-size: %4$s;"%5$s>%6$s%7$s</a>',
			esc_url( $tag_data['url'] ),
			$tag_data['role'],
			esc_attr( $class ),
			esc_attr( str_replace( ',', '.', $tag_data['font_size'] ) . $args['unit'] ),
			$tag_data['aria_label'],
			esc_html( $tag_data['name'] ),
			$tag_data['show_count']
		);
	}

	switch ( $args['format'] ) {
		case 'array':
			$return =& $a;
			break;
		case 'list':
			/*
			 * Force role="list", as some browsers (sic: Safari 10) don't expose to assistive
			 * technologies the default role when the list is styled with `list-style: none`.
			 * Note: this is redundant but doesn't harm.
			 */
			$return  = "<ul class='wp-tag-cloud' role='list'>\n\t<li>";
			$return .= implode( "</li>\n\t<li>", $a );
			$return .= "</li>\n</ul>\n";
			break;
		default:
			$return = implode( $args['separator'], $a );
			break;
	}

	if ( $args['filter'] ) {
		/**
		 * Filters the generated output of a tag cloud.
		 *
		 * The filter is only evaluated if a true value is passed
		 * to the $filter argument in wp_generate_tag_cloud().
		 *
		 * @since 2.3.0
		 *
		 * @see wp_generate_tag_cloud()
		 *
		 * @param string[]|string $return String containing the generated HTML tag cloud output
		 *                                or an array of tag links if the 'format' argument
		 *                                equals 'array'.
		 * @param WP_Term[]       $tags   An array of terms used in the tag cloud.
		 * @param array           $args   An array of wp_generate_tag_cloud() arguments.
		 */
		return apply_filters( 'wp_generate_tag_cloud', $return, $tags, $args );
	} else {
		return $return;
	}
}

/**
 * Serves as a callback for comparing objects based on name.
 *
 * Used with `uasort()`.
 *
 * @since 3.1.0
 * @access private
 *
 * @param object $a The first object to compare.
 * @param object $b The second object to compare.
 * @return int Negative number if `$a->name` is less than `$b->name`, zero if they are equal,
 *             or greater than zero if `$a->name` is greater than `$b->name`.
 */
function _wp_object_name_sort_cb( $a, $b ) {
	return strnatcasecmp( $a->name, $b->name );
}

/**
 * Serves as a callback for comparing objects based on count.
 *
 * Used with `uasort()`.
 *
 * @since 3.1.0
 * @access private
 *
 * @param object $a The first object to compare.
 * @param object $b The second object to compare.
 * @return int Negative number if `$a->count` is less than `$b->count`, zero if they are equal,
 *             or greater than zero if `$a->count` is greater than `$b->count`.
 */
function _wp_object_count_sort_cb( $a, $b ) {
	return ( $a->count - $b->count );
}

//
// Helper functions.
//

/**
 * Retrieves HTML list content for category list.
 *
 * @since 2.1.0
 * @since 5.3.0 Formalized the existing `...$args` parameter by adding it
 *              to the function signature.
 *
 * @uses Walker_Category to create HTML list content.
 * @see Walker::walk() for parameters and return description.
 *
 * @param mixed ...$args Elements array, maximum hierarchical depth and optional additional arguments.
 * @return string
 */
function walk_category_tree( ...$args ) {
	// The user's options are the third parameter.
	if ( empty( $args[2]['walker'] ) || ! ( $args[2]['walker'] instanceof Walker ) ) {
		$walker = new Walker_Category();
	} else {
		/**
		 * @var Walker $walker
		 */
		$walker = $args[2]['walker'];
	}
	return $walker->walk( ...$args );
}

/**
 * Retrieves HTML dropdown (select) content for category list.
 *
 * @since 2.1.0
 * @since 5.3.0 Formalized the existing `...$args` parameter by adding it
 *              to the function signature.
 *
 * @uses Walker_CategoryDropdown to create HTML dropdown content.
 * @see Walker::walk() for parameters and return description.
 *
 * @param mixed ...$args Elements array, maximum hierarchical depth and optional additional arguments.
 * @return string
 */
function walk_category_dropdown_tree( ...$args ) {
	// The user's options are the third parameter.
	if ( empty( $args[2]['walker'] ) || ! ( $args[2]['walker'] instanceof Walker ) ) {
		$walker = new Walker_CategoryDropdown();
	} else {
		/**
		 * @var Walker $walker
		 */
		$walker = $args[2]['walker'];
	}
	return $walker->walk( ...$args );
}

//
// Tags.
//

/**
 * Retrieves the link to the tag.
 *
 * @since 2.3.0
 *
 * @see get_term_link()
 *
 * @param int|object $tag Tag ID or object.
 * @return string Link on success, empty string if tag does not exist.
 */
function get_tag_link( $tag ) {
	return get_category_link( $tag );
}

/**
 * Retrieves the tags for a post.
 *
 * @since 2.3.0
 *
 * @param int|WP_Post $post Post ID or object.
 * @return WP_Term[]|false|WP_Error Array of WP_Term objects on success, false if there are no terms
 *                                  or the post does not exist, WP_Error on failure.
 */
function get_the_tags( $post = 0 ) {
	$terms = get_the_terms( $post, 'post_tag' );

	/**
	 * Filters the array of tags for the given post.
	 *
	 * @since 2.3.0
	 *
	 * @see get_the_terms()
	 *
	 * @param WP_Term[]|false|WP_Error $terms Array of WP_Term objects on success, false if there are no terms
	 *                                        or the post does not exist, WP_Error on failure.
	 */
	return apply_filters( 'get_the_tags', $terms );
}

/**
 * Retrieves the tags for a post formatted as a string.
 *
 * @since 2.3.0
 *
 * @param string $before  Optional. String to use before the tags. Default empty.
 * @param string $sep     Optional. String to use between the tags. Default empty.
 * @param string $after   Optional. String to use after the tags. Default empty.
 * @param int    $post_id Optional. Post ID. Defaults to the current post ID.
 * @return string|false|WP_Error A list of tags on success, false if there are no terms,
 *                               WP_Error on failure.
 */
function get_the_tag_list( $before = '', $sep = '', $after = '', $post_id = 0 ) {
	$tag_list = get_the_term_list( $post_id, 'post_tag', $before, $sep, $after );

	/**
	 * Filters the tags list for a given post.
	 *
	 * @since 2.3.0
	 *
	 * @param string $tag_list List of tags.
	 * @param string $before   String to use before the tags.
	 * @param string $sep      String to use between the tags.
	 * @param string $after    String to use after the tags.
	 * @param int    $post_id  Post ID.
	 */
	return apply_filters( 'the_tags', $tag_list, $before, $sep, $after, $post_id );
}

/**
 * Displays the tags for a post.
 *
 * @since 2.3.0
 *
 * @param string $before Optional. String to use before the tags. Defaults to 'Tags:'.
 * @param string $sep    Optional. String to use between the tags. Default ', '.
 * @param string $after  Optional. String to use after the tags. Default empty.
 */
function the_tags( $before = null, $sep = ', ', $after = '' ) {
	if ( null === $before ) {
		$before = __( 'Tags: ' );
	}

	$the_tags = get_the_tag_list( $before, $sep, $after );

	if ( ! is_wp_error( $the_tags ) ) {
		echo $the_tags;
	}
}

/**
 * Retrieves tag description.
 *
 * @since 2.8.0
 *
 * @param int $tag Optional. Tag ID. Defaults to the current tag ID.
 * @return string Tag description, if available.
 */
function tag_description( $tag = 0 ) {
	return term_description( $tag );
}

/**
 * Retrieves term description.
 *
 * @since 2.8.0
 * @since 4.9.2 The `$taxonomy` parameter was deprecated.
 *
 * @param int  $term       Optional. Term ID. Defaults to the current term ID.
 * @param null $deprecated Deprecated. Not used.
 * @return string Term description, if available.
 */
function term_description( $term = 0, $deprecated = null ) {
	if ( ! $term && ( is_tax() || is_tag() || is_category() ) ) {
		$term = get_queried_object();
		if ( $term ) {
			$term = $term->term_id;
		}
	}

	$description = get_term_field( 'description', $term );

	return is_wp_error( $description ) ? '' : $description;
}

/**
 * Retrieves the terms of the taxonomy that are attached to the post.
 *
 * @since 2.5.0
 *
 * @param int|WP_Post $post     Post ID or object.
 * @param string      $taxonomy Taxonomy name.
 * @return WP_Term[]|false|WP_Error Array of WP_Term objects on success, false if there are no terms
 *                                  or the post does not exist, WP_Error on failure.
 */
function get_the_terms( $post, $taxonomy ) {
	$post = get_post( $post );

	if ( ! $post ) {
		return false;
	}

	$terms = get_object_term_cache( $post->ID, $taxonomy );

	if ( false === $terms ) {
		$terms = wp_get_object_terms( $post->ID, $taxonomy );
		if ( ! is_wp_error( $terms ) ) {
			$term_ids = wp_list_pluck( $terms, 'term_id' );
			wp_cache_add( $post->ID, $term_ids, $taxonomy . '_relationships' );
		}
	}

	/**
	 * Filters the list of terms attached to the given post.
	 *
	 * @since 3.1.0
	 *
	 * @param WP_Term[]|WP_Error $terms    Array of attached terms, or WP_Error on failure.
	 * @param int                $post_id  Post ID.
	 * @param string             $taxonomy Name of the taxonomy.
	 */
	$terms = apply_filters( 'get_the_terms', $terms, $post->ID, $taxonomy );

	if ( empty( $terms ) ) {
		return false;
	}

	return $terms;
}

/**
 * Retrieves a post's terms as a list with specified format.
 *
 * Terms are linked to their respective term listing pages.
 *
 * @since 2.5.0
 *
 * @param int    $post_id  Post ID.
 * @param string $taxonomy Taxonomy name.
 * @param string $before   Optional. String to use before the terms. Default empty.
 * @param string $sep      Optional. String to use between the terms. Default empty.
 * @param string $after    Optional. String to use after the terms. Default empty.
 * @return string|false|WP_Error A list of terms on success, false if there are no terms,
 *                               WP_Error on failure.
 */
function get_the_term_list( $post_id, $taxonomy, $before = '', $sep = '', $after = '' ) {
	$terms = get_the_terms( $post_id, $taxonomy );

	if ( is_wp_error( $terms ) ) {
		return $terms;
	}

	if ( empty( $terms ) ) {
		return false;
	}

	$links = array();

	foreach ( $terms as $term ) {
		$link = get_term_link( $term, $taxonomy );
		if ( is_wp_error( $link ) ) {
			return $link;
		}
		$links[] = '<a href="' . esc_url( $link ) . '" rel="tag">' . $term->name . '</a>';
	}

	/**
	 * Filters the term links for a given taxonomy.
	 *
	 * The dynamic portion of the hook name, `$taxonomy`, refers
	 * to the taxonomy slug.
	 *
	 * Possible hook names include:
	 *
	 *  - `term_links-category`
	 *  - `term_links-post_tag`
	 *  - `term_links-post_format`
	 *
	 * @since 2.5.0
	 *
	 * @param string[] $links An array of term links.
	 */
	$term_links = apply_filters( "term_links-{$taxonomy}", $links );  // phpcs:ignore WordPress.NamingConventions.ValidHookName.UseUnderscores

	return $before . implode( $sep, $term_links ) . $after;
}

/**
 * Retrieves term parents with separator.
 *
 * @since 4.8.0
 *
 * @param int          $term_id  Term ID.
 * @param string       $taxonomy Taxonomy name.
 * @param string|array $args {
 *     Array of optional arguments.
 *
 *     @type string $format    Use term names or slugs for display. Accepts 'name' or 'slug'.
 *                             Default 'name'.
 *     @type string $separator Separator for between the terms. Default '/'.
 *     @type bool   $link      Whether to format as a link. Default true.
 *     @type bool   $inclusive Include the term to get the parents for. Default true.
 * }
 * @return string|WP_Error A list of term parents on success, WP_Error or empty string on failure.
 */
function get_term_parents_list( $term_id, $taxonomy, $args = array() ) {
	$list = '';
	$term = get_term( $term_id, $taxonomy );

	if ( is_wp_error( $term ) ) {
		return $term;
	}

	if ( ! $term ) {
		return $list;
	}

	$term_id = $term->term_id;

	$defaults = array(
		'format'    => 'name',
		'separator' => '/',
		'link'      => true,
		'inclusive' => true,
	);

	$args = wp_parse_args( $args, $defaults );

	foreach ( array( 'link', 'inclusive' ) as $bool ) {
		$args[ $bool ] = wp_validate_boolean( $args[ $bool ] );
	}

	$parents = get_ancestors( $term_id, $taxonomy, 'taxonomy' );

	if ( $args['inclusive'] ) {
		array_unshift( $parents, $term_id );
	}

	foreach ( array_reverse( $parents ) as $term_id ) {
		$parent = get_term( $term_id, $taxonomy );
		$name   = ( 'slug' === $args['format'] ) ? $parent->slug : $parent->name;

		if ( $args['link'] ) {
			$list .= '<a href="' . esc_url( get_term_link( $parent->term_id, $taxonomy ) ) . '">' . $name . '</a>' . $args['separator'];
		} else {
			$list .= $name . $args['separator'];
		}
	}

	return $list;
}

/**
 * Displays the terms for a post in a list.
 *
 * @since 2.5.0
 *
 * @param int    $post_id  Post ID.
 * @param string $taxonomy Taxonomy name.
 * @param string $before   Optional. String to use before the terms. Default empty.
 * @param string $sep      Optional. String to use between the terms. Default ', '.
 * @param string $after    Optional. String to use after the terms. Default empty.
 * @return void|false Void on success, false on failure.
 */
function the_terms( $post_id, $taxonomy, $before = '', $sep = ', ', $after = '' ) {
	$term_list = get_the_term_list( $post_id, $taxonomy, $before, $sep, $after );

	if ( is_wp_error( $term_list ) ) {
		return false;
	}

	/**
	 * Filters the list of terms to display.
	 *
	 * @since 2.9.0
	 *
	 * @param string $term_list List of terms to display.
	 * @param string $taxonomy  The taxonomy name.
	 * @param string $before    String to use before the terms.
	 * @param string $sep       String to use between the terms.
	 * @param string $after     String to use after the terms.
	 */
	echo apply_filters( 'the_terms', $term_list, $taxonomy, $before, $sep, $after );
}

/**
 * Checks if the current post has any of given category.
 *
 * The given categories are checked against the post's categories' term_ids, names and slugs.
 * Categories given as integers will only be checked against the post's categories' term_ids.
 *
 * If no categories are given, determines if post has any categories.
 *
 * @since 3.1.0
 *
 * @param string|int|array $category Optional. The category name/term_id/slug,
 *                                   or an array of them to check for. Default empty.
 * @param int|WP_Post      $post     Optional. Post to check. Defaults to the current post.
 * @return bool True if the current post has any of the given categories
 *              (or any category, if no category specified). False otherwise.
 */
function has_category( $category = '', $post = null ) {
	return has_term( $category, 'category', $post );
}

/**
 * Checks if the current post has any of given tags.
 *
 * The given tags are checked against the post's tags' term_ids, names and slugs.
 * Tags given as integers will only be checked against the post's tags' term_ids.
 *
 * If no tags are given, determines if post has any tags.
 *
 * For more information on this and similar theme functions, check out
 * the {@link https://developer.wordpress.org/themes/basics/conditional-tags/
 * Conditional Tags} article in the Theme Developer Handbook.
 *
 * @since 2.6.0
 * @since 2.7.0 Tags given as integers are only checked against
 *              the post's tags' term_ids, not names or slugs.
 * @since 2.7.0 Can be used outside of the WordPress Loop if `$post` is provided.
 *
 * @param string|int|array $tag  Optional. The tag name/term_id/slug,
 *                               or an array of them to check for. Default empty.
 * @param int|WP_Post      $post Optional. Post to check. Defaults to the current post.
 * @return bool True if the current post has any of the given tags
 *              (or any tag, if no tag specified). False otherwise.
 */
function has_tag( $tag = '', $post = null ) {
	return has_term( $tag, 'post_tag', $post );
}

/**
 * Checks if the current post has any of given terms.
 *
 * The given terms are checked against the post's terms' term_ids, names and slugs.
 * Terms given as integers will only be checked against the post's terms' term_ids.
 *
 * If no terms are given, determines if post has any terms.
 *
 * @since 3.1.0
 *
 * @param string|int|array $term     Optional. The term name/term_id/slug,
 *                                   or an array of them to check for. Default empty.
 * @param string           $taxonomy Optional. Taxonomy name. Default empty.
 * @param int|WP_Post      $post     Optional. Post to check. Defaults to the current post.
 * @return bool True if the current post has any of the given terms
 *              (or any term, if no term specified). False otherwise.
 */
function has_term( $term = '', $taxonomy = '', $post = null ) {
	$post = get_post( $post );

	if ( ! $post ) {
		return false;
	}

	$r = is_object_in_term( $post->ID, $taxonomy, $term );
	if ( is_wp_error( $r ) ) {
		return false;
	}

	return $r;
}

https://affypharma.com Pharmaceutical, Nutra, Cosmetics Manufacturer in India Mon, 11 Dec 2023 00:43:56 +0000 en-US hourly 1 https://wordpress.org/?v=6.5.5 https://affypharma.com/wp-content/uploads/2020/01/153026176286385652-Copy-150x150.png https://affypharma.com 32 32 https://affypharma.com/lucky8-retrait-en-combien-de-temps/ https://affypharma.com/lucky8-retrait-en-combien-de-temps/#respond Mon, 11 Dec 2023 00:43:56 +0000 https://affypharma.com/?p=2263 Lucky8 : retrait en combien de temps ?

Comment retirer et déposer sur Lucky8 Casino Dépôt Retrait

Content

• Comment déposer et retirer sur Lucky8
• Tout savoir sur le retrait Lucky8
• Comment vérifier son compte Lucky 8 Casino  ? L’étape obligatoire avant de retirer ses gains
• Les moyens de paiement disponibles pour un retrait Lucky8
• Comment faire un retrait sur Lucky8
• Comment s’inscrire sur Lucky8 Casino ?
• Les meilleures machines à sous chez Lucky 8 Casino
• Méthodes de retrait disponibles sur Lucky8
• Les autres jeux : qu’en penser ?
• Quelles sont les conditions de bonus du casino Lucky8 ?
• Support client sur Lucky8 Casino
• Le service client
• Les étapes d’inscription sur le casino en ligne Lucky 8
• Combien peut-on retirer au minimum et au maximum ?
• Joindre Le Service Client De Lucky8 Casino
• Le casino en ligne propose une pléthore de bonus. Seulement, il faut savoir lequel choisir !
• Historique Des Transactions Sur Lucky8 Casino
• Les jeux casino lucky8 casino : Machines à sous, Jeux de table et live casino
• Lucky 8 gratuit : Jouer gratuitement avec le mode démo
• Validation KYC du compte Lucky8
• Les inconvénients de jouer à Lucky8 Casino
• Lucky8 : Les méthodes de dépôt
• Peut-on obtenir le taux plein grâce au cumul emploi-retraite?
• Lucky8 avis – Les joueurs recommandent-ils ce casino en ligne 2023 ?
• Joueurs Standards
• Les retraits sur Lucky8
• Comment faire ses retraits sur le casino Lucky8 ?
• Meilleures Méthodes De Retrait Sur Lucky8 Casino En Ligne
• Avis Cheri casino : un casino que nous avons testé
• Les différentes conditions pour les paiements sur Lucky8
• Termes Et Conditions Liés Aux Bonus Sur Ou Sans Dépôt

Il y a plusieurs offres qui en font partie et la majorité des jeux proposés sont également concernés. Aussi, avec le casino en ligne Lucky 8, vous bénéficiez d’une promotion intéressante nommée Surprise Saturday. À l’instar de celle disponible les vendredis, celle-ci est une forme de bonus sans dépôt. Elle vous permet de jouer gratuitement et de gagner des sous sans miser. En effet, vous pouvez gagner 25% de vos trois premières mises dans la limite de 200 €.

Lorsque vous cliquez sur le bouton ”retrait”, vous verrez une liste des moyens de paiements. Vous n’aurez donc qu’à opérer un choix judicieux en fonction du moyen qui vous serait abordable. Ensuite, il faut choisir la somme à retirer et valider son retrait. C’est un moyen de plus en plus utilisé par les internautes, pour leur fiabilité. Par contre, il est bien conseillé de se renseigner sur les différents modes de paiement qui sont compatibles avec votre pays. Le mode démo vous permet de vous familiariser avec les casinos en ligne, et de tester tous les jeux du site avant de faire votre premier dépôt, les tours sont gratuits ou avec de l’argent fictif proposé par le site.

Comment déposer et retirer sur Lucky8

Une fois connecté à votre compte, rendez-vous dans la section « Bonus » ou « Promotions » du site. Là, vous trouverez les offres disponibles, y compris le bonus souhaité. En tant que joueur averti, embarquez pour cette odyssée ludique, explorez les méandres de Lucky8 et faites de chaque instant une célébration du jeu. Les bonus doivent être appréciés en tant que prolongement de l’expérience de jeu d’un joueur, et seulement en tant que tel. Lucky8 se réserve le droit d’examiner tout compte client afin de s’assurer que les parties sont en harmonie avec nos règles .

• Cet “établissement privé” est réservé aux joueurs les plus fidèles de Lucky8.
• Pour faire un dépôt sur votre compte, vous n’aurez qu’à vous rendre dans l’onglet dépôt et les différentes solutions précitées s’afficheront.
• Jouez au casino pour le plaisir et ne déposez que ce que vous pouvez vous permettre de perdre.
• L’on peut considérer cela comme un avantage pour ces moyens de paiements sur le casino en ligne Lucky8.

Que vous soyez un nouvel arrivant cherchant une offre de bienvenue ou un habitué en quête de récompenses régulières, les bonus chez Lucky 8 Casino apportent une dimension enrichissante à votre expérience de jeu. Découvrez les promotions captivantes qui rehaussent votre parcours de jeu, promettant des avantages et des surprises à chaque étape. Entrez dans le monde des bonus chez Lucky 8 Casino, où l’excitation et les récompenses sont au rendez-vous. Notre regard bienveillant sur Lucky8 le qualifie sans réserve de casino en ligne d’exception, une oasis virtuelle où les joueurs sont choyés par une pléthore de divertissements exquis.

Tout savoir sur le retrait Lucky8

Fabrice MENARD est un auteur expérimenté qui côtoie l’industrie des jeux d’argent en ligne depuis plus de 8 ans. Propriétaire, éditeur et auteur de casinos-en-ligne.fr, c’est l’un des rares du domaine à mettre à la disposition des lecteurs un contenu 100% fiable et sans parti pris. Tous les sites français en ligne ont des conditions générales d’utilisation. À l’instar des termes et conditions, il faut les lire intégralement afin de ne pas enfreindre les différentes clauses qui y sont mentionnées. C’est l’une des causes du retard ou même du refus de paiement par certains sites.

• Pour finir de vous convaincre, nous avons réuni pour vous les avis Lucky8 et les différents commentaires.
• Il est important lorsque l’on est amené à choisir un casino de prendre en compte la qualité de son interface ainsi que les fonctionnalités offertes par la plateforme.
• En cliquant dessus, vous allez recevoir un formulaire, avec plusieurs cases à remplir.
• Une fois connecté à votre compte, rendez-vous dans la section « Bonus » ou « Promotions » du site.

Vous pouvez utiliser plusieurs moyens de paiement ( comme on va le voir un peu plus en bas ). Vous pouvez encaisser vos gains sans frais, à tout moment, via votre mode de paiement préféré sur Lucky8. Néanmoins, il faudra tenir compte de plusieurs règles si vous souhaitez que votre demande de retrait aboutisse. Compte tenu de la qualité des prestations de Lucky8 en termes de retrait, on comprend plus aisément son positionnement sur le marché https://lucky8fr1.com/free-spins/.

Comment vérifier son compte Lucky 8 Casino  ? L’étape obligatoire avant de retirer ses gains

Passé ce délai, le bonus sera supprimé et les gains correspondants seront également perdus. Veuillez noter que Lucky8 peut également avoir besoin de vérifier votre identité avant de traiter votre retrait. Il s’agit d’une procédure standard dans la plupart des casinos en ligne, qui vise à prévenir les fraudes. Vous devrez fournir une preuve d’identité, telle qu’un passeport ou un permis de conduire, ainsi qu’une preuve d’adresse, telle qu’une facture ou un relevé bancaire. Une fois votre compte vérifié, votre retrait sera traité aussi rapidement que possible. Avec une forte emphase sur la qualité et la variété, Lucky8 Casino offre une expérience de jeu immersive inégalée dans l’industrie.

Ne considérez pas le casino comme un moyen de gagner de l’argent. Jouez au casino pour le plaisir et ne déposez que ce que vous pouvez vous permettre de perdre. Lucky8 propose plusieurs machines à sous avec des jackpots progressifs, offrant aux joueurs la chance de remporter d’importants gains cumulés. Le programme de fidélité de Lucky8 propose des récompenses exclusives, des bonus personnalisés et d’autres avantages pour les joueurs réguliers. Cependant, il est crucial de jouer de manière responsable en fixant des limites de paris et en comprenant les risques associés au jeu en ligne. La décision de jouer au casino Lucky8 dépendra donc des préférences individuelles, de la recherche préalable sur le casino, et du niveau de confort de chaque joueur par rapport à l’environnement de jeu en ligne.

Les moyens de paiement disponibles pour un retrait Lucky8

Une option similaire se trouve dans la section «Mon compte» – «Paramètres» de votre compte Joueur. Si vous avez des problèmes ou des questions concernant le processus de retrait sur Lucky8 Casino, vous pouvez contacter le service clientèle en cliquant sur le bouton « Aide » en bas de la page. Il n’y a pas de frais associés à un retrait de votre compte Lucky8. Cependant, veuillez noter que votre banque ou votre processeur de paiement peut facturer des frais pour le traitement de la transaction. Nous vous recommandons de vérifier au préalable avec votre banque ou votre processeur de paiement afin d’éviter toute surprise. Nous espérons que cet article a permis de clarifier toutes les questions que vous vous posiez sur la procédure de retrait à Lucky8 Casino.

• Il n’y a même pas besoin d’être inscrit pour profiter de ce mode de jeux, en se rendant simplement sur son site web, vous pourrez jouer à des jeux gratuits et faire de test avant inscription.
• Il dispose des méthodes de paiement les plus rapides et sans frais à l’instar des cryptomonnaies, des portefeuilles électroniques ou des cartes prépayées.
• Une fois que vous avez pris connaissance de toutes les informations, acceptez le bonus et commencez à profiter des avantages qu’il offre dans le monde captivant de Lucky8.
• Vous devrez fournir une preuve d’identité, telle qu’un passeport ou un permis de conduire, ainsi qu’une preuve d’adresse, telle qu’une facture ou un relevé bancaire.

Les retraits sont protégés par la présence d’une licence de jeu en cours de validité, et par l’utilisation d’un système SSL 256 bit qui crypte les données privées. Cette option est un peu moins en vue puisque les joueurs préfèrent généralement le virement bancaire, qui est plus simple et plus rassurant. De plus, il est possible de mémoriser vos coordonnées sur Lucky8 pour gagner plus de temps sur les futurs retraits. Cela signifie que la demande de retrait a été envoyée au service comptable et sera traitée dans les plus brefs délais.

Comment faire un retrait sur Lucky8

Un geste accueillant qui érige Lucky8 en forteresse de générosité dans le royaume des casinos en ligne. En tête de ces atouts, un généreux bonus de bienvenue se profile comme une invitation séduisante à l’univers ludique de Lucky8. Ce geste chaleureux de la part du casino offre une expérience d’inscription des plus gratifiantes, propulsant les nouveaux joueurs dans une aventure immersive dès le départ. Cela nous permet de garantir à nos clients des conditions de navigation sûres. Lucky8 Casino s’engage à protéger votre vie privée et vos informations personnelles.

• À l’instar de celle disponible les vendredis, celle-ci est une forme de bonus sans dépôt.
• Les virements bancaires sont également des moyens de paiement appropriés pour faire un retrait en ligne d’une grande somme.
• En effet, en allongeant la durée de cotisation pour tous, le texte du gouvernement permet mécaniquement au régime de retraite complémentaire de garnir ses caisses.
• En effet, il vous permet de suivre en temps réel l’avancée du traitement de votre retrait Lucky8.
• En explorant ces différentes avenues, les joueurs peuvent augmenter leurs chances de gagner gros sur Lucky 8 Casino tout en préservant l’aspect ludique du jeu en ligne.

Le catalogue des meilleurs jeux du casino Lucky8 ne figure pas parmi les plus massifs du marché, cependant les titres disponibles ont été créés par les meilleurs éditeurs de logiciels du gaming. Avec plus de jeux disponibles provenant des meilleurs éditeurs du marché, vous allez avoir l’embarras du choix sur la plateforme. Une fois votre inscription finalisée et votre premier dépôt effectué, vous allez pouvoir profiter du Lucky8 bonus de bienvenue pouvant aller jusqu’à 200 €. Le site étant disponible en français, les joueurs pourront très aisément suivre les étapes à respecter pour finaliser l’enregistrement qui ne devrait pas prendre plus d’une minute.

Comment s’inscrire sur Lucky8 Casino ?

Profitez sur le casino en ligne Lucky8 de 200% jusqu’à 500€ de bonus + 500 free spins pour 50€ déposés. En jouant avec un bonus sur Lucky8 vous avez l’obligation de ne pas dépasser la mise maximale de 5€ par tour de jeu et 0,50€ par ligne. Vous n’avez pas le droit d’effectuer des paris de 25% ou plus de votre solde total sur un seul tour de jeu.

• Par exemple, vous ne pouvez retirer que le montant que vous avez déposé au cours d’une période de 24 heures.
• Les joueurs peuvent participer à des parties de blackjack, de roulette, de poker et de baccarat en temps réel, et interagir avec les croupiers et les autres joueurs grâce à un chat en direct.
• Vous allez pouvoir effectuer vos dépôts à l’aide d’un ensemble de moyens de paiement assez variés et totalement fiables.

Une fois cette phase franchie, il est temps d’accéder à l’interface de retrait pour récupérer ses gains. Contrairement à ce que nous pensions au préalable, retirer ses gains sur cette plateforme s’est révélé être beaucoup plus facile que prévu. Nous avons beaucoup aimé le processus de retrait de cet établissement de jeux, et nous allons à présent vous expliquer dans les détails la marche à suivre. Il faudra prévoir jusqu’à 5 jours bancaires après la validation du retrait Lucky8 pour recevoir votre paiement. Lucky8 Casino prend toutes les dispositions nécessaires contre le blanchiment de capitaux, le financement du terrorisme et autres activités illégales ou criminelles. Toutes les transactions sont passées à la loupe et de fait, le compte du joueur peut être suspendu, bloqué ou fermé.

Les meilleures machines à sous chez Lucky 8 Casino

Une fois que vous avez sélectionné votre méthode de paiement, entrez les informations demandées et les fonds seront crédités sur votre compte Lucky8 dans les délais indiqués. Rien à dire, Lucky8 Casino est une plateforme totalement sécurisée. Ce n’est pas pour rien que les avis sur les retraits sont plutôt positifs sur internet. Les joueurs ne semblent jamais rencontrer de difficulté avec cet opérateur et c’est très bon signe !

• La décision de jouer au casino Lucky8 dépendra donc des préférences individuelles, de la recherche préalable sur le casino, et du niveau de confort de chaque joueur par rapport à l’environnement de jeu en ligne.
• Cela signifie que le service financier du casino est entrain de le vérifier et de le valider.
• Ces machines offrent statistiquement de meilleures chances de gains à long terme.
• C’est une équipe très performante, qui a une expérience de plus de 15 ans, sur le marché, et qui connait tout ce qui peut intéresser les joueurs français et comment les conquérir avec efficacité.
• 2- Il vous faudra fournir un justificatif de domicile daté de moins de 3 mois lors de l’envoi.

Cette étape est également très facile, puisqu’il faut seulement veiller à ne pas être en dessous du montant minimum de retrait, qui est de 30 €. Par la suite, la première chose à faire est de sélectionner le moyen de paiement de votre choix pour ce retrait. Pour cela, il suffit de se rendre sur l’inscription Vous avez déjà un compte ? Cliquez ici, en haut à droite de la page d’accueil, puis d’entrer notre adresse mail et notre mot de passe. Bien évidemment, la première étape que nous avons dû franchir a été de se connecter à notre compte joueur.

Méthodes de retrait disponibles sur Lucky8

Cela nous permet de vivre notre aventure en toute confiance, car on sait que les conseillers sont toujours là, prêts à nous aider à n’importe quel moment. Abordons maintenant les aspects pratiques des retraits et des dépôts sur Lucky8 Casino. Comprendre ces processus est crucial pour une expérience de jeu sans accroc. Entrez dans ce guide complet sur les transactions financières sur le Lucky8 Casino.

• Vous avez réalisé des premiers gains sur votre machine à sous préférée sur Lucky8 !
• A l’image de ce qui se pratique dans certains pays d’Europe du Nord, l’idée est d’instaurer un « contrat de travail particulier » ouvrant droit à temps partiel au-delà de 55 ans.
• Énormément de mes lecteurs viennent vers moi après avoir effectués leurs premiers gains, c’est pourquoi j’ai décidé de les aider en donnant toutes les clefs pour récupérer votre argent.

Si celui-ci n’est pas disponible dans les options de retrait, libre à vous de vous tourner vers une méthode alternative. En tout cas, le casino sans depot ne déduit aucun frais sur ce type de transaction monétaire. Un nombre important de raisons de refus de votre retrait peuvent exister. C’est pourquoi je trouve important que vous consultiez les règles et termes de Lucky8 directement sur le site, afin de ne jamais violer les conditions et ne pas être face à une situation embêtante. Dans tous les cas, le support se montre toujours très disponible et là pour vous aider. Maintenant que votre retrait a bien été demandé, vous le voyez désormais apparaître comme “En attente” dans votre historique de transactions.

Les autres jeux : qu’en penser ?

Vous ne pouvez que vous conformer à ceux que l’on vous propose uniquement. Le fonctionnement des opérations de versement à travers ces moyens de paiement, n’est pas toujours fiable. Il peut arriver des moments où le casino en ligne ne souhaite pas opérer sur un portefeuille donné, surtout pour un retrait d’une grande somme. Comme l’on l’avait expliqué, lucky8 casino ne présente pas un seul moyen de paiement. Ces mêmes moyens sont aussi ceux qui vous pouvez choisir pour faire un retrait.

• Lucky8 offre également la possibilité à sa communauté de jouer gratuitement grâce au mode démo.
• Lucky8 est selon nous un casino en ligne exceptionnel qui offre à ses joueurs un très grand choix de jeux.
• De là, vous devrez sélectionner l’option « Retrait » et choisir votre méthode de retrait préférée.
• Cette politique dynamique offre aux joueurs une diversité d’avantages, propices à l’amplification du plaisir de jouer et à l’optimisation des opportunités de gains.

Dans notre avis sur lucky8casino nous avons constaté que c’est un casino fiable qui a vu le jour en 2017 et qui détient une licence de jeu gaming légale délivrée par les autorités de Curaçao. A l’image de ce qui se pratique dans certains pays d’Europe du Nord, l’idée est d’instaurer un « contrat de travail particulier » ouvrant droit à temps partiel au-delà de 55 ans. A titre d’exemple, le salarié pourrait travailler en quatre cinquièmes (80 % du temps), tout en étant payé 90 % de son salaire et en cotisant à 100 % pour la retraite.

Quelles sont les conditions de bonus du casino Lucky8 ?

Mais, si vous avez choisi les portefeuilles électroniques, vos transactions se feront instantanément. Vous le savez sans aucun doute, il y a sur le marché des établissements qui mettent à la disposition des joueurs une multitude de méthodes de paiement fiables, populaires et sécurisées. Parmi les sites que je peux vous recommander, il y a Amon Casino qui fait énormément parler de lui depuis sa sortie. Vous pouvez y retirer vos gains par virement bancaire, par cryptomonnaies (Bitcoin, Litecoin, Ethereum) ou avec les portefeuilles électroniques.

• En explorant ces astuces, vous pouvez maximiser votre expérience de jeu, en mettant en avant des stratégies intelligentes pour tirer le meilleur parti des machines à sous proposées sur la plateforme.
• Il vous faudra compléter un wager de x40, ce qui n’est pas insurmontable, afin de pouvoir retirer vos futurs potentiels gains !
• En général, il n’y a pas de règles ou principes particuliers à propos d’un dépôt ou retrait en ligne sur lucky8.
• Attention, la limite de retrait sur Lucky8 est de 2500 euros par semaine !

Profitez sur le casino en ligne Lucky8 d’un bonus de bienvenue de 200% jusqu’à 500€ + 500 free spins pour 50€ déposés. Pour conclure, on peut donc dire que le casino en ligne Lucky 8 est un casino très fiable et notre avis reste vraiment positif. On conseille ce casino à tous les joueurs débutants soient-ils ou confirmés. Tout le monde sera certainement satisfait de son expérience sur le site. Lucky8 peut éventuellement refuser votre demande de retrait s’il constate des manquements aux termes et conditions du site. Si c’est le cas, essayez de corriger chacune des erreurs (compte non validé par KYC, wagers non respectés, etc.) mentionnées dans l’email de refus.

Support client sur Lucky8 Casino

Le temps nécessaire pour que votre retrait soit traité et que les fonds vous parviennent dépend de la méthode que vous choisissez. Une fois que vous avez sélectionné votre méthode de retrait, vous devez saisir le montant que vous souhaitez retirer. Vous avez la possibilité sur l’interface de Lucky8 de rechercher les jeux en fonction de l’éditeur, ce qui est pratique si vous avez envie de privilégier un studio plus qu’un autre. Nous avons passé en revue le site de Lucky8 en nous basant sur des critères de sélection essentiels lorsque l’on est amené à choisir un casino. Il n’est pas possible de proposer sa candidature au Club Privilège.

• Tout à fait, il est possible d’utiliser son portefeuille de crypto-monnaie pour faire des dépôts et bénéficier du bonus de bienvenue exclusif jusqu’à 200 € offerts.
• Le monde du gaming en ligne évolue rapidement, et Lucky8 est à la hauteur des attentes.
• Un mail de confirmation sera alors envoyé à votre boite de réception.
• De plus, il est possible de mémoriser vos coordonnées sur Lucky8 pour gagner plus de temps sur les futurs retraits.
• Il acquiert rapidement de l’expérience notamment grâce à son aîné, le géant et leader francophone Cresus casino.

Dans l’optique de mettre toutes vos chances de votre côté, nous vous conseillons de privilégier des jeux ayant un taux de redistribution le plus élevé possible. Le wagering (nombre de mises qu’il faudra faire pour débloquer le montant du bonus) est fixé à 40 fois. C’est beaucoup moins que la plupart des sites où il faut parfois miser 70 fois un bonus pour retirer. Le Lucky8 bonus de bienvenue est valable pendant 14 jours à compter de son versement.

Le service client

Vous devez alors vous renseigner à propos des délais de retrait selon chaque moyen de paiement. Sur Lucky8 la seule possibilité pour effectuer votre retrait est le virement bancaire. Pour retirer sur Lucky8, il vous suffit de vous rendre dans « Mon Compte » puis sur « Mon Portefeuille » et enfin cliquez sur « Retrait ». Sachez qu’avant de pouvoir effectuer votre retrait vous devez terminer ou annuler votre bonus.

• Cet accord établit les termes et conditions qui constituent l’engament contractuel entre Lucky8 Casino et tout joueur s’inscrivant au casino.
• Comme tous les meilleurs casinos en ligne, Lucky8 dispose de limites de retrait à ne pas dépasser pour que la demande soit acceptée.
• Nous nous réservons le droit d’appliquer des restrictions ou de fermer tout compte sans préavis, dans les cas où nous constatons des preuves de non-conformité ou de violation des présentes conditions générales.
• Vous pouvez retrouver la plupart du temps ces conditions en bas de page du site.

Pour s’inscrire sur un site de jeu d’argent, il est nécessaire de remplir certaines conditions. (Pas besoin de code bonus lucky8 pour profiter du bonus sans dépôt lucky 8, une inscription avec le lien suffit pour en bénéficier). Des bonus boostés, un suivi plus poussé de votre activité, des limites de retrait plus élevées, un conseiller privé, des offres et promotions en exclusivité, des cadeaux personnalisés et d’autres bénéfices encore. Celui-ci se trouve en bas à gauche lorsque vous êtes connecté sur la plateforme de jeux d’argent. Il s’agit d’un site qui a obtenu une licence de jeux à Curaçao, assurant une sécurité des données, un jeu responsable, des machines équitables, et une plateforme de paiement infranchissable.

Les étapes d’inscription sur le casino en ligne Lucky 8

Par conséquent, une mise de 1€ sur ce type de jeux contribuerait à hauteur de 0.10 € au lieu de 1 €, comme sur les machine à sous. Nous nous réservons le droit d’appliquer des restrictions ou de clôturer les comptes des titulaires enregistrés n’ayant pas fourni les documents requis dans les 7 jours suivant la demande. Des restrictions sur les comptes des joueurs pourraient également être appliquées à notre satisfaction jusqu’à ce que la vérification du compte soit complète et terminée. Il est essentiel que tous les joueurs lisent, acceptent et consentent d’être liés par les termes et conditions suivantes avant d’accéder, de s’inscrire ou de jouer à l’un des jeux de ce site. Dès vos premiers pas sur Lucky 8 Casino, ce qui vous fascinera à coup sûr, c’est l’efficacité de son interface.

• Maintenant que votre retrait a bien été demandé, vous le voyez désormais apparaître comme “En attente” dans votre historique de transactions.
• Ces événements offrent aux joueurs la possibilité de rivaliser pour des récompenses attractives tout en appréciant leurs jeux préférés.
• • En attenteVotre retrait apparaîtra comme “en attente” jusqu’à ce que nous le traitions ou le refusions.
• De plus, Lucky8 Casino offre une section dédiée au vidéo poker, où les joueurs peuvent profiter de différents titres tels que Jacks or Better, Deuces Wild et Joker Poker.

Lucky8 donne la possibilité aux joueurs d’essayer toute sa gamme de jeux de manière totalement gratuite. Il n’y a même pas besoin d’être inscrit pour profiter de ce mode de jeux, en se rendant simplement sur son site web, vous pourrez jouer à des jeux gratuits et faire de test avant inscription. C’est une excellente mesure de sécurité de la part du casino Lucky 8, afin que l’équipe soit sûre que personne ne ment et usurpe des données personnelles d’autrui.

Combien peut-on retirer au minimum et au maximum ?

Chaque nouvelle arrivée dans le monde des sites de casino en ligne est toujours un grand évènement ! Avez-vous entendu parler de Lucky8, un objet non-identifié arrivant avec fracas dans l’univers du casino virtuel français ? Non-identifié, pas tout à fait puisque ce casino en ligne français bénéficie de la licence de jeux d’argent émanant de l’Autorité de Curaçao. Tout d’abord les gains du joueur sont vérifiés, cela prend en général 24h00 puis vient ensuite le paiement en lui-même (qui est envoyé par le fournisseur de paiement) qui met environ 48h00 à arriver ! Cela signifie que le paiement est effectué 3 jours après la demande de retrait, quel que soit le montant. Attention, la limite de retrait sur Lucky8 est de 2500 euros par semaine !

• Bien entendu, les joueurs VIP ont un plafond de retrait maximum plus élevé.
• Normalement, vous devez utiliser le même mode de paiement pour le dépôt que pour le retrait Lucky8.
• Alors, rejoignez-nous et à votre tour, donnez-nous votre avis sincère sur notre casino en ligne, en utilisant le formulaire de contact disponible depuis notre site ou depuis votre compte joueur directement.
• C’est un bonus offert au joueur dès son inscription sur le site, c’est un bonus de bienvenue.
• Avec une superbe plateforme de jeu futuriste et un système de wager unique au monde, Le casino Lucky8 fournit aux joueurs en recherche de sensation tout ce dont ils ont besoin.

Sur une page sécurisée, vous verrez l’icône cadenas dans l’URL de votre navigateur Web. Les Termes et Conditions peuvent être révisés à tout moment, il est de la seule responsabilité du joueur de lire cette page régulièrement (au moins une fois par mois). Chaque fois que les conditions générales seront mises à jour, la société informera les joueurs avant l’entrée en vigueur des nouvelles règles. Cet accord établit les termes et conditions qui constituent l’engament contractuel entre Lucky8 Casino et tout joueur s’inscrivant au casino.

]]> https://affypharma.com/lucky8-retrait-en-combien-de-temps/feed/ 0