aptechka 0.26.1 → 0.26.2

package/lib/loading/index.d.ts

@@ -0,0 +1,23 @@
+export interface LoadingEvents {
+    loadingProgress: CustomEvent<{
+        total: number;
+        loaded: number;
+        progress: number;
+    }>;
+    loadingStart: CustomEvent<{}>;
+    loadingComplete: CustomEvent<{
+        total: number;
+    }>;
+}
+declare class Loading {
+    #private;
+    add(resourceName: string): void;
+    complete(resourceName: string): void;
+    error(resourceName: string): void;
+}
+export declare const loading: Loading;
+declare global {
+    interface WindowEventMap extends LoadingEvents {
+    }
+}
+export {};

package/lib/media/index.d.ts

@@ -0,0 +1,12 @@
+import { Store } from '../store/vanilla';
+
+export type MediaCallback = () => void;
+export type MediaQueries<T extends string = string> = Map<T, {
+    match: MediaCallback;
+    unmatch?: MediaCallback;
+}>;
+export declare class Media extends Store<boolean> {
+    #private;
+    constructor(query: string);
+    close(): void;
+}

package/lib/media-elements/image/index.d.ts

@@ -0,0 +1,11 @@
+import { SourceElement } from '../source';
+
+export declare class ImageElement extends SourceElement<HTMLImageElement> {
+    protected createConsumer(): HTMLImageElement;
+    protected consumeSource(url: string | null): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-image': ImageElement;
+    }
+}

package/lib/media-elements/index.d.ts

@@ -0,0 +1,4 @@
+export { ImageElement } from './image';
+export { SequenceElement, type SequenceElementParameters } from './sequence';
+export { SourceElement, type SourceEvents } from './source';
+export { VideoElement, type VideoEvents } from './video';

package/lib/media-elements/sequence/index.d.ts

@@ -0,0 +1,22 @@
+import { SourceManagerSourceSet } from '../../source';
+import { CanvasElement } from '../../canvas';
+import { SourceElement } from '../source';
+
+export interface SequenceElementParameters {
+    srcset: SourceManagerSourceSet;
+    pad?: number;
+}
+export declare class SequenceElement extends SourceElement<CanvasElement> {
+    #private;
+    constructor(parameters?: SequenceElementParameters);
+    setProgress(value: number): void;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+    protected createConsumer(): CanvasElement;
+    protected consumeSource(url: string | null): Promise<void>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-sequence': SequenceElement;
+    }
+}

package/lib/media-elements/source/index.d.ts

@@ -0,0 +1,27 @@
+import { SourceManager } from '../../source';
+import { ClassLinkedStatus } from '../../class-linked-status';
+
+export interface SourceEvents {
+    sourceCapture: CustomEvent;
+    sourceRelease: CustomEvent;
+}
+export declare abstract class SourceElement<T extends HTMLElement> extends HTMLElement {
+    #private;
+    constructor();
+    get consumerElement(): T;
+    get sourceManager(): SourceManager;
+    get status(): ClassLinkedStatus<{
+        loading: false;
+        loaded: false;
+        error: false;
+    }>;
+    get isLazy(): boolean;
+    protected abstract createConsumer(): T;
+    protected abstract consumeSource(url: string | null): void;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementEventMap extends SourceEvents {
+    }
+}

package/lib/media-elements/video/index.d.ts

@@ -0,0 +1,22 @@
+import { SourceElement } from '../source';
+
+export interface VideoEvents {
+    videoReadyStateChange: CustomEvent<{
+        readyState: number;
+        progress: number;
+    }>;
+}
+export declare class VideoElement extends SourceElement<HTMLVideoElement> {
+    #private;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+    protected createConsumer(): HTMLVideoElement;
+    protected consumeSource(url: string | null): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-video': VideoElement;
+    }
+    interface HTMLElementEventMap extends VideoEvents {
+    }
+}

package/lib/morph/Link.d.ts

@@ -0,0 +1,7 @@
+import { Morph } from './Morph';
+
+export declare class Link {
+    #private;
+    constructor(element: HTMLAnchorElement, morph: Morph);
+    destroy(): void;
+}

package/lib/morph/Morph.d.ts

