def min_window(search_str: str, target_letters: str) -> str:
    """
    Given a string to search, and another string of target char_dict,
    return the smallest substring of the search string that contains
    all target char_dict.

    >>> is_contains_unique_chars("Hello World", "lWl")
    "llo W"
    >>> is_contains_unique_chars("Hello World", "f")
    ""

    This solution uses a sliding window, alternating between shifting
    the end of the window right until all target char_dict are contained
    in the window, and shifting the start of the window right until the
    window no longer contains every target character.

    Time complexity: O(target_count + search_len) ->
        The algorithm checks a dictionary at most twice for each character
        in search_str.

    Space complexity: O(search_len) ->
        The primary contributer to additional space is the building of a
        dictionary using the search string.
    """

    target_count = len(target_letters)
    search_len = len(search_str)

    # Return if not possible due to string lengths.
    if search_len < target_count:
        return ""

    # Build dictionary with counts for each letter in target_letters
    char_dict = {}
    for ch in target_letters:
        if ch not in char_dict:
            char_dict[ch] = 1
        else:
            char_dict[ch] += 1

    # Initialize window
    window_start = 0
    window_end = 0

    exists = False
    min_window_len = search_len + 1

    # Start sliding window algorithm
    while window_end < search_len:
        # Slide window end right until all search characters are contained
        while target_count > 0 and window_end < search_len:
            cur = search_str[window_end]
            if cur in char_dict:
                char_dict[cur] -= 1
                if char_dict[cur] >= 0:
                    target_count -= 1
            window_end += 1
        temp = window_end - window_start

        # Check if window is the smallest found so far
        if target_count == 0 and temp < min_window_len:
            min_window = [window_start, window_end]
            exists = True
            min_window_len = temp

        # Slide window start right until a search character exits the window
        while target_count == 0 and window_start < window_end:
            cur = search_str[window_start]
            window_start += 1
            if cur in char_dict:
                char_dict[cur] += 1
                if char_dict[cur] > 0:
                    break
        temp = window_end - window_start + 1

        # Check if window is the smallest found so far
        if temp < min_window_len and target_count == 0:
            min_window = [window_start - 1, window_end]
            min_window_len = temp
        target_count = 1

    if exists:
        return search_str[min_window[0] : min_window[1]]
    else:
        return ""