tungsten 0.1.6 → 0.1.24

package/types/jsx/jsx.d.ts

@@ -0,0 +1,341 @@
+
+import type { ContentNode, ContentNodeComponent } from 'tungsten/ContentNode.js'
+import { TungstenBaseComponent } from 'tungsten/Components.jsx'
+import type { FunctionComponent } from 'tungsten/FunctionComponent.js'
+
+import type { HTMLWebViewElement } from './html.global.js'
+import type { 
+    AnchorHTMLAttributes, AreaHTMLAttributes, AudioHTMLAttributes, BaseHTMLAttributes,
+    BlockquoteHTMLAttributes, ButtonHTMLAttributes, CanvasHTMLAttributes, ColHTMLAttributes, ColgroupHTMLAttributes, DataHTMLAttributes, DelHTMLAttributes, DetailsHTMLAttributes, DialogHTMLAttributes, EmbedHTMLAttributes, FieldsetHTMLAttributes, FormHTMLAttributes, HTMLAttributes, HtmlHTMLAttributes, IframeHTMLAttributes, ImgHTMLAttributes, InputHTMLAttributes, InsHTMLAttributes, KeygenHTMLAttributes, LabelHTMLAttributes, LiHTMLAttributes, LinkHTMLAttributes, MapHTMLAttributes, MenuHTMLAttributes, MetaHTMLAttributes, MeterHTMLAttributes, ObjectHTMLAttributes, OlHTMLAttributes, OptgroupHTMLAttributes, OptionHTMLAttributes, OutputHTMLAttributes, ParamHTMLAttributes, ProgressHTMLAttributes, QuoteHTMLAttributes, SVGAttributes, ScriptHTMLAttributes, SelectHTMLAttributes, SlotHTMLAttributes, SourceHTMLAttributes, StyleHTMLAttributes, TableHTMLAttributes, TdHTMLAttributes, TextareaHTMLAttributes, ThHTMLAttributes, TimeHTMLAttributes, TrackHTMLAttributes, VideoHTMLAttributes, WebViewHTMLAttributes
+} from './html.d.js'
+
+
+
+interface ErrorInfo {
+    componentStack: string;
+}
+
+
+/////////////////////////////////////////////////////
+// React types that we are going to replace
+/////////////////////////////////////////////////////
+interface NewLifecycle<P, S, SS> {
+    getSnapshotBeforeUpdate?(prevProps: Readonly<P>, prevState: Readonly<S>): SS | null;
+    componentDidUpdate?(prevProps: Readonly<P>, prevState: Readonly<S>, snapshot?: SS): void;
+}
+
+interface DeprecatedLifecycle<P, S> {
+    componentWillMount?(): void;
+    UNSAFE_componentWillMount?(): void;
+    componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+    UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+    componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): void;
+    UNSAFE_componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): void;
+}
+
+interface ComponentLifecycle<P, S, SS = any> extends NewLifecycle<P, S, SS>, DeprecatedLifecycle<P, S> {
+    componentDidMount?(): void;
+    shouldComponentUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): boolean;
+    componentWillUnmount?(): void;
+    componentDidCatch?(error: Error, errorInfo: ErrorInfo): void;
+}
+interface Component<P = {}, S = {}, SS = any> extends ComponentLifecycle<P, S, SS> { }
+
+type JSXElementConstructor<P> =
+    | ((
+        props: P,
+            /**
+             * @deprecated https://legacy.reactjs.org/docs/legacy-context.html#referencing-context-in-stateless-function-components
+             */
+        deprecatedLegacyContext?: any,
+    ) => ContentNode)
+    | (new (props: P) => Component<any, any>);
+
+// interface ReactElement<P = any, T extends string | JSXElementConstructor<any> = string | JSXElementConstructor<any>> {
+//     type: T;
+//     props: P;
+//     key: Key | null;
+// }
+// interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES {}
+// type ReactNode =
+//     | ReactElement
+//     | string
+//     | number
+//     | Iterable<ReactNode>
+//     | ReactPortal
+//     | boolean
+//     | null
+//     | undefined
+//     | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES[keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_REACT_NODES];
+
+// interface ReactPortal extends ReactElement {
+//     key: Key | null;
+//     children: ReactNode;
+// }
+
+/////////////////////////////////////////////////////
+// End: React types that we are going to replace
+/////////////////////////////////////////////////////
+
+
+type Key = string | number;
+
+interface RefObject<T> {
+    readonly current: T | null;
+}
+    // Bivariance hack for consistent unsoundness with RefObject
+type RefCallback<T> = { bivarianceHack(instance: T | null): void }['bivarianceHack'];
+type Ref<T> = RefCallback<T> | RefObject<T> | null;
+type LegacyRef<T> = string | Ref<T>;
+
+interface Attributes {
+    key?: Key | null | undefined;
+}
+interface RefAttributes<T> extends Attributes {
+    /**
+     * Allows getting a ref to the component instance.
+     * Once the component unmounts, React will set `ref.current` to `null` (or call the ref with `null` if you passed a callback ref).
+     * @see https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom
+     */
+    ref?: Ref<T> | undefined;
+}
+interface ClassAttributes<T> extends Attributes {
+    /**
+     * Allows getting a ref to the component instance.
+     * Once the component unmounts, React will set `ref.current` to `null` (or call the ref with `null` if you passed a callback ref).
+     * @see https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom
+     */
+    ref?: LegacyRef<T> | undefined;
+}
+
+interface ClassAttributes<T> extends Attributes {
+    /**
+     * Allows getting a ref to the component instance.
+     * Once the component unmounts, React will set `ref.current` to `null` (or call the ref with `null` if you passed a callback ref).
+     * @see https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom
+     */
+    ref?: LegacyRef<T> | undefined;
+}
+
+type DetailedHTMLProps<E extends HTMLAttributes<T>, T> = ClassAttributes<T> & E;
+
+interface SVGProps<T> extends SVGAttributes<T>, ClassAttributes<T> { }
+interface SVGLineElementAttributes<T> extends SVGProps<T> {}
+interface SVGTextElementAttributes<T> extends SVGProps<T> {}
+
+
+/*
+// We can't recurse forever because `type` can't be self-referential;
+// let's assume it's reasonable to do a single React.lazy() around a single React.memo() / vice-versa
+type LibraryManagedAttributes<C, P> = C extends React.MemoExoticComponent<infer T> | React.LazyExoticComponent<infer T>
+    ? T extends React.MemoExoticComponent<infer U> | React.LazyExoticComponent<infer U>
+        ? ReactManagedAttributes<U, P>
+        : ReactManagedAttributes<T, P>
+    : ReactManagedAttributes<C, P>;
+*/
+
+export interface TungstenIntrinsicAttributes extends Attributes { }
+export interface TungstenIntrinsicClassAttributes<T> extends ClassAttributes<T> { }
+
+export interface TungstenIntrinsicElements {
+    // HTML
+    a: DetailedHTMLProps<AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>;
+    abbr: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    address: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    area: DetailedHTMLProps<AreaHTMLAttributes<HTMLAreaElement>, HTMLAreaElement>;
+    article: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    aside: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    audio: DetailedHTMLProps<AudioHTMLAttributes<HTMLAudioElement>, HTMLAudioElement>;
+    b: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    base: DetailedHTMLProps<BaseHTMLAttributes<HTMLBaseElement>, HTMLBaseElement>;
+    bdi: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    bdo: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    big: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    blockquote: DetailedHTMLProps<BlockquoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>;
+    body: DetailedHTMLProps<HTMLAttributes<HTMLBodyElement>, HTMLBodyElement>;
+    br: DetailedHTMLProps<HTMLAttributes<HTMLBRElement>, HTMLBRElement>;
+    button: DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement, any>, HTMLButtonElement>;
+    canvas: DetailedHTMLProps<CanvasHTMLAttributes<HTMLCanvasElement>, HTMLCanvasElement>;
+    caption: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    center: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    cite: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    code: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    col: DetailedHTMLProps<ColHTMLAttributes<HTMLTableColElement>, HTMLTableColElement>;
+    colgroup: DetailedHTMLProps<ColgroupHTMLAttributes<HTMLTableColElement>, HTMLTableColElement>;
+    data: DetailedHTMLProps<DataHTMLAttributes<HTMLDataElement, any>, HTMLDataElement>;
+    datalist: DetailedHTMLProps<HTMLAttributes<HTMLDataListElement>, HTMLDataListElement>;
+    dd: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    del: DetailedHTMLProps<DelHTMLAttributes<HTMLModElement>, HTMLModElement>;
+    details: DetailedHTMLProps<DetailsHTMLAttributes<HTMLDetailsElement>, HTMLDetailsElement>;
+    dfn: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    dialog: DetailedHTMLProps<DialogHTMLAttributes<HTMLDialogElement>, HTMLDialogElement>;
+    div: DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+    dl: DetailedHTMLProps<HTMLAttributes<HTMLDListElement>, HTMLDListElement>;
+    dt: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    em: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    embed: DetailedHTMLProps<EmbedHTMLAttributes<HTMLEmbedElement>, HTMLEmbedElement>;
+    fieldset: DetailedHTMLProps<FieldsetHTMLAttributes<HTMLFieldSetElement>, HTMLFieldSetElement>;
+    figcaption: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    figure: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    footer: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    form: DetailedHTMLProps<FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>;
+    h1: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
+    h2: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
+    h3: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
+    h4: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
+    h5: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
+    h6: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
+    head: DetailedHTMLProps<HTMLAttributes<HTMLHeadElement>, HTMLHeadElement>;
+    header: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    hgroup: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    hr: DetailedHTMLProps<HTMLAttributes<HTMLHRElement>, HTMLHRElement>;
+    html: DetailedHTMLProps<HtmlHTMLAttributes<HTMLHtmlElement>, HTMLHtmlElement>;
+    i: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    iframe: DetailedHTMLProps<IframeHTMLAttributes<HTMLIFrameElement>, HTMLIFrameElement>;
+    img: DetailedHTMLProps<ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>;
+    input: DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement, any>, HTMLInputElement>;
+    ins: DetailedHTMLProps<InsHTMLAttributes<HTMLModElement>, HTMLModElement>;
+    kbd: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    keygen: DetailedHTMLProps<KeygenHTMLAttributes<HTMLElement>, HTMLElement>;
+    label: DetailedHTMLProps<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>;
+    legend: DetailedHTMLProps<HTMLAttributes<HTMLLegendElement>, HTMLLegendElement>;
+    li: DetailedHTMLProps<LiHTMLAttributes<HTMLLIElement, any>, HTMLLIElement>;
+    link: DetailedHTMLProps<LinkHTMLAttributes<HTMLLinkElement>, HTMLLinkElement>;
+    main: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    map: DetailedHTMLProps<MapHTMLAttributes<HTMLMapElement>, HTMLMapElement>;
+    mark: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    menu: DetailedHTMLProps<MenuHTMLAttributes<HTMLElement>, HTMLElement>;
+    menuitem: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    meta: DetailedHTMLProps<MetaHTMLAttributes<HTMLMetaElement>, HTMLMetaElement>;
+    meter: DetailedHTMLProps<MeterHTMLAttributes<HTMLMeterElement, any>, HTMLMeterElement>;
+    nav: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    noindex: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    noscript: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    object: DetailedHTMLProps<ObjectHTMLAttributes<HTMLObjectElement>, HTMLObjectElement>;
+    ol: DetailedHTMLProps<OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>;
+    optgroup: DetailedHTMLProps<OptgroupHTMLAttributes<HTMLOptGroupElement>, HTMLOptGroupElement>;
+    option: DetailedHTMLProps<OptionHTMLAttributes<HTMLOptionElement, any>, HTMLOptionElement>;
+    output: DetailedHTMLProps<OutputHTMLAttributes<HTMLOutputElement>, HTMLOutputElement>;
+    p: DetailedHTMLProps<HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>;
+    param: DetailedHTMLProps<ParamHTMLAttributes<HTMLParamElement, any>, HTMLParamElement>;
+    picture: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    pre: DetailedHTMLProps<HTMLAttributes<HTMLPreElement>, HTMLPreElement>;
+    progress: DetailedHTMLProps<ProgressHTMLAttributes<HTMLProgressElement, any>, HTMLProgressElement>;
+    q: DetailedHTMLProps<QuoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>;
+    rp: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    rt: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    ruby: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    s: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    samp: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    search: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    slot: DetailedHTMLProps<SlotHTMLAttributes<HTMLSlotElement>, HTMLSlotElement>;
+    script: DetailedHTMLProps<ScriptHTMLAttributes<HTMLScriptElement>, HTMLScriptElement>;
+    section: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    select: DetailedHTMLProps<SelectHTMLAttributes<HTMLSelectElement, any>, HTMLSelectElement>;
+    small: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    source: DetailedHTMLProps<SourceHTMLAttributes<HTMLSourceElement>, HTMLSourceElement>;
+    span: DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>;
+    strong: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    style: DetailedHTMLProps<StyleHTMLAttributes<HTMLStyleElement>, HTMLStyleElement>;
+    sub: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    summary: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    sup: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    table: DetailedHTMLProps<TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>;
+    template: DetailedHTMLProps<HTMLAttributes<HTMLTemplateElement>, HTMLTemplateElement>;
+    tbody: DetailedHTMLProps<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
+    td: DetailedHTMLProps<TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>;
+    textarea: DetailedHTMLProps<TextareaHTMLAttributes<HTMLTextAreaElement, any>, HTMLTextAreaElement>;
+    tfoot: DetailedHTMLProps<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
+    th: DetailedHTMLProps<ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>;
+    thead: DetailedHTMLProps<HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>;
+    time: DetailedHTMLProps<TimeHTMLAttributes<HTMLTimeElement>, HTMLTimeElement>;
+    title: DetailedHTMLProps<HTMLAttributes<HTMLTitleElement>, HTMLTitleElement>;
+    tr: DetailedHTMLProps<HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>;
+    track: DetailedHTMLProps<TrackHTMLAttributes<HTMLTrackElement>, HTMLTrackElement>;
+    u: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    ul: DetailedHTMLProps<HTMLAttributes<HTMLUListElement>, HTMLUListElement>;
+    'var': DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    video: DetailedHTMLProps<VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>;
+    wbr: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
+    webview: DetailedHTMLProps<WebViewHTMLAttributes<HTMLWebViewElement>, HTMLWebViewElement>;
+
+    // SVG
+    svg: SVGProps<SVGSVGElement>;
+
+    animate: SVGProps<SVGElement>; // TODO: It is SVGAnimateElement but is not in TypeScript's lib.dom.d.ts for now.
+    animateMotion: SVGProps<SVGElement>;
+    animateTransform: SVGProps<SVGElement>; // TODO: It is SVGAnimateTransformElement but is not in TypeScript's lib.dom.d.ts for now.
+    circle: SVGProps<SVGCircleElement>;
+    clipPath: SVGProps<SVGClipPathElement>;
+    defs: SVGProps<SVGDefsElement>;
+    desc: SVGProps<SVGDescElement>;
+    ellipse: SVGProps<SVGEllipseElement>;
+    feBlend: SVGProps<SVGFEBlendElement>;
+    feColorMatrix: SVGProps<SVGFEColorMatrixElement>;
+    feComponentTransfer: SVGProps<SVGFEComponentTransferElement>;
+    feComposite: SVGProps<SVGFECompositeElement>;
+    feConvolveMatrix: SVGProps<SVGFEConvolveMatrixElement>;
+    feDiffuseLighting: SVGProps<SVGFEDiffuseLightingElement>;
+    feDisplacementMap: SVGProps<SVGFEDisplacementMapElement>;
+    feDistantLight: SVGProps<SVGFEDistantLightElement>;
+    feDropShadow: SVGProps<SVGFEDropShadowElement>;
+    feFlood: SVGProps<SVGFEFloodElement>;
+    feFuncA: SVGProps<SVGFEFuncAElement>;
+    feFuncB: SVGProps<SVGFEFuncBElement>;
+    feFuncG: SVGProps<SVGFEFuncGElement>;
+    feFuncR: SVGProps<SVGFEFuncRElement>;
+    feGaussianBlur: SVGProps<SVGFEGaussianBlurElement>;
+    feImage: SVGProps<SVGFEImageElement>;
+    feMerge: SVGProps<SVGFEMergeElement>;
+    feMergeNode: SVGProps<SVGFEMergeNodeElement>;
+    feMorphology: SVGProps<SVGFEMorphologyElement>;
+    feOffset: SVGProps<SVGFEOffsetElement>;
+    fePointLight: SVGProps<SVGFEPointLightElement>;
+    feSpecularLighting: SVGProps<SVGFESpecularLightingElement>;
+    feSpotLight: SVGProps<SVGFESpotLightElement>;
+    feTile: SVGProps<SVGFETileElement>;
+    feTurbulence: SVGProps<SVGFETurbulenceElement>;
+    filter: SVGProps<SVGFilterElement>;
+    foreignObject: SVGProps<SVGForeignObjectElement>;
+    g: SVGProps<SVGGElement>;
+    image: SVGProps<SVGImageElement>;
+    line: SVGLineElementAttributes<SVGLineElement>;
+    linearGradient: SVGProps<SVGLinearGradientElement>;
+    marker: SVGProps<SVGMarkerElement>;
+    mask: SVGProps<SVGMaskElement>;
+    metadata: SVGProps<SVGMetadataElement>;
+    mpath: SVGProps<SVGElement>;
+    path: SVGProps<SVGPathElement>;
+    pattern: SVGProps<SVGPatternElement>;
+    polygon: SVGProps<SVGPolygonElement>;
+    polyline: SVGProps<SVGPolylineElement>;
+    radialGradient: SVGProps<SVGRadialGradientElement>;
+    rect: SVGProps<SVGRectElement>;
+    stop: SVGProps<SVGStopElement>;
+    switch: SVGProps<SVGSwitchElement>;
+    symbol: SVGProps<SVGSymbolElement>;
+    text: SVGTextElementAttributes<SVGTextElement>;
+    textPath: SVGProps<SVGTextPathElement>;
+    tspan: SVGProps<SVGTSpanElement>;
+    use: SVGProps<SVGUseElement>;
+    view: SVGProps<SVGViewElement>;
+}
+
+type IntrinsicElement = TungstenIntrinsicElements[keyof TungstenIntrinsicElements]
+
+type TungstenElementType = string | JSXElementConstructor<any>;
+export type TungstenElement = IntrinsicElement | ContentNodeComponent
+export interface TungstenElementAttributesProperty { props: {}; } // eslint-disable-line @typescript-eslint/ban-types
+export interface TungstenElementChildrenAttribute { children: {}; } // eslint-disable-line @typescript-eslint/ban-types
+
+declare global {
+    namespace JSX {
+        export type Element = ContentNode // ContentNode allows an array. Use Core because Element is exclusive of an array of Elements
+        export interface ElementAttributesProperty extends TungstenElementAttributesProperty {}
+        export interface ElementChildrenAttribute extends TungstenElementChildrenAttribute {}
+        export type ElementClass = TungstenBaseComponent<any, any> | FunctionComponent<any, any>
+        export interface IntrinsicAttributes extends TungstenIntrinsicAttributes { }
+        export interface IntrinsicClassAttributes<T> extends TungstenIntrinsicClassAttributes<T> {}
+        export interface IntrinsicElements extends TungstenIntrinsicElements {}
+    }
+}

package/types/modules.d.ts

@@ -0,0 +1,7 @@
+declare module '@babel/preset-react'
+declare module 'babel-plugin-sxy-module-resolver'
+declare module 'babel-plugin-css-to-js'
+declare module '@babel/plugin-transform-class-properties'
+declare module '@rollup/plugin-node-resolve'
+declare module '@rollup/plugin-commonjs'
+declare module 'rollup-plugin-terser'

package/types/regexpMatches.d.ts

@@ -0,0 +1,3 @@
+type RegExpMatchWithCaptureGroup = RegExpMatchArray & { 1: string }
+type RegExpExecMatchWithCaptureGroup = RegExpExecArray & { 1: string }
+type RegExpExecMatchWith3CaptureGroups = RegExpExecArray & { 1: string, 2: string, 3: string }

package/readme.md

@@ -1 +0,0 @@
-Tungsten TypeScript Framework