@@ -0,0 +1,37 @@
+import { ChangeHistoryAction } from '../utils';
+import { Link } from './Link';
+
+export interface MorphParameters {
+    base?: string;
+    waitForHeadToLoad?: boolean;
+    cachePages?: boolean;
+}
+export interface MorphNavigationEntry {
+    pathname: string;
+    isCached: boolean;
+}
+export interface MorphPreprocessorEntry extends MorphNavigationEntry {
+    resolve: () => void;
+    reject: () => void;
+}
+export type MorphPreprocessor = (entry: MorphPreprocessorEntry) => void;
+export type MorphNavigationCallback = (entry: MorphNavigationEntry) => void;
+export type MorphPostprocessor = MorphNavigationCallback;
+export declare class Morph {
+    #private;
+    preprocessor?: MorphPreprocessor;
+    postprocessor?: MorphPostprocessor;
+    constructor(parameters?: MorphParameters);
+    get currentPathname(): string;
+    get links(): Link[];
+    normalizePath(path: string): {
+        leaf: string;
+        pathname: string;
+        parameters: string;
+        hash: string;
+    };
+    beforeNavigationEvent(callback: MorphNavigationCallback): () => void;
+    afterNavigationEvent(callback: MorphNavigationCallback): () => void;
+    prefetch(path: string): Promise<Document>;
+    navigate(path: string, historyAction?: ChangeHistoryAction): Promise<void>;
+}

package/lib/morph/index.d.ts

@@ -0,0 +1 @@
+export { Morph, type MorphPostprocessor, type MorphNavigationCallback, type MorphPreprocessor, type MorphPreprocessorEntry, type MorphNavigationEntry, type MorphParameters, } from './Morph';

package/lib/need_redo_tweaker/CheckboxElement.d.ts

@@ -0,0 +1,14 @@
+export declare class CheckboxElement extends HTMLElement {
+    #private;
+    static formAssociated: boolean;
+    constructor();
+    get checked(): boolean;
+    set checked(state: boolean);
+    get value(): string;
+    set value(value: string);
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-checkbox': CheckboxElement;
+    }
+}

package/lib/need_redo_tweaker/TweakerBooleanManagerElement.d.ts

@@ -0,0 +1,11 @@
+import { Store } from '../store/vanilla';
+import { TweakerStoreManagerElement } from './TweakerStoreManagerElement';
+
+export declare class TweakerBooleanManagerElement extends TweakerStoreManagerElement<Store<boolean>> {
+    constructor(...stores: Array<Store<boolean>>);
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-tweaker-boolean-manager': TweakerBooleanManagerElement;
+    }
+}

package/lib/need_redo_tweaker/TweakerColorManagerElement.d.ts

@@ -0,0 +1,11 @@
+import { Store } from '../store/vanilla';
+import { TweakerStoreManagerElement } from './TweakerStoreManagerElement';
+
+export declare class TweakerColorManagerElement extends TweakerStoreManagerElement<Store<string>> {
+    constructor(...stores: Array<Store<string>>);
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-tweaker-color-manager': TweakerColorManagerElement;
+    }
+}

package/lib/need_redo_tweaker/TweakerElement.d.ts

@@ -0,0 +1,18 @@
+import { Store } from '../store/vanilla';
+import { TweakerFolderElement } from './TweakerFolderElement';
+
+export interface StoreBox {
+    store: Store;
+    remainingFolders: Array<string>;
+}
+export declare class TweakerElement extends TweakerFolderElement {
+    #private;
+    constructor();
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-tweaker': TweakerElement;
+    }
+}

package/lib/need_redo_tweaker/TweakerFieldElement.d.ts

@@ -0,0 +1,20 @@
+import { Store } from '../store/vanilla';
+
+export interface TweakerFieldParameters {
+    store: Store<any>;
+}
+export declare class TweakerFieldElement extends HTMLElement {
+    #private;
+    constructor(parameters: TweakerFieldParameters);
+    get key(): string;
+    get name(): string;
+    get stores(): Store<any>[];
+    addStore(store: Store<any>): void;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-tweaker-field': TweakerFieldElement;
+    }
+}

package/lib/need_redo_tweaker/TweakerFolderElement.d.ts

