memoize((a: Date|number) => memoize((b: Date|number) => memoize((local: boolean) : boolean => {
		if (typeof a === 'number') {
			if (isNaN(a)) {
				return false;
			}

			a	= timestampToDate(a);
		}
		if (typeof b === 'number') {
			if (isNaN(b)) {
				return false;
			}

			b	= timestampToDate(b);
		}

		return local ? (
			a.getFullYear() === b.getFullYear() &&
			a.getMonth() === b.getMonth() &&
			a.getDate() === b.getDate()
		) : (
			a.getUTCFullYear() === b.getUTCFullYear() &&
			a.getUTCMonth() === b.getUTCMonth() &&
			a.getUTCDate() === b.getUTCDate()
		);
	})))

	memoize((date: number|Date) =>
		memoize((noToday: boolean) : string|undefined => {
			date	= timestampToDate(date);

			return compareDates(date, now, true) ?
				noToday ? undefined : strings.today :
			compareDates(date, now - 86400000, true) ?
				strings.yesterday :
			date.getFullYear() === timestampToDate(now).getFullYear() ?
				`${
					date.toLocaleDateString(undefined, {weekday: 'long'})
				}, ${
					date.toLocaleDateString(undefined, {month: 'long'})
				} ${
					getOrdinal(date.getDate())
				}` :
				`${
					date.toLocaleDateString(undefined, {month: 'long'})
				} ${
					getOrdinal(date.getDate())
				}, ${
					date.getFullYear()
				}`
			;
		})

						memoize((startPadding: number) =>
							memoize((endPadding: number) =>
								getTimesInternal(
									{
										end: {hour: endHour, minute: endMinute},
										start: {hour: startHour, minute: startMinute}
									},
									increment,
									startPadding,
									endPadding
								)
							)

		memoize((now?: Date|number) =>
			memoize((startTime?: Date|number) : number => {
				if (
					(typeof now !== 'number' && !(now instanceof Date)) ||
					(typeof startTime !== 'number' && !(startTime instanceof Date)) ||
					!compareDates(now, startTime)
				) {
					return 0;
				}

				if (typeof now === 'number') {
					now	= timestampToDate(now);
				}

				return (
					(now.getMinutes() + (now.getHours() * 60)) -
					(timeRange.start.minute + (timeRange.start.hour * 60))
				);
			})

	memoize((noZero: boolean) =>
		memoize((timestamp?: number) : Date =>
			timestamp === undefined || isNaN(timestamp) || (noZero && timestamp === 0) ?
				new Date() :
				new Date(timestamp)
		)

import {SecurityContext} from '@angular/core';
import {SafeStyle, SafeUrl} from '@angular/platform-browser';
import memoize from 'lodash-es/memoize';
import {MaybePromise} from '../maybe-promise-type';
import {staticDomSanitizer} from './static-services';


/** Converts a URL into a `url()` SafeStyle. */
/* tslint:disable-next-line:no-null-keyword */
export const urlToSafeStyle	=
	memoize(async (url: MaybePromise<string|SafeUrl|null|undefined>) : Promise<SafeStyle> => {
		const domSanitizer	= await staticDomSanitizer;

		const urlValue	= await url;
		const urlString	= typeof urlValue === 'string' || !urlValue ?
			urlValue :
			domSanitizer.sanitize(SecurityContext.URL, urlValue)
		;

		return domSanitizer.bypassSecurityTrustStyle(urlString ? `url(${urlString})` : '');
	})
;

import {FormControl} from '@angular/forms';
import memoize from 'lodash-es/memoize';
import {combineLatest, concat, of} from 'rxjs';
import {map} from 'rxjs/operators';
import {safeStringCompare} from './compare';


/** Creates a form control that has to match a specified value. */
export const formControlMatch	= (o: {value: string}, initialValue: string = '') =>
	new FormControl(initialValue, [control =>
		!safeStringCompare(control.value, o.value) ?
			{mismatch: true} :
			/* tslint:disable-next-line:no-null-keyword */
			null
	])
;

/** Observes a form control. */
export const watchFormControl	= memoize((control: FormControl) => concat(
	of(control),
	combineLatest(
		control.statusChanges,
		control.valueChanges
	).pipe(
		map(() => control)
	)
));

import memoize from 'lodash-es/memoize';
import {translate} from './translate';


/** Converts variable name into human-friendly title-style text. */
export const titleize	= memoize((s: string) => translate(
	s.
		replace(/^([a-z])/g, c => c.toUpperCase()).
		replace(/([A-Z])/g, ' $1').
		replace(/ And /g, ' & ').
		trim()
));