@davidsouther/jiffies 2.2.5 → 2026.4.0

package/lib/esm/dom/css/core.js

@@ -1,24 +0,0 @@
-import { Sides, Sizes } from "./constants.js";
-export function isSide(v) {
-    return Sides[v] !== undefined;
-}
-export function isSize(v) {
-    return Sizes[v] !== undefined;
-}
-export function getSize(size) {
-    return Sizes[size];
-}
-export function getSide(side) {
-    switch (side) {
-        case "t":
-            return [...getSide("tl"), ...getSide("tr")];
-        case "r":
-            return [...getSide("tr"), ...getSide("br")];
-        case "b":
-            return [...getSide("br"), ...getSide("bl")];
-        case "l":
-            return [...getSide("tl"), ...getSide("bl")];
-        default:
-            return [Sides[side]];
-    }
-}

package/lib/esm/dom/css/fstyle.d.ts

@@ -1,5 +0,0 @@
-import { Properties } from "../types/css.js";
-export declare type FStyle = Properties | {
-    [k: string]: FStyle;
-};
-export declare function compileFStyle(fstyle: FStyle, prefix?: string): string;

package/lib/esm/dom/css/fstyle.js

@@ -1,32 +0,0 @@
-import { dashCase } from "../../case.js";
-export function compileFStyle(fstyle, prefix = "") {
-    const properties = [];
-    const rules = [];
-    for (const [key, value] of Object.entries(fstyle)) {
-        if (typeof value == "string") {
-            properties.push({ key, value });
-        }
-        else {
-            rules.push({ key, value });
-        }
-    }
-    let rule = "";
-    if (properties.length > 0) {
-        rule += `${prefix} {\n`;
-        for (const { key, value } of properties) {
-            rule += `  ${dashCase(key)}: ${value};\n`;
-        }
-        rule += "}\n\n";
-    }
-    for (const { key, value } of rules) {
-        if (key.startsWith("@media")) {
-            rule += `${key} {\n`;
-            rule += compileFStyle(value, "  ");
-            rule += `}\n\n`;
-        }
-        else {
-            rule += compileFStyle(value, `${prefix} ${key}`);
-        }
-    }
-    return rule;
-}

package/lib/esm/dom/css/sizing.d.ts

@@ -1,5 +0,0 @@
-import { Width } from "./constants.js";
-export declare function width(amount: Width, block?: "inline"): {
-    width: string;
-    display?: string | undefined;
-};

package/lib/esm/dom/css/sizing.js

@@ -1,10 +0,0 @@
-import { Widths } from "./constants.js";
-export function width(amount, block) {
-    if (amount === undefined && Widths[block] !== undefined) {
-        amount = block;
-    }
-    return {
-        ...(block === "inline" ? { display: "inline-block" } : {}),
-        width: Widths[amount] ?? "0",
-    };
-}

package/lib/esm/dom/dom.d.ts

@@ -1,27 +0,0 @@
-import { Properties } from "./types/css.js";
-declare const Events: unique symbol;
-export declare const CLEAR: unique symbol;
-export declare type EventHandler = EventListenerOrEventListenerObject;
-export declare type DenormChildren = Node | string | typeof CLEAR;
-export declare type DOMElement = Element & ElementCSSInlineStyle;
-export declare type DomAttrs = {
-    class: string | string[];
-    style: Partial<Properties> | string;
-    role: "button" | "list" | "listbox";
-    events: Partial<{
-        [K in keyof HTMLElementEventMap]: EventHandler | null;
-    }>;
-};
-export declare type Attrs<E extends Omit<Element, "update">, S = {}> = Partial<Omit<E, "style"> & S & DomAttrs>;
-export declare type DenormAttrs<E extends Omit<Element, "update">, S = {}> = Attrs<E, S> | DenormChildren;
-declare global {
-    interface Element {
-        [Events]: Map<string, EventHandler>;
-        update(attrs?: DenormAttrs<Element>, ...children: DenormChildren[]): this;
-    }
-}
-export declare type DOMUpdates<E extends Element = Element> = [DenormAttrs<E>, ...DenormChildren[]] | DenormChildren[];
-export declare function normalizeArguments<E extends Element>(attrs?: DenormAttrs<E>, children?: DenormChildren[], defaultAttrs?: Attrs<E>): [Attrs<E>, DenormChildren[]];
-export declare function up<E extends Element>(element: Omit<E, "update">, attrs?: DenormAttrs<E>, ...children: DenormChildren[]): E;
-export declare function update(element: Omit<Element, "update">, attrs: Attrs<Element>, children: DenormChildren[]): Element;
-export {};