@@ -0,0 +1,24 @@
+import { Store } from '../store/vanilla';
+import { TweakerFieldElement } from './TweakerFieldElement';
+import { StoreBox } from './TweakerElement';
+
+export interface TweakerFolderParameters {
+    key: string;
+    storeBox?: StoreBox;
+}
+export declare class TweakerFolderElement extends HTMLElement {
+    #private;
+    constructor(parameters: TweakerFolderParameters);
+    get key(): string;
+    get head(): Store<any>;
+    get content(): Store<(TweakerFieldElement | TweakerFolderElement)[]>;
+    get bodyElement(): HTMLElement;
+    get contentElement(): HTMLElement;
+    protected connectedCallback(): void;
+    protected handleStore(storeBox: StoreBox): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-tweaker-folder': TweakerFolderElement;
+    }
+}

package/lib/need_redo_tweaker/TweakerLinkManagerElement.d.ts

@@ -0,0 +1,11 @@
+import { Store } from '../store/vanilla';
+import { TweakerStoreManagerElement } from './TweakerStoreManagerElement';
+
+export declare class TweakerLinkManagerElement extends TweakerStoreManagerElement<Store<string>> {
+    constructor(...stores: Array<Store<string>>);
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-tweaker-link-manager': TweakerLinkManagerElement;
+    }
+}

package/lib/need_redo_tweaker/TweakerNumberManagerElement.d.ts

@@ -0,0 +1,14 @@
+import { Store } from '../store/vanilla';
+import { TweakerStoreManagerElement } from './TweakerStoreManagerElement';
+
+export declare class TweakerNumberManagerElement extends TweakerStoreManagerElement<Store<Array<number> | number>> {
+    #private;
+    constructor(...stores: Array<Store<Array<number> | number>>);
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-tweaker-number-manager': TweakerNumberManagerElement;
+    }
+}

package/lib/need_redo_tweaker/TweakerSelectManagerElement.d.ts

@@ -0,0 +1,11 @@
+import { Store } from '../store/vanilla';
+import { TweakerStoreManagerElement } from './TweakerStoreManagerElement';
+
+export declare class TweakerSelectManagerElement extends TweakerStoreManagerElement<Store<string>> {
+    constructor(...stores: Array<Store<string>>);
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-tweaker-select-manager': TweakerSelectManagerElement;
+    }
+}

package/lib/need_redo_tweaker/TweakerStoreManagerElement.d.ts

@@ -0,0 +1,10 @@
+import { Store } from '../store/vanilla';
+
+export declare class TweakerStoreManagerElement<S extends Store<any>> extends HTMLElement {
+    #private;
+    constructor(...stores: Array<S>);
+    addStore(store: S): void;
+    protected get firstStore(): S;
+    protected get stores(): S[];
+    protected updateStores(value: S['current']): void;
+}

package/lib/need_redo_tweaker/TweakerStringManagerElement.d.ts

@@ -0,0 +1,11 @@
+import { Store } from '../store/vanilla';
+import { TweakerStoreManagerElement } from './TweakerStoreManagerElement';
+
+export declare class TweakerStringManagerElement<S extends Store<any> = Store<string>> extends TweakerStoreManagerElement<S> {
+    constructor(...stores: Array<S>);
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-tweaker-string-manager': TweakerStringManagerElement;
+    }
+}

package/lib/need_redo_tweaker/element-constructor/ElementConstructor.d.ts

