A extends List ? number extends A ["length"] ? K extends number | template-literal ? A [never] | undefined : undefined : K extends keyof A ? A [K] : undefined : unknown extends A ? unknown : K extends keyof A ? A [K] : undefined

A1 extends A2 ? A1 : A2

string | number | symbol

L ["length"]

ReadonlyArray<A>

string | number | bigint | boolean

L extends readonly [ rest, any ] | readonly [ rest, optional ] ? LBody : L

S extends template-literal ? Replace<template-literal, R, W> : S

S extends template-literal ? __Split<AS, D, [ rest, BS ]> : [ rest, S ]

# At

src/string.ts#L10

AAt<Split<S, "">, K>

# Join – Concat many literals together

src/string.ts#L24

_Join<T, D> extends inferred ? Cast<X, string> : never

# Length

src/string.ts#L43

LLength<Split<S, "">>

# Replace

src/string.ts#L44

_Replace<S, R, W> extends inferred ? Cast<X, string> : never

# Split – Split S by D into a [[List]]

src/string.ts#L62

_Split<S, D> extends inferred ? Cast<X, string []> : never

# attributeChangedCallback(name, oldValue, newValue) – Callback that is invoked when one of the {@link withProperties} changes.
# name – Name of attribute

string

# oldValue – Old value

null | string

# newValue – New value

null | string

attributeChangedCallback(name, oldValue, newValue)  =>

void

In connectedCallback() you should setup tasks that should only occur when the element is connected to the document. The most common of these is adding event listeners to nodes external to the element, like a keydown event handler added to the window.

connectedCallback() {
  super.connectedCallback();
  this.addEventListener('keydown', this._handleKeydown);
}

Typically, anything done in connectedCallback() should be undone when the element is disconnected, in disconnectedCallback().

connectedCallback()  =>

void

This callback is the main signal to the element that it may no longer be used. disconnectedCallback() should ensure that nothing is holding a reference to the element (such as event listeners added to nodes external to the element), so that it is free to be garbage collected.

disconnectedCallback() {
  super.disconnectedCallback();
  window.removeEventListener('keydown', this._handleKeydown);
}

An element may be re-connected after being disconnected.

disconnectedCallback()  =>

void

# this

T

# event
E & {

# currentTarget

src/everyday-types.ts#L8

T

# target

src/everyday-types.ts#L8

Element

}

# get(v)
# v

K

get(v)  =>

T

# v

K

has(v)  =>

boolean

# get(v)
# v

K

get(v)  =>

T

# v

K

has(v)  =>

boolean

any

N extends N ? number extends N ? T [] : _Chunk<T, N, [ ]> : never

# (args)

src/everyday-types.ts#L5

# new()

T

# args

any []

# (args)

src/everyday-types.ts#L6

# new()

unknown

# args

any []

Class<CustomElement> & {}

Narrow<Parameters<Narrow<Get<T, K>, Fn<any, any>>> [0], CustomEvent> ["detail"]

keyof EventsOf<T>

[K in Keys<T> ]-?: Narrow<Parameters<Narrow<Get<T, K>, Fn<any, any>>> [0], Event>

# (args)
# args

T

(args)  =>

R

T [NarrowKey<K, T>]

number | string | symbol

keyof [K in keyof T ]: StringOf<K>

{} & Omit<T, "constructor">

[P in keyof T ]: T [P]

K extends T ? K : never

Narrow<K, keyof T>

[K in Keys<T> ]: T [K]

null | undefined | void

[K in T extends ReadonlyArray<inferred> ? U : never ]: V

template-literal

String.Split<StringOf<T>, " on">

StringOf<keyof T>

T extends string ? string extends T ? never : T : never

Narrow<T, string>

HTMLElement | SVGElement | Window | Document | ShadowRoot

StringConstructor | NumberConstructor | BooleanConstructor

T [keyof T]

R ["length"] extends N ? R : _Chunk<T, N, [ T, rest ]>