package/lib/esm/dom/dom.js

@@ -1,104 +0,0 @@
-const Events = Symbol("events");
-export const CLEAR = Symbol("Clear children");
-function isAttrs(attrs) {
-    if (!attrs) {
-        return false;
-    }
-    if (typeof attrs === "object") {
-        return !attrs.nodeType;
-    }
-    return false;
-}
-export function normalizeArguments(attrs, children = [], defaultAttrs = {}) {
-    let attributes;
-    if (isAttrs(attrs)) {
-        attributes = attrs;
-    }
-    else {
-        if (attrs !== undefined) {
-            children.unshift(attrs);
-        }
-        attributes = defaultAttrs;
-    }
-    return [attributes, children.flat()];
-}
-export function up(element, attrs, ...children) {
-    return update(element, ...normalizeArguments(attrs, children));
-}
-export function update(element, attrs, children) {
-    // Track events, to remove later
-    const $events = (element[Events] ??= new Map());
-    const { style = {}, events = {}, ...rest } = attrs;
-    Object.entries(events).forEach(([k, v]) => {
-        if (v === null) {
-            if ($events.has(k)) {
-                const listener = $events.get(k);
-                element.removeEventListener(k, listener);
-            }
-        }
-        else if (v !== undefined) {
-            element.addEventListener(k, v);
-            $events.set(k, v);
-        }
-    });
-    const _style = element.style;
-    if (_style) {
-        if (typeof style === "string") {
-            _style.cssText = style;
-        }
-        else {
-            Object.entries(style).forEach(([k, v]) => {
-                // @ts-ignore Object.entries is unable to statically look into args
-                _style[k] = v;
-            });
-        }
-    }
-    Object.entries(rest).forEach(([k, v]) => {
-        if (k === "class") {
-            v = Array.isArray(v)
-                ? v
-                : (typeof v === "string" ? v : `${v}`).split(/\s+/m);
-            v
-                .filter((s) => s !== "")
-                .forEach((c) => {
-                if (c.startsWith("!")) {
-                    element.classList.remove(c.substring(1));
-                }
-                else {
-                    element.classList.add(c);
-                }
-            });
-            return;
-        }
-        const useNamespace = element.namespaceURI &&
-            element.namespaceURI != "http://www.w3.org/1999/xhtml";
-        const remove = !v;
-        if (useNamespace) {
-            if (remove) {
-                element.removeAttributeNS(element.namespaceURI, k);
-            }
-            else if (v === true) {
-                element.setAttributeNS(element.namespaceURI, k, k);
-            }
-            else {
-                element.setAttributeNS(element.namespaceURI, k, v);
-            }
-        }
-        else {
-            if (remove) {
-                element.removeAttribute(k);
-            }
-            else if (v === true) {
-                element.setAttribute(k, k);
-            }
-            else {
-                element.setAttribute(k, v);
-            }
-        }
-    });
-    if (children?.length > 0) {
-        element.replaceChildren(...(children[0] === CLEAR ? [] : children));
-    }
-    element.update ??= (attrs, ...children) => update(element, ...normalizeArguments(attrs, children));
-    return element;
-}

package/lib/esm/dom/fc.d.ts

@@ -1,14 +0,0 @@
-import { DenormChildren, DomAttrs } from "./dom.js";
-export declare type Attrs<S> = S & Partial<DomAttrs>;
-export declare const State: unique symbol;
-export interface FCComponent<P extends object, S extends object> extends Element {
-    [State]?: Partial<S>;
-    update(attrs?: Partial<Attrs<P> & DomAttrs> | DenormChildren, ...children: DenormChildren[]): this;
-}
-export interface RenderFn<P extends object, S extends object> {
-    (el: FCComponent<P, S>, attrs: Attrs<P>, children: DenormChildren[]): Element | Element[];
-}
-export interface FCComponentCtor<P extends object, S extends object> {
-    (attrs?: Attrs<P> | DenormChildren, ...children: DenormChildren[]): FCComponent<P, S>;
-}
-export declare function FC<P extends object, S extends object = {}>(name: string, component: RenderFn<P, S>): FCComponentCtor<P, S>;

