hanzio 1.1.0 → 2.0.0

package/src/string/index.ts

@@ -1,3 +1,5 @@
+import type { Result } from '../promise'
+
 export type JsonValue =
 	| string
 	| number
@@ -8,18 +10,44 @@ export type JsonValue =
 export type JsonObject = { [key: string]: JsonValue | undefined }
 export type JsonArray = Array<JsonValue | undefined>
 
+/**
+ * Parses the first number-like token in a string. Only a `-` directly before
+ * the digits is a sign, so `'2024-01-05'` gives `2024`. Whitespace and the
+ * separator that isn't `decimalSeparator` are treated as thousands separators:
+ * `'1,234.56'` gives `1234.56`, and `'1.234,56'` with `decimalSeparator: ','`
+ * gives `1234.56`.
+ */
 export function extractNumber(
-	value: string | null | undefined
+	value: string | null | undefined,
+	options: { decimalSeparator?: '.' | ',' } = {}
 ): number | undefined {
-	if (!value?.trim()) return undefined
-
-	const cleanedValue = value.replace(/[^\d.,-]/g, '')
-	if (!cleanedValue) return undefined
+	const { decimalSeparator = '.' } = options
+	const decimal = decimalSeparator === '.' ? '\\.' : ','
+	const thousands = decimalSeparator === '.' ? ',' : '\\.'
+	// First number-like token. A thousands separator (or whitespace) only counts
+	// when exactly three digits follow it, so '12,5' reads as 12, not 125.
+	const token = value?.match(
+		new RegExp(
+			`-?(?:\\d+(?:(?:${thousands}|\\s)\\d{3}(?!\\d))*(?:${decimal}\\d+)?|${decimal}\\d+)`
+		)
+	)?.[0]
+	if (!token) return undefined
 
-	const parsedNumber = Number.parseFloat(cleanedValue)
+	const parsedNumber = Number.parseFloat(
+		token
+			.replace(/\s/g, '')
+			.replaceAll(decimalSeparator === '.' ? ',' : '.', '')
+			.replace(decimalSeparator, '.')
+	)
 	return Number.isNaN(parsedNumber) ? undefined : parsedNumber
 }
 
