@davidsouther/jiffies 1.0.0 → 2.0.1

package/src/test.mjs

@@ -5,25 +5,29 @@ import { execute } from "./scope/execute.js";
 import { asXML } from "./scope/display/junit.js";
 import { onConsole } from "./scope/display/console.js";
 
-await import("./test_all.js");
+async function main() {
+  await import("./test_all.js");
 
-(async function () {
-  const results = await execute();
+  (async function () {
+    const results = await execute();
 
-  const FLAGS = parse(process.argv);
+    const FLAGS = parse(process.argv);
 
-  switch (FLAGS.asString("mode", "console")) {
-    case "junit":
-      const xml = asXML(results);
-      console.log(xml);
-      break;
-    case "console":
-    default:
-      onConsole(results);
-      break;
-  }
+    switch (FLAGS.asString("mode", "console")) {
+      case "junit":
+        const xml = asXML(results);
+        console.log(xml);
+        break;
+      case "console":
+      default:
+        onConsole(results);
+        break;
+    }
 
-  if (results.failed > 0) {
-    process.exit(1);
-  }
-})();
+    if (results.failed > 0) {
+      process.exit(1);
+    }
+  })();
+}
+
+main();

package/src/test_all.ts

@@ -2,14 +2,6 @@
 // discarded during transpilation.
 import { describe, expect, it } from "./scope/index.js";
 