package/lib/esm/dom/fc.js

@@ -1,35 +0,0 @@
-import { CLEAR, normalizeArguments, update, } from "./dom.js";
-export const State = Symbol();
-export function FC(name, component) {
-    class FCImpl extends HTMLElement {
-        constructor() {
-            super();
-        }
-        [State] = {};
-        #attrs = {};
-        #children = [];
-        update(attrs, ...children) {
-            [attrs, children] = normalizeArguments(attrs, children);
-            if (children[0] === CLEAR) {
-                this.#children = [];
-            }
-            else if (children.length > 0) {
-                this.#children = children;
-            }
-            this.#attrs = { ...this.#attrs, ...attrs };
-            // Apply updates from the attrs to the dom node itself
-            update(this, this.#attrs, []);
-            // Re-run the component function using new element, attrs, and children.
-            const replace = [component(this, this.#attrs, this.#children)];
-            this.replaceChildren(...replace.flat());
-            return this;
-        }
-    }
-    customElements.define(name, FCImpl);
-    const ctor = (attrs, ...children) => {
-        const element = document.createElement(name);
-        element.update(attrs, ...children);
-        return element;
-    };
-    return ctor;
-}

package/lib/esm/dom/fc.test.d.ts

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

package/lib/esm/dom/fc.test.js

@@ -1,21 +0,0 @@
-import { describe, it, expect } from "../scope/index.js";
-import { button, div, form, input, label, small } from "./html.js";
-import { FC } from "./fc.js";
-describe("FC", () => {
-    it("creates FCs", () => {
-        const Input = FC("fc-input", (el, attrs, children) => label(attrs.placeholder ?? attrs.name, input(attrs), ...children));
-        const f = form({ action: "#", method: "POST" }, div({ class: "grid" }, Input({
-            name: "firstName",
-            placeholder: "First Name",
-            required: true,
-        }), Input({
-            name: "lastName",
-            placeholder: "Last Name",
-            required: true,
-        })), Input({ name: "email", type: "email", placeholder: "E-Mail" }, small("We'll never share your information.")), button({ type: "submit" }, "Submit"));
-        // document.body.appendChild(f);
-        expect(f.children.length).toBe(3);
-        expect(f.querySelectorAll("input[required]").length).toBe(2);
-        expect(f.querySelectorAll('input[name="firstName"]').length).toBe(1);
-    });
-});

package/lib/esm/dom/form/form.app.d.ts

@@ -1 +0,0 @@
-export declare const App: () => HTMLElement;

package/lib/esm/dom/form/form.app.js

@@ -1,23 +0,0 @@
-import { article, button, div, main, small } from "../html.js";
-import { Form, Input } from "./form.js";
-export const App = () => main({ class: "container" }, article(Form({
-    events: {
-        submit(event) {
-            console.log("Should see fields for firstname, lastname, email, etc");
-            console.log(event);
-        },
-    },
-}, div({ class: "grid" }, Input({ id: "firstname", placeholder: "First name" }), Input({ id: "lastname", placeholder: "Last name" })), Input({
-    id: "email",
-    type: "email",
-    placeholder: "Email address",
-    required: true,
-}, small("We will never share your email with anyone.")), button({ type: "submit" }, "Submit"), div({ class: "grid" }, Input({ id: "valid", placeholder: "Valid", "aria-invalid": "false" }), Input({
-    id: "invalid",
-    placeholder: "Invalid",
-    "aria-invalid": "true",
-}), Input({ id: "disabled", placeholder: "Disabled", disabled: true }), Input({ id: "readonly", value: "Readonly", readOnly: true }))
-// Dropdown({id: 'fruit', label: "Fruit", placeholder: "Select a fruit...", options: ['Banana', 'Watermelon', 'Apple', 'Orange', 'Mango']}),
-// Radios({legend: 'Size', options: {small: 'Small', medium: 'Medium', large: 'Large', extralarge: "Extra Large"}, checked: 'small'}),
-// Checkboxes({options: {terms: 'I agree to the Terms and Conditions', termsSharing: {label: 'I agree to share my information with partners', disabled: true, checked: true}}),
-)));

package/lib/esm/dom/form/form.d.ts

@@ -1,26 +0,0 @@
-import { DenormChildren } from "../dom.js";
-import { label } from "../html.js";
-import { FormAttributes, InputAttributes, LabelAttributes, OptionAttributes, SelectAttributes } from "../types/html";
-export declare const Form: (attrs: FormAttributes, ...children: DenormChildren[]) => HTMLFormElement;
-export declare const Input: (attrs: InputAttributes, ...children: DenormChildren[]) => HTMLLabelElement;
-export declare const Select: (attrs: {
-    options: string[] | {};
-    selected?: string;
-} & SelectAttributes & LabelAttributes) => HTMLLabelElement;
-export declare const Button: () => void;
-declare const prepareOptions: (attrs: string[] | Record<string, string | {
-    label: string;
-    disabled?: boolean | undefined;
-    selected?: boolean | undefined;
-}>, selected?: string) => Parameters<typeof Option>[0][];
-export declare const Option: (attrs: OptionAttributes) => HTMLOptionElement;
-export declare const Dropdown: (attrs: SelectAttributes | {
-    selected?: string;
-}, ...options: Parameters<typeof prepareOptions>[0][]) => HTMLLabelElement;
-export declare const Radios: () => void;
-export declare const Checks: () => void;
-export declare const Switches: () => void;
-export declare const Radio: (attrs: Omit<InputAttributes, "type">) => HTMLLabelElement;
-export declare const Checkbox: (attrs: Omit<InputAttributes, "type">) => HTMLLabelElement;
-export declare const Switch: () => HTMLLabelElement;
-export {};

package/lib/esm/dom/form/form.js

@@ -1,34 +0,0 @@
-import { form, input, label, option, select } from "../html.js";
-export const Form = (attrs, ...children) => {
-    if (attrs.events?.submit) {
-        const submit = attrs.events.submit;
-        attrs.events.submit = (event) => {
-            event.preventDefault();
-            submit(event);
-        };
-    }
-    return form(attrs, ...children);
-};
-export const Input = (attrs, ...children) => label(input(attrs), ...children);
-export const Select = (attrs) => label({ style: attrs.style ?? {} }, select({ events: attrs.events ?? {} }, ...prepareOptions(attrs.options, attrs.selected).map(Option)));
-export const Button = () => { };
-const prepareOptions = (attrs, selected) => Array.isArray(attrs)
-    ? attrs.map((value) => ({
-        value,
-        label: value,
-        selected: selected == value,
-    }))
-    : Object.entries(attrs).map(([value, label]) => typeof label === "string"
-        ? { value, label, selected: selected === value }
-        : { value, ...label });
-export const Option = (attrs) => option(attrs);
-export const Dropdown = (attrs, ...options) => Select({
-    ...attrs,
-    options: typeof options[0] == "string" ? options : options[0],
-});
-export const Radios = () => { };
-export const Checks = () => { };
-export const Switches = () => { };
-export const Radio = (attrs) => Input({ type: "radio" });
-export const Checkbox = (attrs) => Input({ type: "checkbox" });
-export const Switch = () => Checkbox({ role: "switch" });

package/lib/esm/dom/form/form.test.js

@@ -1 +0,0 @@
-"use strict";

package/lib/esm/dom/html.d.ts

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

package/lib/esm/dom/html.js

@@ -1,114 +0,0 @@
-import { up } from "./dom.js";
-const makeHTMLElement = (name) => (attrs, ...children) => up(document.createElement(name), attrs, ...children);
-export const a = makeHTMLElement("a");
-export const abbr = makeHTMLElement("abbr");
-export const address = makeHTMLElement("address");
-export const area = makeHTMLElement("area");
-export const article = makeHTMLElement("article");
-export const aside = makeHTMLElement("aside");
-export const audio = makeHTMLElement("audio");
-export const b = makeHTMLElement("b");
-export const base = makeHTMLElement("base");
-export const bdi = makeHTMLElement("bdi");
-export const bdo = makeHTMLElement("bdo");
-export const blockquote = makeHTMLElement("blockquote");
-export const body = makeHTMLElement("body");
-export const br = makeHTMLElement("br");
-export const button = makeHTMLElement("button");
-export const canvas = makeHTMLElement("canvas");
-export const caption = makeHTMLElement("caption");
-export const cite = makeHTMLElement("cite");
-export const code = makeHTMLElement("code");
-export const col = makeHTMLElement("col");
-export const colgroup = makeHTMLElement("colgroup");
-export const data = makeHTMLElement("data");
-export const datalist = makeHTMLElement("datalist");
-export const dd = makeHTMLElement("dd");
-export const del = makeHTMLElement("del");
-export const details = makeHTMLElement("details");
-export const dfn = makeHTMLElement("dfn");
-export const dialog = makeHTMLElement("dialog");
-export const div = makeHTMLElement("div");
-export const dl = makeHTMLElement("dl");
-export const dt = makeHTMLElement("dt");
-export const em = makeHTMLElement("em");
-export const embed = makeHTMLElement("embed");
-export const fieldset = makeHTMLElement("fieldset");
-export const figcaption = makeHTMLElement("figcaption");
-export const figure = makeHTMLElement("figure");
-export const footer = makeHTMLElement("footer");
-export const form = makeHTMLElement("form");
-export const h1 = makeHTMLElement("h1");
-export const h2 = makeHTMLElement("h2");
-export const h3 = makeHTMLElement("h3");
-export const h4 = makeHTMLElement("h4");
-export const h5 = makeHTMLElement("h5");
-export const h6 = makeHTMLElement("h6");
-export const head = makeHTMLElement("head");
-export const header = makeHTMLElement("header");
-export const hgroup = makeHTMLElement("hgroup");
-export const hr = makeHTMLElement("hr");
-export const html = makeHTMLElement("html");
-export const i = makeHTMLElement("i");
-export const iframe = makeHTMLElement("iframe");
-export const img = makeHTMLElement("img");
-export const input = makeHTMLElement("input");
-export const ins = makeHTMLElement("ins");
-export const kbd = makeHTMLElement("kbd");
-export const label = makeHTMLElement("label");
-export const legend = makeHTMLElement("legend");
-export const li = makeHTMLElement("li");
-export const link = makeHTMLElement("link");
-export const main = makeHTMLElement("main");
-export const map = makeHTMLElement("map");
-export const mark = makeHTMLElement("mark");
-export const menu = makeHTMLElement("menu");
-export const meta = makeHTMLElement("meta");
-export const meter = makeHTMLElement("meter");
-export const nav = makeHTMLElement("nav");
-export const noscript = makeHTMLElement("noscript");
-export const object = makeHTMLElement("object");
-export const ol = makeHTMLElement("ol");
-export const optgroup = makeHTMLElement("optgroup");
-export const option = makeHTMLElement("option");
-export const output = makeHTMLElement("output");
-export const p = makeHTMLElement("p");
-export const param = makeHTMLElement("param");
-export const picture = makeHTMLElement("picture");
-export const pre = makeHTMLElement("pre");
-export const progress = makeHTMLElement("progress");
-export const q = makeHTMLElement("q");
-export const rp = makeHTMLElement("rp");
-export const rt = makeHTMLElement("rt");
-export const ruby = makeHTMLElement("ruby");
-export const s = makeHTMLElement("s");
-export const samp = makeHTMLElement("samp");
-export const script = makeHTMLElement("script");
-export const section = makeHTMLElement("section");
-export const select = makeHTMLElement("select");
-export const slot = makeHTMLElement("slot");
-export const small = makeHTMLElement("small");
-export const source = makeHTMLElement("source");
-export const span = makeHTMLElement("span");
-export const strong = makeHTMLElement("strong");
-export const style = makeHTMLElement("style");
-export const sub = makeHTMLElement("sub");
-export const summary = makeHTMLElement("summary");
-export const sup = makeHTMLElement("sup");
-export const table = makeHTMLElement("table");
-export const tbody = makeHTMLElement("tbody");
-export const td = makeHTMLElement("td");
-export const template = makeHTMLElement("template");
-export const textarea = makeHTMLElement("textarea");
-export const tfoot = makeHTMLElement("tfoot");
-export const th = makeHTMLElement("th");
-export const thead = makeHTMLElement("thead");
-export const time = makeHTMLElement("time");
-export const title = makeHTMLElement("title");
-export const tr = makeHTMLElement("tr");
-export const track = makeHTMLElement("track");
-export const u = makeHTMLElement("u");
-export const ul = makeHTMLElement("ul");
-export const htmlvar = makeHTMLElement("var"); // var is reserved, export as variable
-export const video = makeHTMLElement("video");
-export const wbr = makeHTMLElement("wbr");

package/lib/esm/dom/html.test.d.ts

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