Spieker.psm1

<#
 .Synopsis
  Displays a visual representation of a calendar.
 
 .Description
  Displays a visual representation of a calendar. This function supports multiple months
  and lets you highlight specific date ranges or days.
 
 .Parameter Start
  The first month to display.
 
 .Parameter End
  The last month to display.
 
 .Parameter FirstDayOfWeek
  The day of the month on which the week begins.
 
 .Parameter HighlightDay
  Specific days (numbered) to highlight. Used for date ranges like (25..31).
  Date ranges are specified by the Windows PowerShell range syntax. These dates are
  enclosed in square brackets.
 
 .Parameter HighlightDate
  Specific days (named) to highlight. These dates are surrounded by asterisks.
 
 .Example
   # Show a default display of this month.
   Show-Calendar
 
 .Example
   # Display a date range.
   Show-Calendar -Start "March, 2010" -End "May, 2010"
 
 .Example
   # Highlight a range of days.
   Show-Calendar -HighlightDay (1..10 + 22) -HighlightDate "2008-12-25"
#>

function get-khaki {
    param(
        [DateTime] $start = [DateTime]::Today,
        [DateTime] $end = $start,
        $firstDayOfWeek,
        [int[]] $highlightDay,
        [string[]] $highlightDate = [DateTime]::Today.ToString('yyyy-MM-dd')
        )
    
    ## Determine the first day of the start and end months.
    $start = New-Object DateTime $start.Year,$start.Month,1
    $end = New-Object DateTime $end.Year,$end.Month,1
    
    ## Convert the highlighted dates into real dates.
    [DateTime[]] $highlightDate = [DateTime[]] $highlightDate
    
    ## Retrieve the DateTimeFormat information so that the
    ## calendar can be manipulated.
    $dateTimeFormat  = (Get-Culture).DateTimeFormat
    if($firstDayOfWeek)
    {
        $dateTimeFormat.FirstDayOfWeek = $firstDayOfWeek
    }
    
    $currentDay = $start
    
    ## Process the requested months.
    while($start -le $end)
    {
        ## Return to an earlier point in the function if the first day of the month
        ## is in the middle of the week.
        while($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek)
        {
            $currentDay = $currentDay.AddDays(-1)
        }
    
        ## Prepare to store information about this date range.
        $currentWeek = New-Object PsObject
        $dayNames = @()
        $weeks = @()
    
        ## Continue processing dates until the function reaches the end of the month.
        ## The function continues until the week is completed with
        ## days from the next month.
        while(($currentDay -lt $start.AddMonths(1)) -or
            ($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek))
        {
            ## Determine the day names to use to label the columns.
            $dayName = "{0:ddd}" -f $currentDay
            if($dayNames -notcontains $dayName)
            {
                $dayNames += $dayName
            }
    
            ## Pad the day number for display, highlighting if necessary.
            $displayDay = " {0,2} " -f $currentDay.Day
    
            ## Determine whether to highlight a specific date.
            if($highlightDate)
            {
                $compareDate = New-Object DateTime $currentDay.Year,
                    $currentDay.Month,$currentDay.Day
                if($highlightDate -contains $compareDate)
                {
                    $displayDay = "*" + ("{0,2}" -f $currentDay.Day) + "*"
                }
            }
    
            ## Otherwise, highlight as part of a date range.
            if($highlightDay -and ($highlightDay[0] -eq $currentDay.Day))
            {
                $displayDay = "[" + ("{0,2}" -f $currentDay.Day) + "]"
                $null,$highlightDay = $highlightDay
            }
    
            ## Add the day of the week and the day of the month as note properties.
            $currentWeek | Add-Member NoteProperty $dayName $displayDay
    
            ## Move to the next day of the month.
            $currentDay = $currentDay.AddDays(1)
    
            ## If the function reaches the next week, store the current week
            ## in the week list and continue.
            if($currentDay.DayOfWeek -eq $dateTimeFormat.FirstDayOfWeek)
            {
                $weeks += $currentWeek
                $currentWeek = New-Object PsObject
            }
        }
    
        ## Format the weeks as a table.
        $calendar = $weeks | Format-Table $dayNames -AutoSize | Out-String
    
        ## Add a centered header.
        $width = ($calendar.Split("`n") | Measure-Object -Maximum Length).Maximum
        $header = "{0:MMMM yyyy}" -f $start
        $padding = " " * (($width - $header.Length) / 2)
        $displayCalendar = " `n" + $padding + $header + "`n " + $calendar
        $displayCalendar.TrimEnd()
    
        ## Move to the next month.
        $start = $start.AddMonths(1)
    
    }
    }

    function Get-Berichtje {
        param (

        )

        write-host "Hallo Nikki, Hoe gaat het met je???"
        
    }

    function Get-Liefste {
        param (
            
        )

        write-host "Mo is de liefste en Daarna Nikki"
        
    }

    function get-khaki1 {
        param(
            [DateTime] $start = [DateTime]::Today,
            [DateTime] $end = $start,
            $firstDayOfWeek,
            [int[]] $highlightDay,
            [string[]] $highlightDate = [DateTime]::Today.ToString('yyyy-MM-dd')
            )
        
        ## Determine the first day of the start and end months.
        $start = New-Object DateTime $start.Year,$start.Month,1
        $end = New-Object DateTime $end.Year,$end.Month,1
        
        ## Convert the highlighted dates into real dates.
        [DateTime[]] $highlightDate = [DateTime[]] $highlightDate
        
        ## Retrieve the DateTimeFormat information so that the
        ## calendar can be manipulated.
        $dateTimeFormat  = (Get-Culture).DateTimeFormat
        if($firstDayOfWeek)
        {
            $dateTimeFormat.FirstDayOfWeek = $firstDayOfWeek
        }
        
        $currentDay = $start
        
        ## Process the requested months.
        while($start -le $end)
        {
            ## Return to an earlier point in the function if the first day of the month
            ## is in the middle of the week.
            while($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek)
            {
                $currentDay = $currentDay.AddDays(-1)
            }
        
            ## Prepare to store information about this date range.
            $currentWeek = New-Object PsObject
            $dayNames = @()
            $weeks = @()
        
            ## Continue processing dates until the function reaches the end of the month.
            ## The function continues until the week is completed with
            ## days from the next month.
            while(($currentDay -lt $start.AddMonths(1)) -or
                ($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek))
            {
                ## Determine the day names to use to label the columns.
                $dayName = "{0:ddd}" -f $currentDay
                if($dayNames -notcontains $dayName)
                {
                    $dayNames += $dayName
                }
        
                ## Pad the day number for display, highlighting if necessary.
                $displayDay = " {0,2} " -f $currentDay.Day
        
                ## Determine whether to highlight a specific date.
                if($highlightDate)
                {
                    $compareDate = New-Object DateTime $currentDay.Year,
                        $currentDay.Month,$currentDay.Day
                    if($highlightDate -contains $compareDate)
                    {
                        $displayDay = "*" + ("{0,2}" -f $currentDay.Day) + "*"
                    }
                }
        
                ## Otherwise, highlight as part of a date range.
                if($highlightDay -and ($highlightDay[0] -eq $currentDay.Day))
                {
                    $displayDay = "[" + ("{0,2}" -f $currentDay.Day) + "]"
                    $null,$highlightDay = $highlightDay
                }
        
                ## Add the day of the week and the day of the month as note properties.
                $currentWeek | Add-Member NoteProperty $dayName $displayDay
        
                ## Move to the next day of the month.
                $currentDay = $currentDay.AddDays(1)
        
                ## If the function reaches the next week, store the current week
                ## in the week list and continue.
                if($currentDay.DayOfWeek -eq $dateTimeFormat.FirstDayOfWeek)
                {
                    $weeks += $currentWeek
                    $currentWeek = New-Object PsObject
                }
            }
        
            ## Format the weeks as a table.
            $calendar = $weeks | Format-Table $dayNames -AutoSize | Out-String
        
            ## Add a centered header.
            $width = ($calendar.Split("`n") | Measure-Object -Maximum Length).Maximum
            $header = "{0:MMMM yyyy}" -f $start
            $padding = " " * (($width - $header.Length) / 2)
            $displayCalendar = " `n" + $padding + $header + "`n " + $calendar
            $displayCalendar.TrimEnd()
        
            ## Move to the next month.
            $start = $start.AddMonths(1)
        
        }
        }
    
        function get-khaki2 {
            param(
                [DateTime] $start = [DateTime]::Today,
                [DateTime] $end = $start,
                $firstDayOfWeek,
                [int[]] $highlightDay,
                [string[]] $highlightDate = [DateTime]::Today.ToString('yyyy-MM-dd')
                )
            
            ## Determine the first day of the start and end months.
            $start = New-Object DateTime $start.Year,$start.Month,1
            $end = New-Object DateTime $end.Year,$end.Month,1
            
            ## Convert the highlighted dates into real dates.
            [DateTime[]] $highlightDate = [DateTime[]] $highlightDate
            
            ## Retrieve the DateTimeFormat information so that the
            ## calendar can be manipulated.
            $dateTimeFormat  = (Get-Culture).DateTimeFormat
            if($firstDayOfWeek)
            {
                $dateTimeFormat.FirstDayOfWeek = $firstDayOfWeek
            }
            
            $currentDay = $start
            
            ## Process the requested months.
            while($start -le $end)
            {
                ## Return to an earlier point in the function if the first day of the month
                ## is in the middle of the week.
                while($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek)
                {
                    $currentDay = $currentDay.AddDays(-1)
                }
            
                ## Prepare to store information about this date range.
                $currentWeek = New-Object PsObject
                $dayNames = @()
                $weeks = @()
            
                ## Continue processing dates until the function reaches the end of the month.
                ## The function continues until the week is completed with
                ## days from the next month.
                while(($currentDay -lt $start.AddMonths(1)) -or
                    ($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek))
                {
                    ## Determine the day names to use to label the columns.
                    $dayName = "{0:ddd}" -f $currentDay
                    if($dayNames -notcontains $dayName)
                    {
                        $dayNames += $dayName
                    }
            
                    ## Pad the day number for display, highlighting if necessary.
                    $displayDay = " {0,2} " -f $currentDay.Day
            
                    ## Determine whether to highlight a specific date.
                    if($highlightDate)
                    {
                        $compareDate = New-Object DateTime $currentDay.Year,
                            $currentDay.Month,$currentDay.Day
                        if($highlightDate -contains $compareDate)
                        {
                            $displayDay = "*" + ("{0,2}" -f $currentDay.Day) + "*"
                        }
                    }
            
                    ## Otherwise, highlight as part of a date range.
                    if($highlightDay -and ($highlightDay[0] -eq $currentDay.Day))
                    {
                        $displayDay = "[" + ("{0,2}" -f $currentDay.Day) + "]"
                        $null,$highlightDay = $highlightDay
                    }
            
                    ## Add the day of the week and the day of the month as note properties.
                    $currentWeek | Add-Member NoteProperty $dayName $displayDay
            
                    ## Move to the next day of the month.
                    $currentDay = $currentDay.AddDays(1)
            
                    ## If the function reaches the next week, store the current week
                    ## in the week list and continue.
                    if($currentDay.DayOfWeek -eq $dateTimeFormat.FirstDayOfWeek)
                    {
                        $weeks += $currentWeek
                        $currentWeek = New-Object PsObject
                    }
                }
            
                ## Format the weeks as a table.
                $calendar = $weeks | Format-Table $dayNames -AutoSize | Out-String
            
                ## Add a centered header.
                $width = ($calendar.Split("`n") | Measure-Object -Maximum Length).Maximum
                $header = "{0:MMMM yyyy}" -f $start
                $padding = " " * (($width - $header.Length) / 2)
                $displayCalendar = " `n" + $padding + $header + "`n " + $calendar
                $displayCalendar.TrimEnd()
            
                ## Move to the next month.
                $start = $start.AddMonths(1)
            
            }
            }


            function get-khaki3 {
                param(
                    [DateTime] $start = [DateTime]::Today,
                    [DateTime] $end = $start,
                    $firstDayOfWeek,
                    [int[]] $highlightDay,
                    [string[]] $highlightDate = [DateTime]::Today.ToString('yyyy-MM-dd')
                    )
                
                ## Determine the first day of the start and end months.
                $start = New-Object DateTime $start.Year,$start.Month,1
                $end = New-Object DateTime $end.Year,$end.Month,1
                
                ## Convert the highlighted dates into real dates.
                [DateTime[]] $highlightDate = [DateTime[]] $highlightDate
                
                ## Retrieve the DateTimeFormat information so that the
                ## calendar can be manipulated.
                $dateTimeFormat  = (Get-Culture).DateTimeFormat
                if($firstDayOfWeek)
                {
                    $dateTimeFormat.FirstDayOfWeek = $firstDayOfWeek
                }
                
                $currentDay = $start
                
                ## Process the requested months.
                while($start -le $end)
                {
                    ## Return to an earlier point in the function if the first day of the month
                    ## is in the middle of the week.
                    while($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek)
                    {
                        $currentDay = $currentDay.AddDays(-1)
                    }
                
                    ## Prepare to store information about this date range.
                    $currentWeek = New-Object PsObject
                    $dayNames = @()
                    $weeks = @()
                
                    ## Continue processing dates until the function reaches the end of the month.
                    ## The function continues until the week is completed with
                    ## days from the next month.
                    while(($currentDay -lt $start.AddMonths(1)) -or
                        ($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek))
                    {
                        ## Determine the day names to use to label the columns.
                        $dayName = "{0:ddd}" -f $currentDay
                        if($dayNames -notcontains $dayName)
                        {
                            $dayNames += $dayName
                        }
                
                        ## Pad the day number for display, highlighting if necessary.
                        $displayDay = " {0,2} " -f $currentDay.Day
                
                        ## Determine whether to highlight a specific date.
                        if($highlightDate)
                        {
                            $compareDate = New-Object DateTime $currentDay.Year,
                                $currentDay.Month,$currentDay.Day
                            if($highlightDate -contains $compareDate)
                            {
                                $displayDay = "*" + ("{0,2}" -f $currentDay.Day) + "*"
                            }
                        }
                
                        ## Otherwise, highlight as part of a date range.
                        if($highlightDay -and ($highlightDay[0] -eq $currentDay.Day))
                        {
                            $displayDay = "[" + ("{0,2}" -f $currentDay.Day) + "]"
                            $null,$highlightDay = $highlightDay
                        }
                
                        ## Add the day of the week and the day of the month as note properties.
                        $currentWeek | Add-Member NoteProperty $dayName $displayDay
                
                        ## Move to the next day of the month.
                        $currentDay = $currentDay.AddDays(1)
                
                        ## If the function reaches the next week, store the current week
                        ## in the week list and continue.
                        if($currentDay.DayOfWeek -eq $dateTimeFormat.FirstDayOfWeek)
                        {
                            $weeks += $currentWeek
                            $currentWeek = New-Object PsObject
                        }
                    }
                
                    ## Format the weeks as a table.
                    $calendar = $weeks | Format-Table $dayNames -AutoSize | Out-String
                
                    ## Add a centered header.
                    $width = ($calendar.Split("`n") | Measure-Object -Maximum Length).Maximum
                    $header = "{0:MMMM yyyy}" -f $start
                    $padding = " " * (($width - $header.Length) / 2)
                    $displayCalendar = " `n" + $padding + $header + "`n " + $calendar
                    $displayCalendar.TrimEnd()
                
                    ## Move to the next month.
                    $start = $start.AddMonths(1)
                
                }
                }

                function get-khaki4 {
                    param(
                        [DateTime] $start = [DateTime]::Today,
                        [DateTime] $end = $start,
                        $firstDayOfWeek,
                        [int[]] $highlightDay,
                        [string[]] $highlightDate = [DateTime]::Today.ToString('yyyy-MM-dd')
                        )
                    
                    ## Determine the first day of the start and end months.
                    $start = New-Object DateTime $start.Year,$start.Month,1
                    $end = New-Object DateTime $end.Year,$end.Month,1
                    
                    ## Convert the highlighted dates into real dates.
                    [DateTime[]] $highlightDate = [DateTime[]] $highlightDate
                    
                    ## Retrieve the DateTimeFormat information so that the
                    ## calendar can be manipulated.
                    $dateTimeFormat  = (Get-Culture).DateTimeFormat
                    if($firstDayOfWeek)
                    {
                        $dateTimeFormat.FirstDayOfWeek = $firstDayOfWeek
                    }
                    
                    $currentDay = $start
                    
                    ## Process the requested months.
                    while($start -le $end)
                    {
                        ## Return to an earlier point in the function if the first day of the month
                        ## is in the middle of the week.
                        while($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek)
                        {
                            $currentDay = $currentDay.AddDays(-1)
                        }
                    
                        ## Prepare to store information about this date range.
                        $currentWeek = New-Object PsObject
                        $dayNames = @()
                        $weeks = @()
                    
                        ## Continue processing dates until the function reaches the end of the month.
                        ## The function continues until the week is completed with
                        ## days from the next month.
                        while(($currentDay -lt $start.AddMonths(1)) -or
                            ($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek))
                        {
                            ## Determine the day names to use to label the columns.
                            $dayName = "{0:ddd}" -f $currentDay
                            if($dayNames -notcontains $dayName)
                            {
                                $dayNames += $dayName
                            }
                    
                            ## Pad the day number for display, highlighting if necessary.
                            $displayDay = " {0,2} " -f $currentDay.Day
                    
                            ## Determine whether to highlight a specific date.
                            if($highlightDate)
                            {
                                $compareDate = New-Object DateTime $currentDay.Year,
                                    $currentDay.Month,$currentDay.Day
                                if($highlightDate -contains $compareDate)
                                {
                                    $displayDay = "*" + ("{0,2}" -f $currentDay.Day) + "*"
                                }
                            }
                    
                            ## Otherwise, highlight as part of a date range.
                            if($highlightDay -and ($highlightDay[0] -eq $currentDay.Day))
                            {
                                $displayDay = "[" + ("{0,2}" -f $currentDay.Day) + "]"
                                $null,$highlightDay = $highlightDay
                            }
                    
                            ## Add the day of the week and the day of the month as note properties.
                            $currentWeek | Add-Member NoteProperty $dayName $displayDay
                    
                            ## Move to the next day of the month.
                            $currentDay = $currentDay.AddDays(1)
                    
                            ## If the function reaches the next week, store the current week
                            ## in the week list and continue.
                            if($currentDay.DayOfWeek -eq $dateTimeFormat.FirstDayOfWeek)
                            {
                                $weeks += $currentWeek
                                $currentWeek = New-Object PsObject
                            }
                        }
                    
                        ## Format the weeks as a table.
                        $calendar = $weeks | Format-Table $dayNames -AutoSize | Out-String
                    
                        ## Add a centered header.
                        $width = ($calendar.Split("`n") | Measure-Object -Maximum Length).Maximum
                        $header = "{0:MMMM yyyy}" -f $start
                        $padding = " " * (($width - $header.Length) / 2)
                        $displayCalendar = " `n" + $padding + $header + "`n " + $calendar
                        $displayCalendar.TrimEnd()
                    
                        ## Move to the next month.
                        $start = $start.AddMonths(1)
                    
                    }
                    }


                    function get-khaki5 {
                        param(
                            [DateTime] $start = [DateTime]::Today,
                            [DateTime] $end = $start,
                            $firstDayOfWeek,
                            [int[]] $highlightDay,
                            [string[]] $highlightDate = [DateTime]::Today.ToString('yyyy-MM-dd')
                            )
                        
                        ## Determine the first day of the start and end months.
                        $start = New-Object DateTime $start.Year,$start.Month,1
                        $end = New-Object DateTime $end.Year,$end.Month,1
                        
                        ## Convert the highlighted dates into real dates.
                        [DateTime[]] $highlightDate = [DateTime[]] $highlightDate
                        
                        ## Retrieve the DateTimeFormat information so that the
                        ## calendar can be manipulated.
                        $dateTimeFormat  = (Get-Culture).DateTimeFormat
                        if($firstDayOfWeek)
                        {
                            $dateTimeFormat.FirstDayOfWeek = $firstDayOfWeek
                        }
                        
                        $currentDay = $start
                        
                        ## Process the requested months.
                        while($start -le $end)
                        {
                            ## Return to an earlier point in the function if the first day of the month
                            ## is in the middle of the week.
                            while($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek)
                            {
                                $currentDay = $currentDay.AddDays(-1)
                            }
                        
                            ## Prepare to store information about this date range.
                            $currentWeek = New-Object PsObject
                            $dayNames = @()
                            $weeks = @()
                        
                            ## Continue processing dates until the function reaches the end of the month.
                            ## The function continues until the week is completed with
                            ## days from the next month.
                            while(($currentDay -lt $start.AddMonths(1)) -or
                                ($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek))
                            {
                                ## Determine the day names to use to label the columns.
                                $dayName = "{0:ddd}" -f $currentDay
                                if($dayNames -notcontains $dayName)
                                {
                                    $dayNames += $dayName
                                }
                        
                                ## Pad the day number for display, highlighting if necessary.
                                $displayDay = " {0,2} " -f $currentDay.Day
                        
                                ## Determine whether to highlight a specific date.
                                if($highlightDate)
                                {
                                    $compareDate = New-Object DateTime $currentDay.Year,
                                        $currentDay.Month,$currentDay.Day
                                    if($highlightDate -contains $compareDate)
                                    {
                                        $displayDay = "*" + ("{0,2}" -f $currentDay.Day) + "*"
                                    }
                                }
                        
                                ## Otherwise, highlight as part of a date range.
                                if($highlightDay -and ($highlightDay[0] -eq $currentDay.Day))
                                {
                                    $displayDay = "[" + ("{0,2}" -f $currentDay.Day) + "]"
                                    $null,$highlightDay = $highlightDay
                                }
                        
                                ## Add the day of the week and the day of the month as note properties.
                                $currentWeek | Add-Member NoteProperty $dayName $displayDay
                        
                                ## Move to the next day of the month.
                                $currentDay = $currentDay.AddDays(1)
                        
                                ## If the function reaches the next week, store the current week
                                ## in the week list and continue.
                                if($currentDay.DayOfWeek -eq $dateTimeFormat.FirstDayOfWeek)
                                {
                                    $weeks += $currentWeek
                                    $currentWeek = New-Object PsObject
                                }
                            }
                        
                            ## Format the weeks as a table.
                            $calendar = $weeks | Format-Table $dayNames -AutoSize | Out-String
                        
                            ## Add a centered header.
                            $width = ($calendar.Split("`n") | Measure-Object -Maximum Length).Maximum
                            $header = "{0:MMMM yyyy}" -f $start
                            $padding = " " * (($width - $header.Length) / 2)
                            $displayCalendar = " `n" + $padding + $header + "`n " + $calendar
                            $displayCalendar.TrimEnd()
                        
                            ## Move to the next month.
                            $start = $start.AddMonths(1)
                        
                        }
                        }


                        function get-khaki6 {
                            param(
                                [DateTime] $start = [DateTime]::Today,
                                [DateTime] $end = $start,
                                $firstDayOfWeek,
                                [int[]] $highlightDay,
                                [string[]] $highlightDate = [DateTime]::Today.ToString('yyyy-MM-dd')
                                )
                            
                            ## Determine the first day of the start and end months.
                            $start = New-Object DateTime $start.Year,$start.Month,1
                            $end = New-Object DateTime $end.Year,$end.Month,1
                            
                            ## Convert the highlighted dates into real dates.
                            [DateTime[]] $highlightDate = [DateTime[]] $highlightDate
                            
                            ## Retrieve the DateTimeFormat information so that the
                            ## calendar can be manipulated.
                            $dateTimeFormat  = (Get-Culture).DateTimeFormat
                            if($firstDayOfWeek)
                            {
                                $dateTimeFormat.FirstDayOfWeek = $firstDayOfWeek
                            }
                            
                            $currentDay = $start
                            
                            ## Process the requested months.
                            while($start -le $end)
                            {
                                ## Return to an earlier point in the function if the first day of the month
                                ## is in the middle of the week.
                                while($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek)
                                {
                                    $currentDay = $currentDay.AddDays(-1)
                                }
                            
                                ## Prepare to store information about this date range.
                                $currentWeek = New-Object PsObject
                                $dayNames = @()
                                $weeks = @()
                            
                                ## Continue processing dates until the function reaches the end of the month.
                                ## The function continues until the week is completed with
                                ## days from the next month.
                                while(($currentDay -lt $start.AddMonths(1)) -or
                                    ($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek))
                                {
                                    ## Determine the day names to use to label the columns.
                                    $dayName = "{0:ddd}" -f $currentDay
                                    if($dayNames -notcontains $dayName)
                                    {
                                        $dayNames += $dayName
                                    }
                            
                                    ## Pad the day number for display, highlighting if necessary.
                                    $displayDay = " {0,2} " -f $currentDay.Day
                            
                                    ## Determine whether to highlight a specific date.
                                    if($highlightDate)
                                    {
                                        $compareDate = New-Object DateTime $currentDay.Year,
                                            $currentDay.Month,$currentDay.Day
                                        if($highlightDate -contains $compareDate)
                                        {
                                            $displayDay = "*" + ("{0,2}" -f $currentDay.Day) + "*"
                                        }
                                    }
                            
                                    ## Otherwise, highlight as part of a date range.
                                    if($highlightDay -and ($highlightDay[0] -eq $currentDay.Day))
                                    {
                                        $displayDay = "[" + ("{0,2}" -f $currentDay.Day) + "]"
                                        $null,$highlightDay = $highlightDay
                                    }
                            
                                    ## Add the day of the week and the day of the month as note properties.
                                    $currentWeek | Add-Member NoteProperty $dayName $displayDay
                            
                                    ## Move to the next day of the month.
                                    $currentDay = $currentDay.AddDays(1)
                            
                                    ## If the function reaches the next week, store the current week
                                    ## in the week list and continue.
                                    if($currentDay.DayOfWeek -eq $dateTimeFormat.FirstDayOfWeek)
                                    {
                                        $weeks += $currentWeek
                                        $currentWeek = New-Object PsObject
                                    }
                                }
                            
                                ## Format the weeks as a table.
                                $calendar = $weeks | Format-Table $dayNames -AutoSize | Out-String
                            
                                ## Add a centered header.
                                $width = ($calendar.Split("`n") | Measure-Object -Maximum Length).Maximum
                                $header = "{0:MMMM yyyy}" -f $start
                                $padding = " " * (($width - $header.Length) / 2)
                                $displayCalendar = " `n" + $padding + $header + "`n " + $calendar
                                $displayCalendar.TrimEnd()
                            
                                ## Move to the next month.
                                $start = $start.AddMonths(1)
                            
                            }
                            }




                            function get-khaki7 {
                                param(
                                    [DateTime] $start = [DateTime]::Today,
                                    [DateTime] $end = $start,
                                    $firstDayOfWeek,
                                    [int[]] $highlightDay,
                                    [string[]] $highlightDate = [DateTime]::Today.ToString('yyyy-MM-dd')
                                    )
                                
                                ## Determine the first day of the start and end months.
                                $start = New-Object DateTime $start.Year,$start.Month,1
                                $end = New-Object DateTime $end.Year,$end.Month,1
                                
                                ## Convert the highlighted dates into real dates.
                                [DateTime[]] $highlightDate = [DateTime[]] $highlightDate
                                
                                ## Retrieve the DateTimeFormat information so that the
                                ## calendar can be manipulated.
                                $dateTimeFormat  = (Get-Culture).DateTimeFormat
                                if($firstDayOfWeek)
                                {
                                    $dateTimeFormat.FirstDayOfWeek = $firstDayOfWeek
                                }
                                
                                $currentDay = $start
                                
                                ## Process the requested months.
                                while($start -le $end)
                                {
                                    ## Return to an earlier point in the function if the first day of the month
                                    ## is in the middle of the week.
                                    while($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek)
                                    {
                                        $currentDay = $currentDay.AddDays(-1)
                                    }
                                
                                    ## Prepare to store information about this date range.
                                    $currentWeek = New-Object PsObject
                                    $dayNames = @()
                                    $weeks = @()
                                
                                    ## Continue processing dates until the function reaches the end of the month.
                                    ## The function continues until the week is completed with
                                    ## days from the next month.
                                    while(($currentDay -lt $start.AddMonths(1)) -or
                                        ($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek))
                                    {
                                        ## Determine the day names to use to label the columns.
                                        $dayName = "{0:ddd}" -f $currentDay
                                        if($dayNames -notcontains $dayName)
                                        {
                                            $dayNames += $dayName
                                        }
                                
                                        ## Pad the day number for display, highlighting if necessary.
                                        $displayDay = " {0,2} " -f $currentDay.Day
                                
                                        ## Determine whether to highlight a specific date.
                                        if($highlightDate)
                                        {
                                            $compareDate = New-Object DateTime $currentDay.Year,
                                                $currentDay.Month,$currentDay.Day
                                            if($highlightDate -contains $compareDate)
                                            {
                                                $displayDay = "*" + ("{0,2}" -f $currentDay.Day) + "*"
                                            }
                                        }
                                
                                        ## Otherwise, highlight as part of a date range.
                                        if($highlightDay -and ($highlightDay[0] -eq $currentDay.Day))
                                        {
                                            $displayDay = "[" + ("{0,2}" -f $currentDay.Day) + "]"
                                            $null,$highlightDay = $highlightDay
                                        }
                                
                                        ## Add the day of the week and the day of the month as note properties.
                                        $currentWeek | Add-Member NoteProperty $dayName $displayDay
                                
                                        ## Move to the next day of the month.
                                        $currentDay = $currentDay.AddDays(1)
                                
                                        ## If the function reaches the next week, store the current week
                                        ## in the week list and continue.
                                        if($currentDay.DayOfWeek -eq $dateTimeFormat.FirstDayOfWeek)
                                        {
                                            $weeks += $currentWeek
                                            $currentWeek = New-Object PsObject
                                        }
                                    }
                                
                                    ## Format the weeks as a table.
                                    $calendar = $weeks | Format-Table $dayNames -AutoSize | Out-String
                                
                                    ## Add a centered header.
                                    $width = ($calendar.Split("`n") | Measure-Object -Maximum Length).Maximum
                                    $header = "{0:MMMM yyyy}" -f $start
                                    $padding = " " * (($width - $header.Length) / 2)
                                    $displayCalendar = " `n" + $padding + $header + "`n " + $calendar
                                    $displayCalendar.TrimEnd()
                                
                                    ## Move to the next month.
                                    $start = $start.AddMonths(1)
                                
                                }
                                }




                                function get-khaki8 {
                                    param(
                                        [DateTime] $start = [DateTime]::Today,
                                        [DateTime] $end = $start,
                                        $firstDayOfWeek,
                                        [int[]] $highlightDay,
                                        [string[]] $highlightDate = [DateTime]::Today.ToString('yyyy-MM-dd')
                                        )
                                    
                                    ## Determine the first day of the start and end months.
                                    $start = New-Object DateTime $start.Year,$start.Month,1
                                    $end = New-Object DateTime $end.Year,$end.Month,1
                                    
                                    ## Convert the highlighted dates into real dates.
                                    [DateTime[]] $highlightDate = [DateTime[]] $highlightDate
                                    
                                    ## Retrieve the DateTimeFormat information so that the
                                    ## calendar can be manipulated.
                                    $dateTimeFormat  = (Get-Culture).DateTimeFormat
                                    if($firstDayOfWeek)
                                    {
                                        $dateTimeFormat.FirstDayOfWeek = $firstDayOfWeek
                                    }
                                    
                                    $currentDay = $start
                                    
                                    ## Process the requested months.
                                    while($start -le $end)
                                    {
                                        ## Return to an earlier point in the function if the first day of the month
                                        ## is in the middle of the week.
                                        while($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek)
                                        {
                                            $currentDay = $currentDay.AddDays(-1)
                                        }
                                    
                                        ## Prepare to store information about this date range.
                                        $currentWeek = New-Object PsObject
                                        $dayNames = @()
                                        $weeks = @()
                                    
                                        ## Continue processing dates until the function reaches the end of the month.
                                        ## The function continues until the week is completed with
                                        ## days from the next month.
                                        while(($currentDay -lt $start.AddMonths(1)) -or
                                            ($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek))
                                        {
                                            ## Determine the day names to use to label the columns.
                                            $dayName = "{0:ddd}" -f $currentDay
                                            if($dayNames -notcontains $dayName)
                                            {
                                                $dayNames += $dayName
                                            }
                                    
                                            ## Pad the day number for display, highlighting if necessary.
                                            $displayDay = " {0,2} " -f $currentDay.Day
                                    
                                            ## Determine whether to highlight a specific date.
                                            if($highlightDate)
                                            {
                                                $compareDate = New-Object DateTime $currentDay.Year,
                                                    $currentDay.Month,$currentDay.Day
                                                if($highlightDate -contains $compareDate)
                                                {
                                                    $displayDay = "*" + ("{0,2}" -f $currentDay.Day) + "*"
                                                }
                                            }
                                    
                                            ## Otherwise, highlight as part of a date range.
                                            if($highlightDay -and ($highlightDay[0] -eq $currentDay.Day))
                                            {
                                                $displayDay = "[" + ("{0,2}" -f $currentDay.Day) + "]"
                                                $null,$highlightDay = $highlightDay
                                            }
                                    
                                            ## Add the day of the week and the day of the month as note properties.
                                            $currentWeek | Add-Member NoteProperty $dayName $displayDay
                                    
                                            ## Move to the next day of the month.
                                            $currentDay = $currentDay.AddDays(1)
                                    
                                            ## If the function reaches the next week, store the current week
                                            ## in the week list and continue.
                                            if($currentDay.DayOfWeek -eq $dateTimeFormat.FirstDayOfWeek)
                                            {
                                                $weeks += $currentWeek
                                                $currentWeek = New-Object PsObject
                                            }
                                        }
                                    
                                        ## Format the weeks as a table.
                                        $calendar = $weeks | Format-Table $dayNames -AutoSize | Out-String
                                    
                                        ## Add a centered header.
                                        $width = ($calendar.Split("`n") | Measure-Object -Maximum Length).Maximum
                                        $header = "{0:MMMM yyyy}" -f $start
                                        $padding = " " * (($width - $header.Length) / 2)
                                        $displayCalendar = " `n" + $padding + $header + "`n " + $calendar
                                        $displayCalendar.TrimEnd()
                                    
                                        ## Move to the next month.
                                        $start = $start.AddMonths(1)
                                    
                                    }
                                    }




                                    function get-khaki9 {
                                        param(
                                            [DateTime] $start = [DateTime]::Today,
                                            [DateTime] $end = $start,
                                            $firstDayOfWeek,
                                            [int[]] $highlightDay,
                                            [string[]] $highlightDate = [DateTime]::Today.ToString('yyyy-MM-dd')
                                            )
                                        
                                        ## Determine the first day of the start and end months.
                                        $start = New-Object DateTime $start.Year,$start.Month,1
                                        $end = New-Object DateTime $end.Year,$end.Month,1
                                        
                                        ## Convert the highlighted dates into real dates.
                                        [DateTime[]] $highlightDate = [DateTime[]] $highlightDate
                                        
                                        ## Retrieve the DateTimeFormat information so that the
                                        ## calendar can be manipulated.
                                        $dateTimeFormat  = (Get-Culture).DateTimeFormat
                                        if($firstDayOfWeek)
                                        {
                                            $dateTimeFormat.FirstDayOfWeek = $firstDayOfWeek
                                        }
                                        
                                        $currentDay = $start
                                        
                                        ## Process the requested months.
                                        while($start -le $end)
                                        {
                                            ## Return to an earlier point in the function if the first day of the month
                                            ## is in the middle of the week.
                                            while($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek)
                                            {
                                                $currentDay = $currentDay.AddDays(-1)
                                            }
                                        
                                            ## Prepare to store information about this date range.
                                            $currentWeek = New-Object PsObject
                                            $dayNames = @()
                                            $weeks = @()
                                        
                                            ## Continue processing dates until the function reaches the end of the month.
                                            ## The function continues until the week is completed with
                                            ## days from the next month.
                                            while(($currentDay -lt $start.AddMonths(1)) -or
                                                ($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek))
                                            {
                                                ## Determine the day names to use to label the columns.
                                                $dayName = "{0:ddd}" -f $currentDay
                                                if($dayNames -notcontains $dayName)
                                                {
                                                    $dayNames += $dayName
                                                }
                                        
                                                ## Pad the day number for display, highlighting if necessary.
                                                $displayDay = " {0,2} " -f $currentDay.Day
                                        
                                                ## Determine whether to highlight a specific date.
                                                if($highlightDate)
                                                {
                                                    $compareDate = New-Object DateTime $currentDay.Year,
                                                        $currentDay.Month,$currentDay.Day
                                                    if($highlightDate -contains $compareDate)
                                                    {
                                                        $displayDay = "*" + ("{0,2}" -f $currentDay.Day) + "*"
                                                    }
                                                }
                                        
                                                ## Otherwise, highlight as part of a date range.
                                                if($highlightDay -and ($highlightDay[0] -eq $currentDay.Day))
                                                {
                                                    $displayDay = "[" + ("{0,2}" -f $currentDay.Day) + "]"
                                                    $null,$highlightDay = $highlightDay
                                                }
                                        
                                                ## Add the day of the week and the day of the month as note properties.
                                                $currentWeek | Add-Member NoteProperty $dayName $displayDay
                                        
                                                ## Move to the next day of the month.
                                                $currentDay = $currentDay.AddDays(1)
                                        
                                                ## If the function reaches the next week, store the current week
                                                ## in the week list and continue.
                                                if($currentDay.DayOfWeek -eq $dateTimeFormat.FirstDayOfWeek)
                                                {
                                                    $weeks += $currentWeek
                                                    $currentWeek = New-Object PsObject
                                                }
                                            }
                                        
                                            ## Format the weeks as a table.
                                            $calendar = $weeks | Format-Table $dayNames -AutoSize | Out-String
                                        
                                            ## Add a centered header.
                                            $width = ($calendar.Split("`n") | Measure-Object -Maximum Length).Maximum
                                            $header = "{0:MMMM yyyy}" -f $start
                                            $padding = " " * (($width - $header.Length) / 2)
                                            $displayCalendar = " `n" + $padding + $header + "`n " + $calendar
                                            $displayCalendar.TrimEnd()
                                        
                                            ## Move to the next month.
                                            $start = $start.AddMonths(1)
                                        
                                        }
                                        }



                                        function get-khaki10 {
                                            param(
                                                [DateTime] $start = [DateTime]::Today,
                                                [DateTime] $end = $start,
                                                $firstDayOfWeek,
                                                [int[]] $highlightDay,
                                                [string[]] $highlightDate = [DateTime]::Today.ToString('yyyy-MM-dd')
                                                )
                                            
                                            ## Determine the first day of the start and end months.
                                            $start = New-Object DateTime $start.Year,$start.Month,1
                                            $end = New-Object DateTime $end.Year,$end.Month,1
                                            
                                            ## Convert the highlighted dates into real dates.
                                            [DateTime[]] $highlightDate = [DateTime[]] $highlightDate
                                            
                                            ## Retrieve the DateTimeFormat information so that the
                                            ## calendar can be manipulated.
                                            $dateTimeFormat  = (Get-Culture).DateTimeFormat
                                            if($firstDayOfWeek)
                                            {
                                                $dateTimeFormat.FirstDayOfWeek = $firstDayOfWeek
                                            }
                                            
                                            $currentDay = $start
                                            
                                            ## Process the requested months.
                                            while($start -le $end)
                                            {
                                                ## Return to an earlier point in the function if the first day of the month
                                                ## is in the middle of the week.
                                                while($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek)
                                                {
                                                    $currentDay = $currentDay.AddDays(-1)
                                                }
                                            
                                                ## Prepare to store information about this date range.
                                                $currentWeek = New-Object PsObject
                                                $dayNames = @()
                                                $weeks = @()
                                            
                                                ## Continue processing dates until the function reaches the end of the month.
                                                ## The function continues until the week is completed with
                                                ## days from the next month.
                                                while(($currentDay -lt $start.AddMonths(1)) -or
                                                    ($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek))
                                                {
                                                    ## Determine the day names to use to label the columns.
                                                    $dayName = "{0:ddd}" -f $currentDay
                                                    if($dayNames -notcontains $dayName)
                                                    {
                                                        $dayNames += $dayName
                                                    }
                                            
                                                    ## Pad the day number for display, highlighting if necessary.
                                                    $displayDay = " {0,2} " -f $currentDay.Day
                                            
                                                    ## Determine whether to highlight a specific date.
                                                    if($highlightDate)
                                                    {
                                                        $compareDate = New-Object DateTime $currentDay.Year,
                                                            $currentDay.Month,$currentDay.Day
                                                        if($highlightDate -contains $compareDate)
                                                        {
                                                            $displayDay = "*" + ("{0,2}" -f $currentDay.Day) + "*"
                                                        }
                                                    }
                                            
                                                    ## Otherwise, highlight as part of a date range.
                                                    if($highlightDay -and ($highlightDay[0] -eq $currentDay.Day))
                                                    {
                                                        $displayDay = "[" + ("{0,2}" -f $currentDay.Day) + "]"
                                                        $null,$highlightDay = $highlightDay
                                                    }
                                            
                                                    ## Add the day of the week and the day of the month as note properties.
                                                    $currentWeek | Add-Member NoteProperty $dayName $displayDay
                                            
                                                    ## Move to the next day of the month.
                                                    $currentDay = $currentDay.AddDays(1)
                                            
                                                    ## If the function reaches the next week, store the current week
                                                    ## in the week list and continue.
                                                    if($currentDay.DayOfWeek -eq $dateTimeFormat.FirstDayOfWeek)
                                                    {
                                                        $weeks += $currentWeek
                                                        $currentWeek = New-Object PsObject
                                                    }
                                                }
                                            
                                                ## Format the weeks as a table.
                                                $calendar = $weeks | Format-Table $dayNames -AutoSize | Out-String
                                            
                                                ## Add a centered header.
                                                $width = ($calendar.Split("`n") | Measure-Object -Maximum Length).Maximum
                                                $header = "{0:MMMM yyyy}" -f $start
                                                $padding = " " * (($width - $header.Length) / 2)
                                                $displayCalendar = " `n" + $padding + $header + "`n " + $calendar
                                                $displayCalendar.TrimEnd()
                                            
                                                ## Move to the next month.
                                                $start = $start.AddMonths(1)
                                            
                                            }
                                            }


                                            function get-khaki11 {
                                                param(
                                                    [DateTime] $start = [DateTime]::Today,
                                                    [DateTime] $end = $start,
                                                    $firstDayOfWeek,
                                                    [int[]] $highlightDay,
                                                    [string[]] $highlightDate = [DateTime]::Today.ToString('yyyy-MM-dd')
                                                    )
                                                
                                                ## Determine the first day of the start and end months.
                                                $start = New-Object DateTime $start.Year,$start.Month,1
                                                $end = New-Object DateTime $end.Year,$end.Month,1
                                                
                                                ## Convert the highlighted dates into real dates.
                                                [DateTime[]] $highlightDate = [DateTime[]] $highlightDate
                                                
                                                ## Retrieve the DateTimeFormat information so that the
                                                ## calendar can be manipulated.
                                                $dateTimeFormat  = (Get-Culture).DateTimeFormat
                                                if($firstDayOfWeek)
                                                {
                                                    $dateTimeFormat.FirstDayOfWeek = $firstDayOfWeek
                                                }
                                                
                                                $currentDay = $start
                                                
                                                ## Process the requested months.
                                                while($start -le $end)
                                                {
                                                    ## Return to an earlier point in the function if the first day of the month
                                                    ## is in the middle of the week.
                                                    while($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek)
                                                    {
                                                        $currentDay = $currentDay.AddDays(-1)
                                                    }
                                                
                                                    ## Prepare to store information about this date range.
                                                    $currentWeek = New-Object PsObject
                                                    $dayNames = @()
                                                    $weeks = @()
                                                
                                                    ## Continue processing dates until the function reaches the end of the month.
                                                    ## The function continues until the week is completed with
                                                    ## days from the next month.
                                                    while(($currentDay -lt $start.AddMonths(1)) -or
                                                        ($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek))
                                                    {
                                                        ## Determine the day names to use to label the columns.
                                                        $dayName = "{0:ddd}" -f $currentDay
                                                        if($dayNames -notcontains $dayName)
                                                        {
                                                            $dayNames += $dayName
                                                        }
                                                
                                                        ## Pad the day number for display, highlighting if necessary.
                                                        $displayDay = " {0,2} " -f $currentDay.Day
                                                
                                                        ## Determine whether to highlight a specific date.
                                                        if($highlightDate)
                                                        {
                                                            $compareDate = New-Object DateTime $currentDay.Year,
                                                                $currentDay.Month,$currentDay.Day
                                                            if($highlightDate -contains $compareDate)
                                                            {
                                                                $displayDay = "*" + ("{0,2}" -f $currentDay.Day) + "*"
                                                            }
                                                        }
                                                
                                                        ## Otherwise, highlight as part of a date range.
                                                        if($highlightDay -and ($highlightDay[0] -eq $currentDay.Day))
                                                        {
                                                            $displayDay = "[" + ("{0,2}" -f $currentDay.Day) + "]"
                                                            $null,$highlightDay = $highlightDay
                                                        }
                                                
                                                        ## Add the day of the week and the day of the month as note properties.
                                                        $currentWeek | Add-Member NoteProperty $dayName $displayDay
                                                
                                                        ## Move to the next day of the month.
                                                        $currentDay = $currentDay.AddDays(1)
                                                
                                                        ## If the function reaches the next week, store the current week
                                                        ## in the week list and continue.
                                                        if($currentDay.DayOfWeek -eq $dateTimeFormat.FirstDayOfWeek)
                                                        {
                                                            $weeks += $currentWeek
                                                            $currentWeek = New-Object PsObject
                                                        }
                                                    }
                                                
                                                    ## Format the weeks as a table.
                                                    $calendar = $weeks | Format-Table $dayNames -AutoSize | Out-String
                                                
                                                    ## Add a centered header.
                                                    $width = ($calendar.Split("`n") | Measure-Object -Maximum Length).Maximum
                                                    $header = "{0:MMMM yyyy}" -f $start
                                                    $padding = " " * (($width - $header.Length) / 2)
                                                    $displayCalendar = " `n" + $padding + $header + "`n " + $calendar
                                                    $displayCalendar.TrimEnd()
                                                
                                                    ## Move to the next month.
                                                    $start = $start.AddMonths(1)
                                                
                                                }
                                                }


                                                function get-khaki12 {
                                                    param(
                                                        [DateTime] $start = [DateTime]::Today,
                                                        [DateTime] $end = $start,
                                                        $firstDayOfWeek,
                                                        [int[]] $highlightDay,
                                                        [string[]] $highlightDate = [DateTime]::Today.ToString('yyyy-MM-dd')
                                                        )
                                                    
                                                    ## Determine the first day of the start and end months.
                                                    $start = New-Object DateTime $start.Year,$start.Month,1
                                                    $end = New-Object DateTime $end.Year,$end.Month,1
                                                    
                                                    ## Convert the highlighted dates into real dates.
                                                    [DateTime[]] $highlightDate = [DateTime[]] $highlightDate
                                                    
                                                    ## Retrieve the DateTimeFormat information so that the
                                                    ## calendar can be manipulated.
                                                    $dateTimeFormat  = (Get-Culture).DateTimeFormat
                                                    if($firstDayOfWeek)
                                                    {
                                                        $dateTimeFormat.FirstDayOfWeek = $firstDayOfWeek
                                                    }
                                                    
                                                    $currentDay = $start
                                                    
                                                    ## Process the requested months.
                                                    while($start -le $end)
                                                    {
                                                        ## Return to an earlier point in the function if the first day of the month
                                                        ## is in the middle of the week.
                                                        while($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek)
                                                        {
                                                            $currentDay = $currentDay.AddDays(-1)
                                                        }
                                                    
                                                        ## Prepare to store information about this date range.
                                                        $currentWeek = New-Object PsObject
                                                        $dayNames = @()
                                                        $weeks = @()
                                                    
                                                        ## Continue processing dates until the function reaches the end of the month.
                                                        ## The function continues until the week is completed with
                                                        ## days from the next month.
                                                        while(($currentDay -lt $start.AddMonths(1)) -or
                                                            ($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek))
                                                        {
                                                            ## Determine the day names to use to label the columns.
                                                            $dayName = "{0:ddd}" -f $currentDay
                                                            if($dayNames -notcontains $dayName)
                                                            {
                                                                $dayNames += $dayName
                                                            }
                                                    
                                                            ## Pad the day number for display, highlighting if necessary.
                                                            $displayDay = " {0,2} " -f $currentDay.Day
                                                    
                                                            ## Determine whether to highlight a specific date.
                                                            if($highlightDate)
                                                            {
                                                                $compareDate = New-Object DateTime $currentDay.Year,
                                                                    $currentDay.Month,$currentDay.Day
                                                                if($highlightDate -contains $compareDate)
                                                                {
                                                                    $displayDay = "*" + ("{0,2}" -f $currentDay.Day) + "*"
                                                                }
                                                            }
                                                    
                                                            ## Otherwise, highlight as part of a date range.
                                                            if($highlightDay -and ($highlightDay[0] -eq $currentDay.Day))
                                                            {
                                                                $displayDay = "[" + ("{0,2}" -f $currentDay.Day) + "]"
                                                                $null,$highlightDay = $highlightDay
                                                            }
                                                    
                                                            ## Add the day of the week and the day of the month as note properties.
                                                            $currentWeek | Add-Member NoteProperty $dayName $displayDay
                                                    
                                                            ## Move to the next day of the month.
                                                            $currentDay = $currentDay.AddDays(1)
                                                    
                                                            ## If the function reaches the next week, store the current week
                                                            ## in the week list and continue.
                                                            if($currentDay.DayOfWeek -eq $dateTimeFormat.FirstDayOfWeek)
                                                            {
                                                                $weeks += $currentWeek
                                                                $currentWeek = New-Object PsObject
                                                            }
                                                        }
                                                    
                                                        ## Format the weeks as a table.
                                                        $calendar = $weeks | Format-Table $dayNames -AutoSize | Out-String
                                                    
                                                        ## Add a centered header.
                                                        $width = ($calendar.Split("`n") | Measure-Object -Maximum Length).Maximum
                                                        $header = "{0:MMMM yyyy}" -f $start
                                                        $padding = " " * (($width - $header.Length) / 2)
                                                        $displayCalendar = " `n" + $padding + $header + "`n " + $calendar
                                                        $displayCalendar.TrimEnd()
                                                    
                                                        ## Move to the next month.
                                                        $start = $start.AddMonths(1)
                                                    
                                                    }
                                                    }


                                                    function get-khaki13 {
                                                        param(
                                                            [DateTime] $start = [DateTime]::Today,
                                                            [DateTime] $end = $start,
                                                            $firstDayOfWeek,
                                                            [int[]] $highlightDay,
                                                            [string[]] $highlightDate = [DateTime]::Today.ToString('yyyy-MM-dd')
                                                            )
                                                        
                                                        ## Determine the first day of the start and end months.
                                                        $start = New-Object DateTime $start.Year,$start.Month,1
                                                        $end = New-Object DateTime $end.Year,$end.Month,1
                                                        
                                                        ## Convert the highlighted dates into real dates.
                                                        [DateTime[]] $highlightDate = [DateTime[]] $highlightDate
                                                        
                                                        ## Retrieve the DateTimeFormat information so that the
                                                        ## calendar can be manipulated.
                                                        $dateTimeFormat  = (Get-Culture).DateTimeFormat
                                                        if($firstDayOfWeek)
                                                        {
                                                            $dateTimeFormat.FirstDayOfWeek = $firstDayOfWeek
                                                        }
                                                        
                                                        $currentDay = $start
                                                        
                                                        ## Process the requested months.
                                                        while($start -le $end)
                                                        {
                                                            ## Return to an earlier point in the function if the first day of the month
                                                            ## is in the middle of the week.
                                                            while($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek)
                                                            {
                                                                $currentDay = $currentDay.AddDays(-1)
                                                            }
                                                        
                                                            ## Prepare to store information about this date range.
                                                            $currentWeek = New-Object PsObject
                                                            $dayNames = @()
                                                            $weeks = @()
                                                        
                                                            ## Continue processing dates until the function reaches the end of the month.
                                                            ## The function continues until the week is completed with
                                                            ## days from the next month.
                                                            while(($currentDay -lt $start.AddMonths(1)) -or
                                                                ($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek))
                                                            {
                                                                ## Determine the day names to use to label the columns.
                                                                $dayName = "{0:ddd}" -f $currentDay
                                                                if($dayNames -notcontains $dayName)
                                                                {
                                                                    $dayNames += $dayName
                                                                }
                                                        
                                                                ## Pad the day number for display, highlighting if necessary.
                                                                $displayDay = " {0,2} " -f $currentDay.Day
                                                        
                                                                ## Determine whether to highlight a specific date.
                                                                if($highlightDate)
                                                                {
                                                                    $compareDate = New-Object DateTime $currentDay.Year,
                                                                        $currentDay.Month,$currentDay.Day
                                                                    if($highlightDate -contains $compareDate)
                                                                    {
                                                                        $displayDay = "*" + ("{0,2}" -f $currentDay.Day) + "*"
                                                                    }
                                                                }
                                                        
                                                                ## Otherwise, highlight as part of a date range.
                                                                if($highlightDay -and ($highlightDay[0] -eq $currentDay.Day))
                                                                {
                                                                    $displayDay = "[" + ("{0,2}" -f $currentDay.Day) + "]"
                                                                    $null,$highlightDay = $highlightDay
                                                                }
                                                        
                                                                ## Add the day of the week and the day of the month as note properties.
                                                                $currentWeek | Add-Member NoteProperty $dayName $displayDay
                                                        
                                                                ## Move to the next day of the month.
                                                                $currentDay = $currentDay.AddDays(1)
                                                        
                                                                ## If the function reaches the next week, store the current week
                                                                ## in the week list and continue.
                                                                if($currentDay.DayOfWeek -eq $dateTimeFormat.FirstDayOfWeek)
                                                                {
                                                                    $weeks += $currentWeek
                                                                    $currentWeek = New-Object PsObject
                                                                }
                                                            }
                                                        
                                                            ## Format the weeks as a table.
                                                            $calendar = $weeks | Format-Table $dayNames -AutoSize | Out-String
                                                        
                                                            ## Add a centered header.
                                                            $width = ($calendar.Split("`n") | Measure-Object -Maximum Length).Maximum
                                                            $header = "{0:MMMM yyyy}" -f $start
                                                            $padding = " " * (($width - $header.Length) / 2)
                                                            $displayCalendar = " `n" + $padding + $header + "`n " + $calendar
                                                            $displayCalendar.TrimEnd()
                                                        
                                                            ## Move to the next month.
                                                            $start = $start.AddMonths(1)
                                                        
                                                        }
                                                        }


                                                        function get-khaki14 {
                                                            param(
                                                                [DateTime] $start = [DateTime]::Today,
                                                                [DateTime] $end = $start,
                                                                $firstDayOfWeek,
                                                                [int[]] $highlightDay,
                                                                [string[]] $highlightDate = [DateTime]::Today.ToString('yyyy-MM-dd')
                                                                )
                                                            
                                                            ## Determine the first day of the start and end months.
                                                            $start = New-Object DateTime $start.Year,$start.Month,1
                                                            $end = New-Object DateTime $end.Year,$end.Month,1
                                                            
                                                            ## Convert the highlighted dates into real dates.
                                                            [DateTime[]] $highlightDate = [DateTime[]] $highlightDate
                                                            
                                                            ## Retrieve the DateTimeFormat information so that the
                                                            ## calendar can be manipulated.
                                                            $dateTimeFormat  = (Get-Culture).DateTimeFormat
                                                            if($firstDayOfWeek)
                                                            {
                                                                $dateTimeFormat.FirstDayOfWeek = $firstDayOfWeek
                                                            }
                                                            
                                                            $currentDay = $start
                                                            
                                                            ## Process the requested months.
                                                            while($start -le $end)
                                                            {
                                                                ## Return to an earlier point in the function if the first day of the month
                                                                ## is in the middle of the week.
                                                                while($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek)
                                                                {
                                                                    $currentDay = $currentDay.AddDays(-1)
                                                                }
                                                            
                                                                ## Prepare to store information about this date range.
                                                                $currentWeek = New-Object PsObject
                                                                $dayNames = @()
                                                                $weeks = @()
                                                            
                                                                ## Continue processing dates until the function reaches the end of the month.
                                                                ## The function continues until the week is completed with
                                                                ## days from the next month.
                                                                while(($currentDay -lt $start.AddMonths(1)) -or
                                                                    ($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek))
                                                                {
                                                                    ## Determine the day names to use to label the columns.
                                                                    $dayName = "{0:ddd}" -f $currentDay
                                                                    if($dayNames -notcontains $dayName)
                                                                    {
                                                                        $dayNames += $dayName
                                                                    }
                                                            
                                                                    ## Pad the day number for display, highlighting if necessary.
                                                                    $displayDay = " {0,2} " -f $currentDay.Day
                                                            
                                                                    ## Determine whether to highlight a specific date.
                                                                    if($highlightDate)
                                                                    {
                                                                        $compareDate = New-Object DateTime $currentDay.Year,
                                                                            $currentDay.Month,$currentDay.Day
                                                                        if($highlightDate -contains $compareDate)
                                                                        {
                                                                            $displayDay = "*" + ("{0,2}" -f $currentDay.Day) + "*"
                                                                        }
                                                                    }
                                                            
                                                                    ## Otherwise, highlight as part of a date range.
                                                                    if($highlightDay -and ($highlightDay[0] -eq $currentDay.Day))
                                                                    {
                                                                        $displayDay = "[" + ("{0,2}" -f $currentDay.Day) + "]"
                                                                        $null,$highlightDay = $highlightDay
                                                                    }
                                                            
                                                                    ## Add the day of the week and the day of the month as note properties.
                                                                    $currentWeek | Add-Member NoteProperty $dayName $displayDay
                                                            
                                                                    ## Move to the next day of the month.
                                                                    $currentDay = $currentDay.AddDays(1)
                                                            
                                                                    ## If the function reaches the next week, store the current week
                                                                    ## in the week list and continue.
                                                                    if($currentDay.DayOfWeek -eq $dateTimeFormat.FirstDayOfWeek)
                                                                    {
                                                                        $weeks += $currentWeek
                                                                        $currentWeek = New-Object PsObject
                                                                    }
                                                                }
                                                            
                                                                ## Format the weeks as a table.
                                                                $calendar = $weeks | Format-Table $dayNames -AutoSize | Out-String
                                                            
                                                                ## Add a centered header.
                                                                $width = ($calendar.Split("`n") | Measure-Object -Maximum Length).Maximum
                                                                $header = "{0:MMMM yyyy}" -f $start
                                                                $padding = " " * (($width - $header.Length) / 2)
                                                                $displayCalendar = " `n" + $padding + $header + "`n " + $calendar
                                                                $displayCalendar.TrimEnd()
                                                            
                                                                ## Move to the next month.
                                                                $start = $start.AddMonths(1)
                                                            
                                                            }
                                                            }


                                                            function get-khaki15 {
                                                                param(
                                                                    [DateTime] $start = [DateTime]::Today,
                                                                    [DateTime] $end = $start,
                                                                    $firstDayOfWeek,
                                                                    [int[]] $highlightDay,
                                                                    [string[]] $highlightDate = [DateTime]::Today.ToString('yyyy-MM-dd')
                                                                    )
                                                                
                                                                ## Determine the first day of the start and end months.
                                                                $start = New-Object DateTime $start.Year,$start.Month,1
                                                                $end = New-Object DateTime $end.Year,$end.Month,1
                                                                
                                                                ## Convert the highlighted dates into real dates.
                                                                [DateTime[]] $highlightDate = [DateTime[]] $highlightDate
                                                                
                                                                ## Retrieve the DateTimeFormat information so that the
                                                                ## calendar can be manipulated.
                                                                $dateTimeFormat  = (Get-Culture).DateTimeFormat
                                                                if($firstDayOfWeek)
                                                                {
                                                                    $dateTimeFormat.FirstDayOfWeek = $firstDayOfWeek
                                                                }
                                                                
                                                                $currentDay = $start
                                                                
                                                                ## Process the requested months.
                                                                while($start -le $end)
                                                                {
                                                                    ## Return to an earlier point in the function if the first day of the month
                                                                    ## is in the middle of the week.
                                                                    while($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek)
                                                                    {
                                                                        $currentDay = $currentDay.AddDays(-1)
                                                                    }
                                                                
                                                                    ## Prepare to store information about this date range.
                                                                    $currentWeek = New-Object PsObject
                                                                    $dayNames = @()
                                                                    $weeks = @()
                                                                
                                                                    ## Continue processing dates until the function reaches the end of the month.
                                                                    ## The function continues until the week is completed with
                                                                    ## days from the next month.
                                                                    while(($currentDay -lt $start.AddMonths(1)) -or
                                                                        ($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek))
                                                                    {
                                                                        ## Determine the day names to use to label the columns.
                                                                        $dayName = "{0:ddd}" -f $currentDay
                                                                        if($dayNames -notcontains $dayName)
                                                                        {
                                                                            $dayNames += $dayName
                                                                        }
                                                                
                                                                        ## Pad the day number for display, highlighting if necessary.
                                                                        $displayDay = " {0,2} " -f $currentDay.Day
                                                                
                                                                        ## Determine whether to highlight a specific date.
                                                                        if($highlightDate)
                                                                        {
                                                                            $compareDate = New-Object DateTime $currentDay.Year,
                                                                                $currentDay.Month,$currentDay.Day
                                                                            if($highlightDate -contains $compareDate)
                                                                            {
                                                                                $displayDay = "*" + ("{0,2}" -f $currentDay.Day) + "*"
                                                                            }
                                                                        }
                                                                
                                                                        ## Otherwise, highlight as part of a date range.
                                                                        if($highlightDay -and ($highlightDay[0] -eq $currentDay.Day))
                                                                        {
                                                                            $displayDay = "[" + ("{0,2}" -f $currentDay.Day) + "]"
                                                                            $null,$highlightDay = $highlightDay
                                                                        }
                                                                
                                                                        ## Add the day of the week and the day of the month as note properties.
                                                                        $currentWeek | Add-Member NoteProperty $dayName $displayDay
                                                                
                                                                        ## Move to the next day of the month.
                                                                        $currentDay = $currentDay.AddDays(1)
                                                                
                                                                        ## If the function reaches the next week, store the current week
                                                                        ## in the week list and continue.
                                                                        if($currentDay.DayOfWeek -eq $dateTimeFormat.FirstDayOfWeek)
                                                                        {
                                                                            $weeks += $currentWeek
                                                                            $currentWeek = New-Object PsObject
                                                                        }
                                                                    }
                                                                
                                                                    ## Format the weeks as a table.
                                                                    $calendar = $weeks | Format-Table $dayNames -AutoSize | Out-String
                                                                
                                                                    ## Add a centered header.
                                                                    $width = ($calendar.Split("`n") | Measure-Object -Maximum Length).Maximum
                                                                    $header = "{0:MMMM yyyy}" -f $start
                                                                    $padding = " " * (($width - $header.Length) / 2)
                                                                    $displayCalendar = " `n" + $padding + $header + "`n " + $calendar
                                                                    $displayCalendar.TrimEnd()
                                                                
                                                                    ## Move to the next month.
                                                                    $start = $start.AddMonths(1)
                                                                
                                                                }
                                                                }


                                                                function get-khaki16 {
                                                                    param(
                                                                        [DateTime] $start = [DateTime]::Today,
                                                                        [DateTime] $end = $start,
                                                                        $firstDayOfWeek,
                                                                        [int[]] $highlightDay,
                                                                        [string[]] $highlightDate = [DateTime]::Today.ToString('yyyy-MM-dd')
                                                                        )
                                                                    
                                                                    ## Determine the first day of the start and end months.
                                                                    $start = New-Object DateTime $start.Year,$start.Month,1
                                                                    $end = New-Object DateTime $end.Year,$end.Month,1
                                                                    
                                                                    ## Convert the highlighted dates into real dates.
                                                                    [DateTime[]] $highlightDate = [DateTime[]] $highlightDate
                                                                    
                                                                    ## Retrieve the DateTimeFormat information so that the
                                                                    ## calendar can be manipulated.
                                                                    $dateTimeFormat  = (Get-Culture).DateTimeFormat
                                                                    if($firstDayOfWeek)
                                                                    {
                                                                        $dateTimeFormat.FirstDayOfWeek = $firstDayOfWeek
                                                                    }
                                                                    
                                                                    $currentDay = $start
                                                                    
                                                                    ## Process the requested months.
                                                                    while($start -le $end)
                                                                    {
                                                                        ## Return to an earlier point in the function if the first day of the month
                                                                        ## is in the middle of the week.
                                                                        while($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek)
                                                                        {
                                                                            $currentDay = $currentDay.AddDays(-1)
                                                                        }
                                                                    
                                                                        ## Prepare to store information about this date range.
                                                                        $currentWeek = New-Object PsObject
                                                                        $dayNames = @()
                                                                        $weeks = @()
                                                                    
                                                                        ## Continue processing dates until the function reaches the end of the month.
                                                                        ## The function continues until the week is completed with
                                                                        ## days from the next month.
                                                                        while(($currentDay -lt $start.AddMonths(1)) -or
                                                                            ($currentDay.DayOfWeek -ne $dateTimeFormat.FirstDayOfWeek))
                                                                        {
                                                                            ## Determine the day names to use to label the columns.
                                                                            $dayName = "{0:ddd}" -f $currentDay
                                                                            if($dayNames -notcontains $dayName)
                                                                            {
                                                                                $dayNames += $dayName
                                                                            }
                                                                    
                                                                            ## Pad the day number for display, highlighting if necessary.
                                                                            $displayDay = " {0,2} " -f $currentDay.Day
                                                                    
                                                                            ## Determine whether to highlight a specific date.
                                                                            if($highlightDate)
                                                                            {
                                                                                $compareDate = New-Object DateTime $currentDay.Year,
                                                                                    $currentDay.Month,$currentDay.Day
                                                                                if($highlightDate -contains $compareDate)
                                                                                {
                                                                                    $displayDay = "*" + ("{0,2}" -f $currentDay.Day) + "*"
                                                                                }
                                                                            }
                                                                    
                                                                            ## Otherwise, highlight as part of a date range.
                                                                            if($highlightDay -and ($highlightDay[0] -eq $currentDay.Day))
                                                                            {
                                                                                $displayDay = "[" + ("{0,2}" -f $currentDay.Day) + "]"
                                                                                $null,$highlightDay = $highlightDay
                                                                            }
                                                                    
                                                                            ## Add the day of the week and the day of the month as note properties.
                                                                            $currentWeek | Add-Member NoteProperty $dayName $displayDay
                                                                    
                                                                            ## Move to the next day of the month.
                                                                            $currentDay = $currentDay.AddDays(1)
                                                                    
                                                                            ## If the function reaches the next week, store the current week
                                                                            ## in the week list and continue.
                                                                            if($currentDay.DayOfWeek -eq $dateTimeFormat.FirstDayOfWeek)
                                                                            {
                                                                                $weeks += $currentWeek
                                                                                $currentWeek = New-Object PsObject
                                                                            }
                                                                        }
                                                                    
                                                                        ## Format the weeks as a table.
                                                                        $calendar = $weeks | Format-Table $dayNames -AutoSize | Out-String
                                                                    
                                                                        ## Add a centered header.
                                                                        $width = ($calendar.Split("`n") | Measure-Object -Maximum Length).Maximum
                                                                        $header = "{0:MMMM yyyy}" -f $start
                                                                        $padding = " " * (($width - $header.Length) / 2)
                                                                        $displayCalendar = " `n" + $padding + $header + "`n " + $calendar
                                                                        $displayCalendar.TrimEnd()
                                                                    
                                                                        ## Move to the next month.
                                                                        $start = $start.AddMonths(1)
                                                                    
                                                                    }
}

function FunctionName {
    param (
        
    )
    
    write-host "Getting Services...."
    Get-service

}
    
    Export-ModuleMember -Function *