+/**
+ * A stable, short, non-cryptographic hash key (32-bit, 8 hex chars) for
+ * JSON-like input. Object key order and query-string parameter order don't
+ * matter. Collisions become likely above ~10k distinct inputs; use `sha256Id`
+ * where that matters.
+ */
 export function generateId(input: JsonValue | undefined): string {
 	const data = normalizeIdInput(input)
 	let hash = 0
@@ -33,32 +61,234 @@ export function generateId(input: JsonValue | undefined): string {
 	return Math.abs(hash).toString(16).padStart(8, '0')
 }
 
-export function slugify(value: string): string {
-	const source =
-		'àáâäæãåāăąçćčđďèéêëēėęěğǵḧîïíīįìłḿñńǹňôöòóœøōõṕŕřßśšşșťțûüùúūǘůűųẃẍÿýžźż·/_,:;'
-	const replacement =
-		'aaaaaaaaaacccddeeeeeeeegghiiiiiilmnnnnooooooooprrsssssttuuuuuuuuuwxyyzzz------'
-	const specialCharacterPattern = new RegExp(source.split('').join('|'), 'g')
+/** Like `generateId`, but a SHA-256 hex digest truncated to `length` chars. */
+export async function sha256Id(
+	input: JsonValue | undefined,
+	length = 16
+): Promise<string> {
+	const digest = await crypto.subtle.digest(
+		'SHA-256',
+		new TextEncoder().encode(normalizeIdInput(input))
+	)
+	return Array.from(new Uint8Array(digest), (byte) =>
+		byte.toString(16).padStart(2, '0')
+	)
+		.join('')
+		.slice(0, length)
+}
+
+// Letters that NFKD doesn't split into a base letter plus a combining mark.
+const UNDECOMPOSED_LETTERS: Record<string, string> = {
+	æ: 'ae',
+	Æ: 'AE',
+	ø: 'o',
+	Ø: 'O',
+	œ: 'oe',
+	Œ: 'OE',
+	ß: 'ss',
+	ẞ: 'SS',
+	đ: 'd',
+	Đ: 'D',
+	ł: 'l',
+	Ł: 'L',
+	þ: 'th',
+	Þ: 'TH',
+	ð: 'd',
+	Ð: 'D'
+}
 
+/** Removes accents and spells out letters like `æ`, `ø` and `ß` in ASCII. */
+function stripAccents(value: string): string {
 	return value
-		.toString()
-		.toLowerCase()
-		.replace(/\s+/g, '-')
-		.replace(specialCharacterPattern, (character) =>
-			replacement.charAt(source.indexOf(character))
+		.normalize('NFKD')
+		.replace(/\p{M}/gu, '')
+		.replace(
+			/[æøœßđłþðÆØŒẞĐŁÞÐ]/g,
+			(letter) => UNDECOMPOSED_LETTERS[letter] ?? ''
 		)
-		.replace(/&/g, '-and-')
-		.replace(/[^\w-]+/g, '')
-		.replace(/--+/g, '-')
-		.replace(/^-+/, '')
-		.replace(/-+$/, '')
+}
+
+export type SlugifyOptions = {
+	/** Placed between words (default `'-'`). */
+	separator?: string
+	/** Default `true`. */
+	lowercase?: boolean
+	/** Cuts the slug to at most this many characters, without a trailing separator. */
+	maxLength?: number
+}
+
+/**
+ * Turns text into a URL slug: strips accents, turns `&` into `and`, splits
+ * words on whitespace and `-_/,:;·`, and drops every other non-ASCII-alphanumeric
+ * character.
+ */
+export function slugify(value: string, options: SlugifyOptions = {}): string {
+	const { separator = '-', lowercase = true, maxLength } = options
+	const slug = stripAccents(value)
+		.replace(/&/g, ' and ')
+		.replace(/[\s\-_/,:;·]+/g, ' ')
+		.replace(/[^a-zA-Z0-9 ]/g, '')
+		.trim()
+		.split(/ +/)
+		.join(separator)
+	const cased = lowercase ? slug.toLowerCase() : slug
+
+	if (maxLength === undefined || cased.length <= maxLength) return cased
+	// Words are alphanumeric, so anything non-alphanumeric at the end is
+	// (part of) a separator.
+	return cased.slice(0, maxLength).replace(/[^a-zA-Z0-9]+$/, '')
+}
+
+/**
+ * JSON.stringify with sorted object keys, so `{ a, b }` and `{ b, a }` produce
+ * the same string. Also encodes values JSON drops or rejects: `bigint`,
+ * `Map` and `Set`. Use it for cache and dedupe keys.
+ */
+export function stableStringify(value: unknown): string {
+	return (
+		JSON.stringify(value, (_key, item: unknown) => {
+			if (typeof item === 'bigint') return `${item}n`
+			if (item instanceof Map) return { $map: [...item.entries()] }
+			if (item instanceof Set) return { $set: [...item] }
+			if (item && typeof item === 'object' && !Array.isArray(item)) {
+				const record = item as Record<string, unknown>
+				return Object.fromEntries(
+					Object.keys(record)
+						.sort()
+						.map((key) => [key, record[key]])
+				)
+			}
+			return item
+		}) ?? 'undefined'
+	)
+}
+
+/**
+ * Cuts text to at most `maxLength` user-visible characters, ellipsis included.
+ * Never splits an emoji or accented letter, and drops whitespace before the
+ * ellipsis. With `wordBoundary`, cuts at the last space unless that would leave
+ * nothing.
+ */
+export function truncate(
+	text: string,
+	maxLength: number,
+	options: { ellipsis?: string; wordBoundary?: boolean } = {}
+): string {
+	const { ellipsis = '…', wordBoundary = false } = options
+	const characters = graphemes(text)
+	if (characters.length <= maxLength) return text
+
+	const ellipsisCharacters = graphemes(ellipsis)
+	const room = maxLength - ellipsisCharacters.length
+	if (room <= 0) return ellipsisCharacters.slice(0, maxLength).join('')
+
+	let cut = characters.slice(0, room).join('')
+	if (wordBoundary && !/^\s/.test(characters[room] ?? '')) {
+		const lastSpace = cut.search(/\s\S*$/)
+		if (lastSpace > 0) cut = cut.slice(0, lastSpace)
+	}
+	return cut.trimEnd() + ellipsis
+}
+
+/** Collapses every whitespace run (NBSP and newlines included) to one space and trims. */
+export function normalizeWhitespace(text: string): string {
+	return text.replace(/\s+/g, ' ').trim()
+}
+
+/**
+ * Escapes text for literal use in a `RegExp`. `-` becomes `\x2d` so the result
+ * is also valid with the `u` and `v` flags.
+ */
+export function escapeRegExp(text: string): string {
+	return text.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&').replace(/-/g, '\\x2d')
+}
+
+/** Lowercases and strips accents, so `'Ærø Café'` becomes `'aero cafe'`. */
+export function foldForSearch(text: string): string {
+	return stripAccents(text).toLowerCase()
+}
+
+/**
+ * True when every whitespace-separated query term appears in at least one
+ * field, ignoring case and accents. An empty query matches everything.
+ */
+export function matchesSearch(
+	query: string,
+	...fields: (string | null | undefined)[]
+): boolean {
+	const haystack = foldForSearch(fields.filter(Boolean).join('\n'))
+	return foldForSearch(query)
+		.split(/\s+/)
+		.every((term) => haystack.includes(term))
+}
+
+const HAS_LETTER = /\p{L}/u
+
+/**
+ * Up to `max` (default 2) uppercase letters for an avatar, or `''` when the
+ * value has no letters (phone numbers, `'—'`). One word gives its first
+ * letters (`'Ada'` → `'AD'`), several give first and last (`'Hans Kristoffer
+ * Hansen'` → `'HH'`). An email is read as its local part without the `+tag`:
+ * `'ada.lovelace+news@x.com'` → `'AL'`.
+ */
+export function initials(
+	name: string | null | undefined,
+	options: { max?: number } = {}
+): string {
+	const { max = 2 } = options
+	const trimmed = name?.trim() ?? ''
+	const source = /^[^\s@]+@[^\s@]+$/.test(trimmed)
+		? (trimmed.split('@')[0] ?? '').replace(/\+.*$/, '').replace(/[._-]+/g, ' ')
+		: trimmed
+	const words = source.split(/\s+/).filter((word) => HAS_LETTER.test(word))
+	const first = words[0]
+	if (!first) return ''
+	if (words.length === 1) return fromFirstLetter(first, max).toUpperCase()
+
+	// Keep the last word (the surname) when there are more words than letters.
+	const head = words.slice(0, Math.max(1, max - 1))
+	const picked =
+		words.length > max ? [...head, words.at(-1) ?? first].slice(0, max) : words
+	return picked
+		.map((word) => fromFirstLetter(word, 1))
+		.join('')
+		.toUpperCase()
+}
+
+/** `JSON.parse` that returns a `Result` instead of throwing. */
+export function safeJsonParse<T = unknown>(
+	text: string
+): Result<T, SyntaxError> {
+	try {
+		return { ok: true, data: JSON.parse(text) as T, error: null }
+	} catch (error) {
+		return { ok: false, data: null, error: error as SyntaxError }
+	}
+}
+
+// `count` characters from the word's first letter, so brackets around a name
+// are skipped but digits after it are kept (`'R2D2'` → `'R2'`).
+function fromFirstLetter(word: string, count: number): string {
+	const characters = graphemes(word)
+	const start = characters.findIndex((character) => HAS_LETTER.test(character))
+	if (start === -1) return ''
+	return characters.slice(start, start + count).join('')
+}
+
+let segmenter: Intl.Segmenter | undefined
+
+// Grapheme clusters when `Intl.Segmenter` exists, otherwise code points.
+function graphemes(text: string): string[] {
+	if (typeof Intl === 'undefined' || !('Segmenter' in Intl)) return [...text]
+	segmenter ??= new Intl.Segmenter()
+	return Array.from(segmenter.segment(text), ({ segment }) => segment)
 }
 
 function normalizeIdInput(input: JsonValue | undefined): string {
 	if (input === undefined) return 'undefined'
 	if (input === null) return 'null'
 	if (typeof input === 'string') {
-		return decodeURIComponent(input).split('&').sort().join('&')
+		return safeDecodeURIComponent(input).split('&').sort().join('&')
 	}
 	if (typeof input === 'number' || typeof input === 'boolean') {
 		return input.toString()
@@ -84,3 +314,11 @@ function sortJsonValue(value: JsonValue | undefined): JsonValue | null {
 
 	return value
 }
+
+function safeDecodeURIComponent(value: string): string {
+	try {
+		return decodeURIComponent(value)
+	} catch {
+		return value
+	}
+}

package/src/typedswitch/index.ts

@@ -74,15 +74,27 @@ type RawHandlerReturnType<T> = T extends (...args: any[]) => infer R ? R : never
 
 /** Get union of all raw return types from a cases object's values */
 type RawCasesReturnType<Cases> = {
-	[K in keyof Cases]: Cases[K] extends undefined
+	[K in keyof Cases]: RawHandlerReturnType<Cases[K]>
+}[keyof Cases]
+
+/** Only required, defined handlers guarantee that a case is handled. */
+type HandledCaseKeys<Cases> = {
+	// biome-ignore lint/complexity/noBannedTypes: Empty-object assignability detects optional keys and index signatures.
+	[K in keyof Cases]-?: {} extends Pick<Cases, K>
 		? never
-		: RawHandlerReturnType<Cases[K]>
+		: undefined extends Cases[K]
+			? never
+			: K
 }[keyof Cases]
 
 // ═══════════════════════════════════════════════════════════════════════════
 // String input mode types
 // ═══════════════════════════════════════════════════════════════════════════
 
+// The exported case-map types below are annotation helpers for consumers who
+// want to type reusable case maps. The typedSwitch overloads infer their own
+// shapes and do not depend on these types.
+
 /** Cases for string input - all cases required */
 export type StringSwitchCases<T extends string, R> = {
 	[K in T]: (value: K) => R | Promise<R>
@@ -97,88 +109,45 @@ export type PartialStringSwitchCases<T extends string, R> = {
 // Object input mode types
 // ═══════════════════════════════════════════════════════════════════════════
 
-/** Cases for object input with custom key - all cases required */
-export type ObjectSwitchCases<T, K extends keyof T, R> = T[K] extends string
-	? {
-			[V in T[K]]: (value: Extract<T, Record<K, V>>) => R | Promise<R>
-		}
+/** Discriminant values supported in object mode. Cases are keyed by `${value}`. */
+type Discriminant = string | number | boolean
+
+/** Discriminant values of `V` whose case key (`${value}`) is in `Keys` */
+type ValuesForKeys<V, Keys> = V extends Discriminant
+	? `${V}` extends `${Keys & (string | number)}`
+		? V
+		: never
 	: never
 
+type ObjectCases<T, K extends keyof T, R> = {
+	[V in Extract<T[K], Discriminant> as `${V}`]: (
+		value: Extract<T, Record<K, V>>
+	) => R
+}
+
+type PartialObjectCases<T, K extends keyof T, R> = {
+	[V in Extract<T[K], Discriminant> as `${V}`]?: (
+		value: Extract<T, Record<K, V>>
+	) => R
+}
+
+/** Cases for object input with custom key - all cases required */
+export type ObjectSwitchCases<
+	T,
+	K extends keyof T,
+	R
+> = T[K] extends Discriminant ? ObjectCases<T, K, R | Promise<R>> : never
+
 /** Partial cases for object input with custom key (when default is provided) */
 export type PartialObjectSwitchCases<
 	T,
 	K extends keyof T,
 	R
-> = T[K] extends string
-	? {
-			[V in T[K]]?: (value: Extract<T, Record<K, V>>) => R | Promise<R>
-		}
-	: never
+> = T[K] extends Discriminant ? PartialObjectCases<T, K, R | Promise<R>> : never
 
 type Handler = (value: unknown) => unknown
 type CasesRecord = Record<string, Handler | undefined>
 
-function runSwitch(
-	value: string | Record<string, unknown>,
-	keyOrCases: string | CasesRecord,
-	casesOrDefault?: CasesRecord | Handler,
-	defaultCase?: Handler
-): unknown {
-	let key: string
-	let cases: CasesRecord
-	let defaultHandler: Handler | undefined
-	let discriminantKey: string | undefined
-
-	if (typeof value === 'string') {
-		// String input: typedSwitch(string, cases, default?)
-		key = value
-		cases = keyOrCases as CasesRecord
-		defaultHandler = casesOrDefault as Handler | undefined
-	} else {
-		// Object input: typedSwitch(obj, key, cases, default?)
-		if (typeof keyOrCases !== 'string') {
-			throw new Error(
-				'Invalid typedSwitch call: object mode requires a string discriminant key'
-			)
-		}
-
-		discriminantKey = keyOrCases
-		const discriminantValue = value[discriminantKey]
-		if (typeof discriminantValue !== 'string') {
-			throw new Error(
-				`Invalid discriminant value for key "${discriminantKey}": expected string, received ${typeof discriminantValue}`
-			)
-		}
-
-		key = discriminantValue
-		cases = casesOrDefault as CasesRecord
-		defaultHandler = defaultCase
-	}
-
-	const handler = cases[key]
-
-	if (handler) {
-		return handler(value)
-	}
-
-	if (defaultHandler) {
-		return defaultHandler(value)
-	}
-
-	const availableCases = Object.keys(cases).join(', ')
-	const availableCasesSuffix =
-		availableCases.length > 0
-			? ` Available cases: ${availableCases}`
-			: ' Available cases: (none)'
-	const contextSuffix = discriminantKey
-		? ` (discriminant key: "${discriminantKey}")`
-		: ''
-
-	throw new Error(
-		`Unhandled case: ${key}${contextSuffix}.${availableCasesSuffix}`
-	)
-}
-
 // ═══════════════════════════════════════════════════════════════════════════
 // Function overloads
 // ═══════════════════════════════════════════════════════════════════════════
@@ -190,10 +159,11 @@ export function typedSwitch<
 >(value: T, cases: Cases): RawCasesReturnType<Cases>
 
 // String input - partial cases allowed (with default)
+// The default handler only receives the cases not covered by `cases`.
 export function typedSwitch<
 	T extends string,
 	Cases extends { [K in T]?: (value: K) => unknown },
-	DefaultCase extends (value: T) => unknown
+	DefaultCase extends (value: Exclude<T, HandledCaseKeys<Cases>>) => unknown
 >(
 	value: T,
 	cases: Cases,
@@ -202,19 +172,20 @@ export function typedSwitch<
 
 // Object input with key - all cases required (no default)
 export function typedSwitch<
-	T extends Record<string, unknown>,
+	T extends object,
 	K extends keyof T,
-	TKey extends T[K] & string,
-	Cases extends { [V in TKey]: (value: Extract<T, Record<K, V>>) => unknown }
+	Cases extends ObjectCases<T, K, unknown>
 >(value: T, key: K, cases: Cases): RawCasesReturnType<Cases>
 
 // Object input with key - partial cases allowed (with default)
+// The default handler only receives the union members not covered by `cases`.
 export function typedSwitch<
-	T extends Record<string, unknown>,
+	T extends object,
 	K extends keyof T,
-	TKey extends T[K] & string,
-	Cases extends { [V in TKey]?: (value: Extract<T, Record<K, V>>) => unknown },
-	DefaultCase extends (value: T) => unknown
+	Cases extends PartialObjectCases<T, K, unknown>,
+	DefaultCase extends (
+		value: Exclude<T, Record<K, ValuesForKeys<T[K], HandledCaseKeys<Cases>>>>
+	) => unknown
 >(
 	value: T,
 	key: K,
@@ -249,13 +220,7 @@ export function typedSwitch<
 	Constraint,
 	T extends Record<string, unknown> = Record<string, unknown>,
 	K extends keyof T = keyof T
->(
-	value: T,
-	key: K,
-	cases: {
-		[V in T[K] & string]: (value: Extract<T, Record<K, V>>) => Constraint
-	}
-): Constraint
+>(value: T, key: K, cases: ObjectCases<T, K, Constraint>): Constraint
 export function typedSwitch<
 	Constraint,
 	T extends Record<string, unknown> = Record<string, unknown>,
@@ -263,11 +228,7 @@ export function typedSwitch<
 >(
 	value: T,
 	key: K,
-	cases: {
-		[V in T[K] & string]: (
-			value: Extract<T, Record<K, V>>
-		) => Constraint | Promise<Constraint>
-	}
+	cases: ObjectCases<T, K, Constraint | Promise<Constraint>>
 ): Constraint | Promise<Constraint>
 
 // Object input with key - partial cases allowed with return constraint (with default)
@@ -278,9 +239,7 @@ export function typedSwitch<
 >(
 	value: T,
 	key: K,
-	cases: {
-		[V in T[K] & string]?: (value: Extract<T, Record<K, V>>) => Constraint
-	},
+	cases: PartialObjectCases<T, K, Constraint>,
 	defaultCase: (value: T) => Constraint
 ): Constraint
 export function typedSwitch<
@@ -290,20 +249,92 @@ export function typedSwitch<
 >(
 	value: T,
 	key: K,
-	cases: {
-		[V in T[K] & string]?: (
-			value: Extract<T, Record<K, V>>
-		) => Constraint | Promise<Constraint>
-	},
+	cases: PartialObjectCases<T, K, Constraint | Promise<Constraint>>,
 	defaultCase: (value: T) => Constraint | Promise<Constraint>
 ): Constraint | Promise<Constraint>
 
 // Implementation
 export function typedSwitch(
-	value: string | Record<string, unknown>,
+	value: string | object,
 	keyOrCases: string | CasesRecord,
 	casesOrDefault?: CasesRecord | Handler,
 	defaultCase?: Handler
 ): unknown {
-	return runSwitch(value, keyOrCases, casesOrDefault, defaultCase)
+	let key: string
+	let cases: CasesRecord
+	let defaultHandler: Handler | undefined
+	let discriminantKey: string | undefined
+
+	if (typeof value === 'string') {
+		// String input: typedSwitch(string, cases, default?)
+		key = value
+		cases = keyOrCases as CasesRecord
+		defaultHandler = casesOrDefault as Handler | undefined
+	} else {
+		// Object input: typedSwitch(obj, key, cases, default?)
+		if (typeof keyOrCases !== 'string') {
+			throw new Error(
+				'Invalid typedSwitch call: object mode requires a string discriminant key'
+			)
+		}
+
+		discriminantKey = keyOrCases
+		const discriminantValue = (value as Record<string, unknown>)[
+			discriminantKey
+		]
+		if (
+			typeof discriminantValue !== 'string' &&
+			typeof discriminantValue !== 'number' &&
+			typeof discriminantValue !== 'boolean'
+		) {
+			throw new Error(
+				`Invalid discriminant value for key "${discriminantKey}": expected string, number or boolean, received ${typeof discriminantValue}`
+			)
+		}
+
+		key = String(discriminantValue)
+		cases = casesOrDefault as CasesRecord
+		defaultHandler = defaultCase
+	}
+
+	// Only own properties count as cases - a key like 'toString' must not
+	// resolve to an inherited Object.prototype method.
+	const handler = Object.hasOwn(cases, key) ? cases[key] : undefined
+
+	if (handler) {
+		return handler(value)
+	}
+
+	if (defaultHandler) {
+		return defaultHandler(value)
+	}
+
+	const availableCases = Object.keys(cases).join(', ')
+	const availableCasesSuffix =
+		availableCases.length > 0
+			? ` Available cases: ${availableCases}`
+			: ' Available cases: (none)'
+	const contextSuffix = discriminantKey
+		? ` (discriminant key: "${discriminantKey}")`
+		: ''
+
+	throw new Error(
+		`Unhandled case: ${key}${contextSuffix}.${availableCasesSuffix}`
+	)
+}
+
+/**
+ * Exhaustiveness helper for regular `switch` statements. Place it in the
+ * `default` branch: it only type-checks when every case has been handled, and
+ * throws if an unexpected value reaches it at runtime.
+ *
+ * @example
+ * switch (status) {
+ *   case 'success': return 1
+ *   case 'error': return 0
+ *   default: return assertNever(status)
+ * }
+ */
+export function assertNever(value: never, message?: string): never {
+	throw new Error(message ?? `Unexpected value: ${String(value)}`)
 }

package/src/types/index.ts

@@ -0,0 +1,14 @@
+export type MaybePromise<T> = T | Promise<T>
+
+/** Union of an object type's values. */
+export type ValueOf<T> = T[keyof T]
+
+/** Union of an array or tuple's element types. */
+export type ElementOf<T extends readonly unknown[]> = T[number]
+
+export type NonEmptyArray<T> = [T, ...T[]]
+
+/** Flattens intersections into one object type so hovers stay readable. */
+export type Simplify<T> = { [K in keyof T]: T[K] } & {}
+
+export type Nullable<T> = T | null | undefined