@@ -0,0 +1,75 @@
+import { Store } from '../../store/vanilla';
+import { SplitFirst } from '../../utils';
+import { ConnectorConnectCallback, ConnectorDisconnectCallback } from '../../connector';
+
+export type StoreOr<T> = T | Store<T>;
+export type ElementConstructorTagNameMap = HTMLElementTagNameMap & SVGElementTagNameMap;
+export type ElementConstructorTagNames = keyof ElementConstructorTagNameMap;
+export type ElementConstructorStringStoreClass = Store<any> | Store<any>;
+export type ElementConstructorStringArrayStoreClass = Store<Array<any>> | Store<Array<any>>;
+export type ElementConstructorClass = string | Array<string | ElementConstructorStringStoreClass | ElementConstructorStringArrayStoreClass | null | undefined> | ElementConstructorStringStoreClass | ElementConstructorStringArrayStoreClass | {
+    [key: string]: boolean | Store<boolean>;
+};
+export type ElementConstructorStyleToken = Exclude<Extract<keyof CSSStyleDeclaration, string> | `--${string}` | `-${string}`, 'length' | 'parentRule'>;
+export type ElementConstructorStyleValue = string | number | Store<any>;
+export type ElementConstructorStyle = Partial<{
+    [K in ElementConstructorStyleToken]: ElementConstructorStyleValue;
+}>;
+export type ElementConstructorJSSWrapper = {
+    [key: string]: object | ElementConstructorStyle;
+};
+export type ElementConstructorJSS = ElementConstructorStyle | {
+    [key: string]: ElementConstructorJSSWrapper | ElementConstructorStyle;
+};
+export type ElementConstructorEventMap = HTMLElementEventMap & SVGElementEventMap;
+export type ElementConstructorNativeAttribute<T extends ElementConstructorTagNames | Node = ElementConstructorTagNames, E = T extends ElementConstructorTagNames ? ElementConstructorTagNameMap[T] : Node> = {
+    [K in keyof E]: E[K] extends string | null ? K : never;
+}[keyof E];
+export type ElementConstructorNativeAttributes<T extends ElementConstructorTagNames | Node = ElementConstructorTagNames> = Partial<{
+    [K in ElementConstructorNativeAttribute<T>]: any;
+}>;
+export type ElementConstructorCustomAttributes = {
+    [key: string]: any;
+};
+export type ElementConstructorAttributes<T extends ElementConstructorTagNames | Node = ElementConstructorTagNames> = ElementConstructorNativeAttributes<T> | ElementConstructorCustomAttributes;
+export type ElementConstructorParent = Node | ElementConstructor;
+export type ElementConstructorRefCallback<T extends ElementConstructorTagNames | Node = ElementConstructorTagNames> = (element: T extends ElementConstructorTagNames ? ElementConstructorTagNameMap[T] : Node) => void;
+export type ElementConstructorObjectRef<T extends ElementConstructorTagNames | Node = ElementConstructorTagNames> = {
+    current: T extends ElementConstructorTagNames ? ElementConstructorTagNameMap[T] : Node;
+};
+export type ElementConstructorRef<T extends ElementConstructorTagNames | Node = ElementConstructorTagNames> = ElementConstructorRefCallback<T> | ElementConstructorObjectRef<T>;
+export type ElementConstructorEventValue<E extends Event> = {
+    callback: (event: E) => void;
+    options?: AddEventListenerOptions;
+} | ((event: E) => void);
+export type ElementConstructorEvents = Partial<{
+    [K in `on${Capitalize<keyof ElementConstructorEventMap>}`]: ElementConstructorEventValue<ElementConstructorEventMap[Extract<Uncapitalize<SplitFirst<K, 'on'>[1]>, keyof ElementConstructorEventMap>]>;
+}>;
+export type ElementConstructorChildrenChangeCallback = () => void;
+export type ElementConstructorTagObject<T extends ElementConstructorTagNames | Node = ElementConstructorTagNames> = {
+    class?: ElementConstructorClass;
+    style?: T extends 'style' ? ElementConstructorJSS : ElementConstructorStyle;
+    children?: any;
+    ref?: ElementConstructorRef<T>;
+    forceSvg?: boolean;
+    lightChildren?: any;
+    onDisconnect?: ConnectorDisconnectCallback;
+    onConnect?: ConnectorConnectCallback;
+    connectedClass?: boolean | string;
+} & ElementConstructorAttributes<T> & ElementConstructorEvents;
+export declare class ElementConstructor<T extends ElementConstructorTagNames | Node = ElementConstructorTagNames, N = T extends ElementConstructorTagNames ? ElementConstructorTagNameMap[T] : Node> {
+    #private;
+    constructor(value: T, object?: ElementConstructorTagObject<T>);
+    constructor(value: string, object?: ElementConstructorTagObject<T>);
+    constructor(value: Node, object?: ElementConstructorTagObject<T>);
+    get node(): N;
+    set node(v: N);
+}
+declare global {
+    interface HTMLElementEventMap {
+        beforeChildrenChange: CustomEvent;
+    }
+    interface HTMLElementEventMap {
+        afterChildrenChange: CustomEvent;
+    }
+}

package/lib/need_redo_tweaker/element-constructor/createStylesheet.d.ts

@@ -0,0 +1,3 @@
+import { ElementConstructorJSS } from './ElementConstructor';
+
+export declare function createStylesheet<T extends ElementConstructorJSS>(object?: T): CSSStyleSheet;

package/lib/need_redo_tweaker/element-constructor/createTheme.d.ts