-import "./context.test.js";
-import "./equal.test.js";
-import "./flags.test.js";
-import "./fs.test.js";
-import "./generator.test.js";
-import "./lock.test.js";
-import "./result.test.js";
-
 describe("Test executor", () => {
   it("matches equality", () => {
     expect(1).toBe(1);
@@ -19,3 +11,23 @@ describe("Test executor", () => {
     expect(() => expect(1).toBe(2)).toThrow();
   });
 });
+
+import "./context.test.js";
+import "./diff.test.js";
+import "./equal.test.js";
+import "./flags.test.js";
+import "./fs.test.js";
+import "./generator.test.js";
+import "./lock.test.js";
+import "./result.test.js";
+import "./observable/observable.test.js";
+
+import * as components from "./components/test.js";
+import * as dom from "./dom/test.js";
+
+if (process?.env.CI?.toLowerCase() !== "true") {
+  (async () => {
+    await components.loadTests();
+    await dom.loadTests();
+  })();
+}

package/build/components/test.js

@@ -1,2 +0,0 @@
-await import("./virtual_scroll.test.js");
-export {};

package/build/dom/dom.d.ts

@@ -1,27 +0,0 @@
-import * as CSS from "./types/css";
-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 & DocumentAndElementEventHandlers & ElementCSSInlineStyle;
-export declare type Updater<E extends DOMElement> = Omit<E, "style"> & {
-    [Events]?: Map<string, EventHandler>;
-    update?: (attrs?: DenormAttrs<E>, ...children: DenormChildren[]) => Node;
-};
-export declare type Updatable<E extends Element> = Omit<E, "style"> & {
-    [Events]: Map<string, EventHandler>;
-    update: (attrs?: DenormAttrs<E>, ...children: DenormChildren[]) => Node;
-};
-export declare type DomAttrs = {
-    class: string;
-    style: Partial<CSS.Properties>;
-    events: Partial<{
-        [K in keyof HTMLElementEventMap]: EventHandler;
-    }>;
-};
-export declare type Attrs<E extends Element, S = {}> = Partial<E & S & DomAttrs>;
-export declare type DenormAttrs<E extends Element, S = {}> = Attrs<E, S> | 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 DOMElement>(element: E, attrs?: DenormAttrs<E>, ...children: DenormChildren[]): Updatable<E>;
-export declare function update<E extends DOMElement>(element: Updater<E>, attrs: Attrs<E>, children: DenormChildren[]): Updatable<E>;
-export {};

package/build/dom/form/form.app.d.ts

@@ -1 +0,0 @@
-export declare const App: () => import("../html.js").UHTMLElement<HTMLElement>;

package/build/dom/html.d.ts

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

package/build/dom/router/link.d.ts

@@ -1,6 +0,0 @@
-export interface Link {
-    href: string;
-    link: string;
-    target: () => Node;
-}
-export declare const link: ({ href, link }: Link) => import("../html.js").UHTMLElement<HTMLAnchorElement>;

package/build/dom/svg.d.ts

@@ -1,64 +0,0 @@
-import { DenormAttrs, DenormChildren } from "./dom.js";
-export declare const a: (attrs?: DenormAttrs<SVGAElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGAElement>;
-export declare const animate: (attrs?: DenormAttrs<SVGAnimateElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGAnimateElement>;
-export declare const animateMotion: (attrs?: DenormAttrs<SVGAnimateMotionElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGAnimateMotionElement>;
-export declare const animateTransform: (attrs?: DenormAttrs<SVGAnimateTransformElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGAnimateTransformElement>;
-export declare const circle: (attrs?: DenormAttrs<SVGCircleElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGCircleElement>;
-export declare const clipPath: (attrs?: DenormAttrs<SVGClipPathElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGClipPathElement>;
-export declare const defs: (attrs?: DenormAttrs<SVGDefsElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGDefsElement>;
-export declare const desc: (attrs?: DenormAttrs<SVGDescElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGDescElement>;
-export declare const ellipse: (attrs?: DenormAttrs<SVGEllipseElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGEllipseElement>;
-export declare const feBlend: (attrs?: DenormAttrs<SVGFEBlendElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEBlendElement>;
-export declare const feColorMatrix: (attrs?: DenormAttrs<SVGFEColorMatrixElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEColorMatrixElement>;
-export declare const feComponentTransfer: (attrs?: DenormAttrs<SVGFEComponentTransferElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEComponentTransferElement>;
-export declare const feComposite: (attrs?: DenormAttrs<SVGFECompositeElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFECompositeElement>;
-export declare const feConvolveMatrix: (attrs?: DenormAttrs<SVGFEConvolveMatrixElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEConvolveMatrixElement>;
-export declare const feDiffuseLighting: (attrs?: DenormAttrs<SVGFEDiffuseLightingElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEDiffuseLightingElement>;
-export declare const feDisplacementMap: (attrs?: DenormAttrs<SVGFEDisplacementMapElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEDisplacementMapElement>;
-export declare const feDistantLight: (attrs?: DenormAttrs<SVGFEDistantLightElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEDistantLightElement>;
-export declare const feDropShadow: (attrs?: DenormAttrs<SVGFEDropShadowElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEDropShadowElement>;
-export declare const feFlood: (attrs?: DenormAttrs<SVGFEFloodElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEFloodElement>;
-export declare const feFuncA: (attrs?: DenormAttrs<SVGFEFuncAElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEFuncAElement>;
-export declare const feFuncB: (attrs?: DenormAttrs<SVGFEFuncBElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEFuncBElement>;
-export declare const feFuncG: (attrs?: DenormAttrs<SVGFEFuncGElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEFuncGElement>;
-export declare const feFuncR: (attrs?: DenormAttrs<SVGFEFuncRElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEFuncRElement>;
-export declare const feGaussianBlur: (attrs?: DenormAttrs<SVGFEGaussianBlurElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEGaussianBlurElement>;
-export declare const feImage: (attrs?: DenormAttrs<SVGFEImageElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEImageElement>;
-export declare const feMerge: (attrs?: DenormAttrs<SVGFEMergeElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEMergeElement>;
-export declare const feMergeNode: (attrs?: DenormAttrs<SVGFEMergeNodeElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEMergeNodeElement>;
-export declare const feMorphology: (attrs?: DenormAttrs<SVGFEMorphologyElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEMorphologyElement>;
-export declare const feOffset: (attrs?: DenormAttrs<SVGFEOffsetElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEOffsetElement>;
-export declare const fePointLight: (attrs?: DenormAttrs<SVGFEPointLightElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFEPointLightElement>;
-export declare const feSpecularLighting: (attrs?: DenormAttrs<SVGFESpecularLightingElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFESpecularLightingElement>;
-export declare const feSpotLight: (attrs?: DenormAttrs<SVGFESpotLightElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFESpotLightElement>;
-export declare const feTile: (attrs?: DenormAttrs<SVGFETileElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFETileElement>;
-export declare const feTurbulence: (attrs?: DenormAttrs<SVGFETurbulenceElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFETurbulenceElement>;
-export declare const filter: (attrs?: DenormAttrs<SVGFilterElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGFilterElement>;
-export declare const foreignObject: (attrs?: DenormAttrs<SVGForeignObjectElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGForeignObjectElement>;
-export declare const g: (attrs?: DenormAttrs<SVGGElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGGElement>;
-export declare const image: (attrs?: DenormAttrs<SVGImageElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGImageElement>;
-export declare const line: (attrs?: DenormAttrs<SVGLineElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGLineElement>;
-export declare const linearGradient: (attrs?: DenormAttrs<SVGLinearGradientElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGLinearGradientElement>;
-export declare const marker: (attrs?: DenormAttrs<SVGMarkerElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGMarkerElement>;
-export declare const mask: (attrs?: DenormAttrs<SVGMaskElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGMaskElement>;
-export declare const metadata: (attrs?: DenormAttrs<SVGMetadataElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGMetadataElement>;
-export declare const mpath: (attrs?: DenormAttrs<SVGMPathElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGMPathElement>;
-export declare const path: (attrs?: DenormAttrs<SVGPathElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGPathElement>;
-export declare const pattern: (attrs?: DenormAttrs<SVGPatternElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGPatternElement>;
-export declare const polygon: (attrs?: DenormAttrs<SVGPolygonElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGPolygonElement>;
-export declare const polyline: (attrs?: DenormAttrs<SVGPolylineElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGPolylineElement>;
-export declare const radialGradient: (attrs?: DenormAttrs<SVGRadialGradientElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGRadialGradientElement>;
-export declare const rect: (attrs?: DenormAttrs<SVGRectElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGRectElement>;
-export declare const script: (attrs?: DenormAttrs<SVGScriptElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGScriptElement>;
-export declare const set: (attrs?: DenormAttrs<SVGSetElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGSetElement>;
-export declare const stop: (attrs?: DenormAttrs<SVGStopElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGStopElement>;
-export declare const style: (attrs?: DenormAttrs<SVGStyleElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGStyleElement>;
-export declare const svg: (attrs?: DenormAttrs<SVGSVGElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGSVGElement>;
-export declare const svgswitch: (attrs?: DenormAttrs<SVGSwitchElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGSwitchElement>;
-export declare const symbol: (attrs?: DenormAttrs<SVGSymbolElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGSymbolElement>;
-export declare const text: (attrs?: DenormAttrs<SVGTextElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGTextElement>;
-export declare const textPath: (attrs?: DenormAttrs<SVGTextPathElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGTextPathElement>;
-export declare const title: (attrs?: DenormAttrs<SVGTitleElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGTitleElement>;
-export declare const tspan: (attrs?: DenormAttrs<SVGTSpanElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGTSpanElement>;
-export declare const use: (attrs?: DenormAttrs<SVGUseElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGUseElement>;
-export declare const view: (attrs?: DenormAttrs<SVGViewElement, {}> | undefined, ...children: DenormChildren[]) => import("./dom.js").Updatable<SVGViewElement>;

package/build/dom/test.js

@@ -1,2 +0,0 @@
-await Promise.all([import("./html.test.js"), import("./fc.test.js")]);
-export {};

package/build/test.mjs

@@ -1,23 +0,0 @@
-#!/usr/bin/env node
-import { parse } from "./flags.js";
-import { execute } from "./scope/execute.js";
-import { asXML } from "./scope/display/junit.js";
-import { onConsole } from "./scope/display/console.js";
-await import("./test_all.js");
-(async function () {
-    const results = await execute();
-    const FLAGS = parse(process.argv);
-    switch (FLAGS.asString("mode", "console")) {
-        case "junit":
-            const xml = asXML(results);
-            console.log(xml);
-            break;
-        case "console":
-        default:
-            onConsole(results);
-            break;
-    }
-    if (results.failed > 0) {
-        process.exit(1);
-    }
-})();

package/src/observable/observable._js

@@ -1,175 +0,0 @@
-// import { Observable, ReplaySubject } from "rxjs";
-// import { tap } from "rxjs/operators";
-import { display } from "../display.js";
-import { DEFAULT_LOGGER, Logger } from "../log.js";
-
-/**
- * @template T
- * @typedef Next
- * @property {T} value
- * @property {false} completed
- * @property {false} failed
- */
-
-/**
- * @template E
- * @typedef Error
- * @property {E} error
- * @property {false} completed
- * @property {true} failed
- */
-
-/**
- * @typedef Completed
- * @property {true} completed
- * @property {false} failed
- */
-
-/**
- * @typedef Failed
- * @property {true} completed
- * @property {true} failed
- */
-
-/**
- * @template T
- * @template E
- * @typedef {Next<T> | Error<E> | Completed | Failed} Event
- */
-
-/**
- * @template T
- * @param {T} value
- * @returns {Next<T>}
- */
-export const next = (value) => ({ value, completed: false, failed: false });
-
-/**
- * @template E
- * @param {E} e
- * @returns {Error<E>}
- */
-export const error = (e) => ({ error: e, completed: false, failed: true });
-
-/** @returns {Completed} */
-export const completed = () => ({ completed: true, failed: false });
-
-/** @returns {Failed} */
-export const failed = () => ({ completed: true, failed: true });
-
-/**
- * @template T
- * @param {Event<T, unknown>} event
- * @returns {event is Next<T>}
- */
-export const isNext = (event) =>
-  !event.completed && !event.failed && event.value !== undefined;
-
-/**
- * @template E
- * @param {Event<unknown, E>} event
- * @returns {event is Error<E>}
- */
-export const isError = (event) => event.failed && !event.completed;
-
-/**
- * @param {Event<unknown, unknown>} event
- * @returns {event is Completed}
- */
-export const isCompleted = (event) => event.completed && !event.failed;
-
-/**
- * @param {Event<unknown, unknown>} event
- * @returns {event is Failed}
- */
-export const isFailed = (event) => event.completed && event.failed;
-
-/**
- * @template T
- * @param {T|Event<T, unknown>} t
- * @returns {t is Event<T, unknown>}
- */
-export const isEvent = (t) => {
-  /* @type unknown */
-  const b = t;
-  return isNext(b) || isError(b) || isCompleted(b);
-};
-
-/**
- * @template T
- * @param {(T|Event<T, unknown>)[]} a
- * @returns {(Event<T, unknown>)[]}
- */
-export const asEvents = (a) => a.map((e) => (isEvent(e) ? e : next(e)));
-
-/**
- * @template T
- * @param {Event<T, unknown>} event
- * @returns {string}
- */
-const marble = (event) =>
-  isError(event)
-    ? "X"
-    : isFailed(event)
-    ? "!"
-    : isCompleted(event)
-    ? "|"
-    : `(${display(event.value)})`;
-
-/**
- * @template T
- * @param {(Event<T, unknown>)[]} events
- * @returns string
- */
-export const marbles = (events) => `:${events.map(marble).join("-")}`;
-
-/**
- * @template T
- * @template E
- * @param {Observable<T>} input$
- * @returns {(Event<T, E>)[]}
- */
-export const collect = (input$) => {
-  /** @type {(Event<T, E>)[]} */
-  const collected = [];
-
-  const subscription = input$.subscribe({
-    next: (/* @type T */ x) => collected.push(next(x)),
-    error: (/* @type E */ e) => collected.push(error(e)),
-    complete: () => collected.push(completed()),
-  });
-
-  subscription.unsubscribe();
-
-  return collected;
-};
-
-/**
- * @template T
- * @param {Logger} logger
- * @returns {(o: Observable<T>) => Observable<T>}
- */
-export const watch =
-  (logger = DEFAULT_LOGGER) =>
-  /**
-   * @template E
-   * @param {Observable<T>} observable
-   * @returns {Observable<T>}
-   */
-  (observable) => {
-    observable.pipe(
-      tap({
-        next(/* @type T */ t) {
-          logger.info(t);
-        },
-        complete() {
-          logger.info("Observable completed");
-        },
-        error(/* @type E */ e) {
-          logger.warn(e);
-        },
-      })
-    );
-
-    return observable;
-  };