@@ -0,0 +1,13 @@
+import { CamelToKebab } from '../../utils';
+
+export interface CreateThemeOptions<P extends string = ''> {
+    prefix?: P;
+}
+export declare function createTheme<T extends {
+    [key: string]: string;
+}, P extends string = ''>(object: T, options?: CreateThemeOptions<P>): { [K in Extract<keyof T, string>]: {
+    var: `var(--${P}${CamelToKebab<K>})`;
+    value: T[K];
+}; } & {
+    style: { [K_1 in `--${P}${CamelToKebab<Extract<keyof T, string>>}`]: string; };
+};

package/lib/need_redo_tweaker/element-constructor/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ElementConstructor';
+export * from './tags';
+export * from './createStylesheet';
+export * from './createTheme';

package/lib/need_redo_tweaker/element-constructor/knownSvgTags.d.ts

@@ -0,0 +1 @@
+export declare const knownSvgTags: Set<string>;

package/lib/need_redo_tweaker/element-constructor/tags.d.ts

@@ -0,0 +1,119 @@
+import { ElementConstructorTagObject, ElementConstructor, ElementConstructorJSS, ElementConstructorTagNames } from './ElementConstructor';
+
+export declare function element<T extends ElementConstructorTagNames | Node = ElementConstructorTagNames>(node: T, object: ElementConstructorTagObject<T>): ElementConstructor<T>;
+export declare function element<T extends string = string>(node: T, object: ElementConstructorTagObject<Element>): ElementConstructor<Element>;
+export declare function a(object?: ElementConstructorTagObject<'a'>): ElementConstructor<"a", HTMLAnchorElement & SVGAElement>;
+export declare function abbr(object?: ElementConstructorTagObject<'abbr'>): ElementConstructor<"abbr", HTMLElement>;
+export declare function address(object?: ElementConstructorTagObject<'address'>): ElementConstructor<"address", HTMLElement>;
+export declare function area(object?: ElementConstructorTagObject<'area'>): ElementConstructor<"area", HTMLAreaElement>;
+export declare function article(object?: ElementConstructorTagObject<'article'>): ElementConstructor<"article", HTMLElement>;
+export declare function aside(object?: ElementConstructorTagObject<'aside'>): ElementConstructor<"aside", HTMLElement>;
+export declare function audio(object?: ElementConstructorTagObject<'audio'>): ElementConstructor<"audio", HTMLAudioElement>;
+export declare function b(object?: ElementConstructorTagObject<'b'>): ElementConstructor<"b", HTMLElement>;
+export declare function base(object?: ElementConstructorTagObject<'base'>): ElementConstructor<"base", HTMLBaseElement>;
+export declare function bdi(object?: ElementConstructorTagObject<'bdi'>): ElementConstructor<"bdi", HTMLElement>;
+export declare function bdo(object?: ElementConstructorTagObject<'bdo'>): ElementConstructor<"bdo", HTMLElement>;
+export declare function blockquote(object?: ElementConstructorTagObject<'blockquote'>): ElementConstructor<"blockquote", HTMLQuoteElement>;
+export declare function body(object?: ElementConstructorTagObject<'body'>): ElementConstructor<"body", HTMLBodyElement>;
+export declare function br(object?: ElementConstructorTagObject<'br'>): ElementConstructor<"br", HTMLBRElement>;
+export declare function button(object?: ElementConstructorTagObject<'button'>): ElementConstructor<"button", HTMLButtonElement>;
+export declare function canvas(object?: ElementConstructorTagObject<'canvas'>): ElementConstructor<"canvas", HTMLCanvasElement>;
+export declare function caption(object?: ElementConstructorTagObject<'caption'>): ElementConstructor<"caption", HTMLTableCaptionElement>;
+export declare function cite(object?: ElementConstructorTagObject<'cite'>): ElementConstructor<"cite", HTMLElement>;
+export declare function code(object?: ElementConstructorTagObject<'code'>): ElementConstructor<"code", HTMLElement>;
+export declare function col(object?: ElementConstructorTagObject<'col'>): ElementConstructor<"col", HTMLTableColElement>;
+export declare function colgroup(object?: ElementConstructorTagObject<'colgroup'>): ElementConstructor<"colgroup", HTMLTableColElement>;
+export declare function data(object?: ElementConstructorTagObject<'data'>): ElementConstructor<"data", HTMLDataElement>;
+export declare function datalist(object?: ElementConstructorTagObject<'datalist'>): ElementConstructor<"datalist", HTMLDataListElement>;
+export declare function dd(object?: ElementConstructorTagObject<'dd'>): ElementConstructor<"dd", HTMLElement>;
+export declare function del(object?: ElementConstructorTagObject<'del'>): ElementConstructor<"del", HTMLModElement>;
+export declare function details(object?: ElementConstructorTagObject<'details'>): ElementConstructor<"details", HTMLDetailsElement>;
+export declare function dfn(object?: ElementConstructorTagObject<'dfn'>): ElementConstructor<"dfn", HTMLElement>;
+export declare function dialog(object?: ElementConstructorTagObject<'dialog'>): ElementConstructor<"dialog", HTMLDialogElement>;
+export declare function div(object?: ElementConstructorTagObject<'div'>): ElementConstructor<"div", HTMLDivElement>;
+export declare function dl(object?: ElementConstructorTagObject<'dl'>): ElementConstructor<"dl", HTMLDListElement>;
+export declare function dt(object?: ElementConstructorTagObject<'dt'>): ElementConstructor<"dt", HTMLElement>;
+export declare function em(object?: ElementConstructorTagObject<'em'>): ElementConstructor<"em", HTMLElement>;
+export declare function embed(object?: ElementConstructorTagObject<'embed'>): ElementConstructor<"embed", HTMLEmbedElement>;
+export declare function fieldset(object?: ElementConstructorTagObject<'fieldset'>): ElementConstructor<"fieldset", HTMLFieldSetElement>;
+export declare function figcaption(object?: ElementConstructorTagObject<'figcaption'>): ElementConstructor<"figcaption", HTMLElement>;
+export declare function figure(object?: ElementConstructorTagObject<'figure'>): ElementConstructor<"figure", HTMLElement>;
+export declare function footer(object?: ElementConstructorTagObject<'footer'>): ElementConstructor<"footer", HTMLElement>;
+export declare function form(object?: ElementConstructorTagObject<'form'>): ElementConstructor<"form", HTMLFormElement>;
+export declare function h1(object?: ElementConstructorTagObject<'h1'>): ElementConstructor<"h1", HTMLHeadingElement>;
+export declare function h2(object?: ElementConstructorTagObject<'h2'>): ElementConstructor<"h2", HTMLHeadingElement>;
+export declare function h3(object?: ElementConstructorTagObject<'h3'>): ElementConstructor<"h3", HTMLHeadingElement>;
+export declare function h4(object?: ElementConstructorTagObject<'h4'>): ElementConstructor<"h4", HTMLHeadingElement>;
+export declare function h5(object?: ElementConstructorTagObject<'h5'>): ElementConstructor<"h5", HTMLHeadingElement>;
+export declare function h6(object?: ElementConstructorTagObject<'h6'>): ElementConstructor<"h6", HTMLHeadingElement>;
+export declare function head(object?: ElementConstructorTagObject<'head'>): ElementConstructor<"head", HTMLHeadElement>;
+export declare function header(object?: ElementConstructorTagObject<'header'>): ElementConstructor<"header", HTMLElement>;
+export declare function hgroup(object?: ElementConstructorTagObject<'hgroup'>): ElementConstructor<"hgroup", HTMLElement>;
+export declare function hr(object?: ElementConstructorTagObject<'hr'>): ElementConstructor<"hr", HTMLHRElement>;
+export declare function html(object?: ElementConstructorTagObject<'html'>): ElementConstructor<"html", HTMLHtmlElement>;
+export declare function i(object?: ElementConstructorTagObject<'i'>): ElementConstructor<"i", HTMLElement>;
+export declare function iframe(object?: ElementConstructorTagObject<'iframe'>): ElementConstructor<"iframe", HTMLIFrameElement>;
+export declare function img(object?: ElementConstructorTagObject<'img'>): ElementConstructor<"img", HTMLImageElement>;
+export declare function input(object?: ElementConstructorTagObject<'input'>): ElementConstructor<"input", HTMLInputElement>;
+export declare function ins(object?: ElementConstructorTagObject<'ins'>): ElementConstructor<"ins", HTMLModElement>;
+export declare function kbd(object?: ElementConstructorTagObject<'kbd'>): ElementConstructor<"kbd", HTMLElement>;
+export declare function label(object?: ElementConstructorTagObject<'label'>): ElementConstructor<"label", HTMLLabelElement>;
+export declare function legend(object?: ElementConstructorTagObject<'legend'>): ElementConstructor<"legend", HTMLLegendElement>;
+export declare function li(object?: ElementConstructorTagObject<'li'>): ElementConstructor<"li", HTMLLIElement>;
+export declare function link(object?: ElementConstructorTagObject<'link'>): ElementConstructor<"link", HTMLLinkElement>;
+export declare function main(object?: ElementConstructorTagObject<'main'>): ElementConstructor<"main", HTMLElement>;
+export declare function map(object?: ElementConstructorTagObject<'map'>): ElementConstructor<"map", HTMLMapElement>;
+export declare function mark(object?: ElementConstructorTagObject<'mark'>): ElementConstructor<"mark", HTMLElement>;
+export declare function menu(object?: ElementConstructorTagObject<'menu'>): ElementConstructor<"menu", HTMLMenuElement>;
+export declare function meta(object?: ElementConstructorTagObject<'meta'>): ElementConstructor<"meta", HTMLMetaElement>;
+export declare function meter(object?: ElementConstructorTagObject<'meter'>): ElementConstructor<"meter", HTMLMeterElement>;
+export declare function nav(object?: ElementConstructorTagObject<'nav'>): ElementConstructor<"nav", HTMLElement>;
+export declare function noscript(object?: ElementConstructorTagObject<'noscript'>): ElementConstructor<"noscript", HTMLElement>;
+export declare function object(object?: ElementConstructorTagObject<'object'>): ElementConstructor<"object", HTMLObjectElement>;
+export declare function ol(object?: ElementConstructorTagObject<'ol'>): ElementConstructor<"ol", HTMLOListElement>;
+export declare function optgroup(object?: ElementConstructorTagObject<'optgroup'>): ElementConstructor<"optgroup", HTMLOptGroupElement>;
+export declare function option(object?: ElementConstructorTagObject<'option'>): ElementConstructor<"option", HTMLOptionElement>;
+export declare function output(object?: ElementConstructorTagObject<'output'>): ElementConstructor<"output", HTMLOutputElement>;
+export declare function p(object?: ElementConstructorTagObject<'p'>): ElementConstructor<"p", HTMLParagraphElement>;
+export declare function picture(object?: ElementConstructorTagObject<'picture'>): ElementConstructor<"picture", HTMLPictureElement>;
+export declare function pre(object?: ElementConstructorTagObject<'pre'>): ElementConstructor<"pre", HTMLPreElement>;
+export declare function progress(object?: ElementConstructorTagObject<'progress'>): ElementConstructor<"progress", HTMLProgressElement>;
+export declare function q(object?: ElementConstructorTagObject<'q'>): ElementConstructor<"q", HTMLQuoteElement>;
+export declare function rp(object?: ElementConstructorTagObject<'rp'>): ElementConstructor<"rp", HTMLElement>;
+export declare function rt(object?: ElementConstructorTagObject<'rt'>): ElementConstructor<"rt", HTMLElement>;
+export declare function ruby(object?: ElementConstructorTagObject<'ruby'>): ElementConstructor<"ruby", HTMLElement>;
+export declare function s(object?: ElementConstructorTagObject<'s'>): ElementConstructor<"s", HTMLElement>;
+export declare function samp(object?: ElementConstructorTagObject<'samp'>): ElementConstructor<"samp", HTMLElement>;
+export declare function script(object?: ElementConstructorTagObject<'script'>): ElementConstructor<"script", HTMLScriptElement & SVGScriptElement>;
+export declare function search(object?: ElementConstructorTagObject<'search'>): ElementConstructor<"search", HTMLElement>;
+export declare function section(object?: ElementConstructorTagObject<'section'>): ElementConstructor<"section", HTMLElement>;
+export declare function select(object?: ElementConstructorTagObject<'select'>): ElementConstructor<"select", HTMLSelectElement>;
+export declare function slot(object?: ElementConstructorTagObject<'slot'>): ElementConstructor<"slot", HTMLSlotElement>;
+export declare function small(object?: ElementConstructorTagObject<'small'>): ElementConstructor<"small", HTMLElement>;
+export declare function source(object?: ElementConstructorTagObject<'source'>): ElementConstructor<"source", HTMLSourceElement>;
+export declare function span(object?: ElementConstructorTagObject<'span'>): ElementConstructor<"span", HTMLSpanElement>;
+export declare function strong(object?: ElementConstructorTagObject<'strong'>): ElementConstructor<"strong", HTMLElement>;
+export declare function style(object?: ElementConstructorJSS): ElementConstructor<"style", HTMLStyleElement & SVGStyleElement>;
+export declare function sub(object?: ElementConstructorTagObject<'sub'>): ElementConstructor<"sub", HTMLElement>;
+export declare function summary(object?: ElementConstructorTagObject<'summary'>): ElementConstructor<"summary", HTMLElement>;
+export declare function sup(object?: ElementConstructorTagObject<'sup'>): ElementConstructor<"sup", HTMLElement>;
+export declare function table(object?: ElementConstructorTagObject<'table'>): ElementConstructor<"table", HTMLTableElement>;
+export declare function tbody(object?: ElementConstructorTagObject<'tbody'>): ElementConstructor<"tbody", HTMLTableSectionElement>;
+export declare function td(object?: ElementConstructorTagObject<'td'>): ElementConstructor<"td", HTMLTableCellElement>;
+export declare function template(object?: ElementConstructorTagObject<'template'>): ElementConstructor<"template", HTMLTemplateElement>;
+export declare function textarea(object?: ElementConstructorTagObject<'textarea'>): ElementConstructor<"textarea", HTMLTextAreaElement>;
+export declare function tfoot(object?: ElementConstructorTagObject<'tfoot'>): ElementConstructor<"tfoot", HTMLTableSectionElement>;
+export declare function th(object?: ElementConstructorTagObject<'th'>): ElementConstructor<"th", HTMLTableCellElement>;
+export declare function thead(object?: ElementConstructorTagObject<'thead'>): ElementConstructor<"thead", HTMLTableSectionElement>;
+export declare function time(object?: ElementConstructorTagObject<'time'>): ElementConstructor<"time", HTMLTimeElement>;
+export declare function title(object?: ElementConstructorTagObject<'title'>): ElementConstructor<"title", HTMLTitleElement & SVGTitleElement>;
+export declare function tr(object?: ElementConstructorTagObject<'tr'>): ElementConstructor<"tr", HTMLTableRowElement>;
+export declare function track(object?: ElementConstructorTagObject<'track'>): ElementConstructor<"track", HTMLTrackElement>;
+export declare function u(object?: ElementConstructorTagObject<'u'>): ElementConstructor<"u", HTMLElement>;
+export declare function ul(object?: ElementConstructorTagObject<'ul'>): ElementConstructor<"ul", HTMLUListElement>;
+export declare function htmlVar(object?: ElementConstructorTagObject<'var'>): ElementConstructor<"var", HTMLElement>;
+export declare function video(object?: ElementConstructorTagObject<'video'>): ElementConstructor<"video", HTMLVideoElement>;
+export declare function wbr(object?: ElementConstructorTagObject<'wbr'>): ElementConstructor<"wbr", HTMLElement>;
+export declare function fragment(object?: ElementConstructorTagObject<Node>): ElementConstructor<Node, Node>;
+export declare function empty(object?: ElementConstructorTagObject<Node>): ElementConstructor<Node, Node>;
+export declare function contents(object?: ElementConstructorTagObject<'div'>): ElementConstructor<"div", HTMLDivElement>;

package/lib/need_redo_tweaker/events.d.ts

@@ -0,0 +1,8 @@
+export declare function dispatchSizeChangeEvent(node: Node): void;
+export declare function dispatchBeforeSizeChangeEvent(node: Node): void;
+declare global {
+    interface HTMLElementEventMap {
+        sizeChange: CustomEvent;
+        beforeSizeChange: CustomEvent;
+    }
+}

package/lib/need_redo_tweaker/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/need_redo_tweaker/select/SelectElement.d.ts

@@ -0,0 +1,24 @@
+export interface SelectToggleDetail {
+    opened: boolean;
+}
+export declare class SelectElement extends HTMLElement {
+    #private;
+    static formAssociated: boolean;
+    constructor();
+    get value(): string;
+    set value(value: string);
+    get internals(): ElementInternals;
+    get opened(): boolean;
+    open(): void;
+    close(): void;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-select': SelectElement;
+    }
+    interface HTMLElementEventMap {
+        selectToggle: CustomEvent<SelectToggleDetail>;
+    }
+}