@loadbare/app 0.4.0 → 0.5.1

package/README.md

@@ -1,8 +1,13 @@
 # Loadbare App
 
-> **This project is being refactored.** While @loadbare/db is highly mature
-> and in use reliably by the author, this ui project is being built from
-> scratch.  We know what it will do, but everything has to be built.
+The fundamentals of @loadbare/app are fixed, we are now working
+on completeness.
+
+> This package is being prepped for 1.0, current work is:
+> 1. docs (nearly done)
+> 2. demos (must be normalized and checked against docs)
+> 3. test a release/use cycle, make sure all instructions work
+
 
 ## Purpose
 
@@ -14,82 +19,48 @@ Loadbare App has two twin primary goals
   to near zero, so the app developer is spending maximum time on the app
   instead of the tooling.
 - To give the developer a fighting chance to provide complete server round
-  trips, from request to final paint, in 300ms or less
-
-## Current WIP
-
-Restructuring the docs.  Right now "getting started"
-and other docs are very limited because they only document what we've
-tested and proven.  Once the build is doing everything it needs to,
-then we can write the docs to flow more like:
-- setting up your infra:
-  - add the package
-  - chrome
-  - express server
-- writing a page with mock db access
-  - wiring express to call our handler
-  - the html
-  - hooks and handlers
-- plugging in your database, just replace mock with your
-  own adapter.
-
-
-## SLOP LINE
-
-Below here is LLM-generated slop, not yet edited to conform to our rules
-against LLM-generated markdown docs.
-
-
-## Ideals
-
-Loadbare App should be fully inspectable. "View Source" should show the source, and
-what it shows should be what the developer tools show. Frameworks commonly
-lose this property as a side effect of how they generate markup; Loadbare App treats
-keeping it as a requirement.
-
-Stated precisely, because two things legitimately differ: no markup exists in
-the DOM that is not in view-source, and the difference between view-source and
-the developer tools is exactly the dynamic half. Navigation moves markup that
-is already in the document, and data lands on it as attributes. Neither
-invents markup.
-
-Some widgets, an enriched table being the obvious one, must clone a template
-once per row, and the number of rows is not known until the data arrives. That
-cloning is allowable: the markup is in view-source, and only the count comes
-from the data. Where the boundary of that allowance sits is stated in
-[Theory of Loadbare App](./docs/theory.md).
-
-Nothing here is about protecting the HTML, which is visible in the developer
-tools regardless. It is about the technology being open to inspection by
-whoever wants to look.
-
-## Documentation
-
-[`docs/theory.md`](./docs/theory.md) states what Loadbare App is and
-why. It is authoritative; where any other document disagrees with it, the other
-document is wrong.
-
-- [Programmer's Guide](./docs/guide.md) — how to build an application with
-  Loadbare App. Each section is marked with whether the code does it yet.
-- [Hosting a Loadbare App Application](./docs/hosting.md) — registering pages,
-  assembling the shell, navigation, and serving the two endpoints from
-  Express. Everything you do once per application rather than once per page.
-- [Theory of Loadbare App](./docs/theory.md) — scope, the performance budget,
-  the thesis, and what is settled so far.
-- [Communication channels](./docs-llm-slop/communication-channels.md) — what
-  the host/data split means on the wire.
-- [Data binding](./docs-llm-slop/data-binding.md) — the addressing vocabulary
-  and how a data fragment lands on a widget.
-- [Requests](./docs-llm-slop/requests.md) — how a widget reaches the server,
-  and what the server may trust.
-- [Bundling](./docs-llm-slop/bundling.md) — how the static half is packaged
-  and shipped.
-- [Expansion](./docs-llm-slop/expansion.md) — how one authored tag becomes the
-  tree it stands for, and why the definition language has no control flow.
-- [Coming from other frameworks](./docs-llm-slop/coming-from-other-frameworks.md)
-  — what changes if you already know React, Angular, htmx or Datastar.
-- [Prior art](./docs-llm-slop/prior-art.md) — what has been done before, and
-  why nothing was adopted off the shelf.
-
-The guide states the API as it should be and marks each section with whether
-the code does it yet. Where the two disagree, the code is what moves.
+  trips, from request to final paint, in 300ms or less.
+
+## Widgets
+
+This package ships one custom element, `<lb-hub>`. The widgets an application
+displays data with — `lb-input`, `lb-select`, `lb-list`, `lb-options`,
+`lb-table`, `lb-picker` — ship separately, in
+[@loadbare/widgets](../widgets/README.md):
+
+```
+npm install @loadbare/app @loadbare/widgets
+```
+
+```ts
+// src/imports.ts
+export default ["@loadbare/widgets"];
+```
+
+The builder resolves that package the way it resolves anyone else's, so a
+widget library written by a third party, or by the application's own team,
+arrives through the same one line. See
+[The Basic Widget Library](./docs/reference/widgets.md) for what each widget
+binds and sends, and
+[Using Widget Libraries](./docs/tutorials/090-using-widget-libraries.md) for
+what listing a package does.
+
+## Tutorials
+
+[Getting Started](./docs/tutorials/000-getting-started.md): a step-by-step
+guide to building a database app, introducing one new concept in
+each lesson.
+
+## Reference
+
+[The Elements of a Loadbare Application](./docs/reference/overview.md)
+
+## Theory
+
+[Theory](./docs/theory.md): the design rationale behind Loadbare App.
+
+## Roadmap Items for 1.0 and 1.1
+
+[Roadmap](./docs/roadmap.md)
+
+

package/dist/build/assemble.d.ts

@@ -9,23 +9,25 @@
  * expanded host is wrapped in `<template id="page-<name>">` and, together
  * with the chrome's own expanded body content, spliced back into the
  * chrome's `<body>`. The result is the one document a server has to serve
- * for every route — see docs/getting-started.md and docs/application-chrome.md.
+ * for every route — see docs/tutorials/000-getting-started.md and
+ * docs/reference/builder.md.
  *
  * Every path here is a parameter, resolved once by build/locations.ts — this
  * module never reconstructs one of its own, and never reads a directory
  * looking for pages or widgets; it is handed exactly which files those are.
  */
-import type { PageFile, WidgetSource } from "./locations.js";
+import type { PageFile } from "./locations.js";
+import type { OriginScan } from "./origins.js";
 export interface AssembleOptions {
     chromeFile: string;
     pages: PageFile[];
-    widgets: Map<string, WidgetSource>;
-    builtinWidgetsDir: string;
+    /** Every origin, already scanned, in cascade order — see build/origins.ts. */
+    scans: OriginScan[];
 }
 export interface Assembled {
     html: string;
     /** Every custom element tag left in the document once expansion is done. */
     usedTags: Set<string>;
 }
-export declare function assemble({ chromeFile, pages, widgets, builtinWidgetsDir, }: AssembleOptions): Promise<Assembled>;
+export declare function assemble({ chromeFile, pages, scans, }: AssembleOptions): Promise<Assembled>;
 //# sourceMappingURL=assemble.d.ts.map

package/dist/build/assemble.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assemble.d.ts","sourceRoot":"","sources":["../../build/assemble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAWH,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE7D,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACnC,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACvB;AAED,wBAAsB,QAAQ,CAAC,EAC7B,UAAU,EACV,KAAK,EACL,OAAO,EACP,iBAAiB,GAClB,EAAE,eAAe,GAAG,OAAO,CAAC,SAAS,CAAC,CA2CtC"}
+{"version":3,"file":"assemble.d.ts","sourceRoot":"","sources":["../../build/assemble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAeH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAuB/C,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,8EAA8E;IAC9E,KAAK,EAAE,UAAU,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACvB;AAED,wBAAsB,QAAQ,CAAC,EAC7B,UAAU,EACV,KAAK,EACL,KAAK,GACN,EAAE,eAAe,GAAG,OAAO,CAAC,SAAS,CAAC,CA2CtC"}

package/dist/build/assemble.js

@@ -9,23 +9,42 @@
  * expanded host is wrapped in `<template id="page-<name>">` and, together
  * with the chrome's own expanded body content, spliced back into the
  * chrome's `<body>`. The result is the one document a server has to serve
- * for every route — see docs/getting-started.md and docs/application-chrome.md.
+ * for every route — see docs/tutorials/000-getting-started.md and
+ * docs/reference/builder.md.
  *
  * Every path here is a parameter, resolved once by build/locations.ts — this
  * module never reconstructs one of its own, and never reads a directory
  * looking for pages or widgets; it is handed exactly which files those are.
  */
 import { readFile } from "node:fs/promises";
-import { addDefinitions, customElementTags, expand, loadDefinitions, } from "./expand.js";
+import { JSDOM } from "jsdom";
+import { addDefinitions, customElementTags, expand, } from "./expand.js";
 import { formatHtml } from "./format.js";
-import { PAGE_TEMPLATE_PREFIX } from "../core/lb-constants.js";
-export async function assemble({ chromeFile, pages, widgets, builtinWidgetsDir, }) {
-    const widgetHtmlFiles = new Map();
-    for (const [tag, source] of widgets) {
-        if (source.html)
-            widgetHtmlFiles.set(tag, source.html);
+import { ATTR_UNKNOWN_PAGE, PAGE_TEMPLATE_PREFIX, } from "../core/lb-constants.js";
+/**
+ * The hub calls showModal() on whatever carries lb-unknown-page (hub/lb-hub.ts),
+ * so a chrome that puts the attribute on anything else would fail at
+ * runtime, on whichever page happens to 404 first, rather than at build
+ * time. The attribute is optional; only a wrong element on it is an error.
+ */
+function checkUnknownPageDialog(chromeFile, expandedBody) {
+    const fragment = JSDOM.fragment(expandedBody);
+    const el = fragment.querySelector(`[${ATTR_UNKNOWN_PAGE}]`);
+    if (!el)
+        return;
+    if (el.tagName !== "DIALOG") {
+        throw new Error(`assemble: '${chromeFile}' declares ${ATTR_UNKNOWN_PAGE} on ` +
+            `<${el.tagName.toLowerCase()}>, must be a <dialog>`);
+    }
+}
+export async function assemble({ chromeFile, pages, scans, }) {
+    // One layer per origin, in order, so a later origin's definition overrides
+    // an earlier one's for the same tag. Each layer is checked for cycles as it
+    // lands, against everything merged so far.
+    let defs = {};
+    for (const scan of scans) {
+        defs = await addDefinitions(defs, scan.definitions);
     }
-    const defs = await addDefinitions(await loadDefinitions([builtinWidgetsDir]), widgetHtmlFiles);
     const templates = [];
     for (const { name, file } of pages) {
         const authored = await readFile(file, "utf-8");
@@ -45,6 +64,7 @@ export async function assemble({ chromeFile, pages, widgets, builtinWidgetsDir,
     }
     const [whole, bodyAttrs, bodyContent] = body;
     const expandedBody = expand(bodyContent, defs);
+    checkUnknownPageDialog(chromeFile, expandedBody);
     const withPages = chromeSource.replace(whole, () => `<body${bodyAttrs}>${expandedBody}\n${templates.join("\n")}\n</body>`);
     return {
         html: await formatHtml(withPages),

package/dist/build/cli.d.ts

@@ -2,26 +2,34 @@
 /**
  * loadbare-app-build — assemble a chrome file and its pages into one HTML
  * document, and bundle the client script for exactly the custom elements
- * that document uses. See docs/getting-started.md.
+ * that document uses. See docs/tutorials/000-getting-started.md.
  *
- *   loadbare-app-build [--src src] [--out dist] [--watch]
+ *   loadbare-app-build [--src src] [--out dist] [--watch] [--minify]
  *
- * `--src` names the tree scanned for everything: the one `*.chrome.html`
- * file, every `*.page.html` page, every other `.html`/`.ts` as a widget,
- * `*.hooks.ts`/`*.queries.ts` pairs, and `elements.ts` if there is one — see
- * build/locations.ts for how a file's name says what it is. The assembled
- * document is written to `<out>/app.html`; the client bundle to
- * `<out>/client.js`, by way of a generated `<out>/client-entry.ts` — see
+ * `--src` names the application's own tree: the one `chrome.html` file,
+ * every `*.page.html` page, its `*.hooks.ts`/`*.queries.ts` pairs, and
+ * `imports.ts` if there is one — see build/locations.ts. It is also the last
+ * origin in the cascade that supplies widget definitions, widget scripts and
+ * stylesheets; this package's own widgets come first and each package named
+ * in `imports.ts` in between, all scanned the same way — see
+ * build/origins.ts.
+ *
+ * The assembled document is written to `<out>/app.html`; the client bundle
+ * to `<out>/client.js`, by way of a generated `<out>/client-entry.ts` — see
  * build/elements.ts for how a tag is resolved to the script that registers
  * it. When any page has a hooks or queries file, the hub registry that used
  * to be hand-maintained is written to `<out>/pages.ts` — see build/pages.ts.
- * Every `.css` file anywhere under `<src>` is concatenated, in the order
- * described in build/locations.ts, and written to `<out>/app.css` — see
- * build/styles.ts.
+ * Every origin's stylesheets are concatenated in that same cascade order and
+ * written to `<out>/app.css` — see build/styles.ts.
+ *
+ * `--minify` minifies both output files: esbuild's own minifier for
+ * `client.js`, as part of the same bundling pass, and esbuild's CSS
+ * transform for `app.css`, as a pass over the concatenation above. `app.html`
+ * is never minified — it is markup an application may still want to read.
  *
  * Without `--watch`, this runs once and exits. With it, every `.html`,
  * `.ts` and `.css` file under `<src>` is watched — a page, a widget's
- * markup, a widget's class, a stylesheet, and `elements.ts` all feed the
+ * markup, a widget's class, a stylesheet, and `imports.ts` all feed the
  * same build — and a rebuild that throws is reported without stopping the
  * watch. There is no dev server and no browser reload here, only the files
  * on disk staying current for the next manual refresh.

package/dist/build/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../build/cli.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../build/cli.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG"}

package/dist/build/cli.js

@@ -2,26 +2,34 @@
 /**
  * loadbare-app-build — assemble a chrome file and its pages into one HTML
  * document, and bundle the client script for exactly the custom elements
- * that document uses. See docs/getting-started.md.
+ * that document uses. See docs/tutorials/000-getting-started.md.
  *
- *   loadbare-app-build [--src src] [--out dist] [--watch]
+ *   loadbare-app-build [--src src] [--out dist] [--watch] [--minify]
  *
- * `--src` names the tree scanned for everything: the one `*.chrome.html`
- * file, every `*.page.html` page, every other `.html`/`.ts` as a widget,
- * `*.hooks.ts`/`*.queries.ts` pairs, and `elements.ts` if there is one — see
- * build/locations.ts for how a file's name says what it is. The assembled
- * document is written to `<out>/app.html`; the client bundle to
- * `<out>/client.js`, by way of a generated `<out>/client-entry.ts` — see
+ * `--src` names the application's own tree: the one `chrome.html` file,
+ * every `*.page.html` page, its `*.hooks.ts`/`*.queries.ts` pairs, and
+ * `imports.ts` if there is one — see build/locations.ts. It is also the last
+ * origin in the cascade that supplies widget definitions, widget scripts and
+ * stylesheets; this package's own widgets come first and each package named
+ * in `imports.ts` in between, all scanned the same way — see
+ * build/origins.ts.
+ *
+ * The assembled document is written to `<out>/app.html`; the client bundle
+ * to `<out>/client.js`, by way of a generated `<out>/client-entry.ts` — see
  * build/elements.ts for how a tag is resolved to the script that registers
  * it. When any page has a hooks or queries file, the hub registry that used
  * to be hand-maintained is written to `<out>/pages.ts` — see build/pages.ts.
- * Every `.css` file anywhere under `<src>` is concatenated, in the order
- * described in build/locations.ts, and written to `<out>/app.css` — see
- * build/styles.ts.
+ * Every origin's stylesheets are concatenated in that same cascade order and
+ * written to `<out>/app.css` — see build/styles.ts.
+ *
+ * `--minify` minifies both output files: esbuild's own minifier for
+ * `client.js`, as part of the same bundling pass, and esbuild's CSS
+ * transform for `app.css`, as a pass over the concatenation above. `app.html`
+ * is never minified — it is markup an application may still want to read.
  *
  * Without `--watch`, this runs once and exits. With it, every `.html`,
  * `.ts` and `.css` file under `<src>` is watched — a page, a widget's
- * markup, a widget's class, a stylesheet, and `elements.ts` all feed the
+ * markup, a widget's class, a stylesheet, and `imports.ts` all feed the
  * same build — and a rebuild that throws is reported without stopping the
  * watch. There is no dev server and no browser reload here, only the files
  * on disk staying current for the next manual refresh.
@@ -33,6 +41,7 @@ import * as esbuild from "esbuild";
 import { assemble } from "./assemble.js";
 import { clientEntrySource, resolveElements } from "./elements.js";
 import { resolveLocations } from "./locations.js";
+import { cssFrom, scanAll } from "./origins.js";
 import { pagesSource } from "./pages.js";
 import { stylesSource } from "./styles.js";
 const { values } = parseArgs({
@@ -40,6 +49,7 @@ const { values } = parseArgs({
         src: { type: "string", default: "src" },
         out: { type: "string", default: "dist" },
         watch: { type: "boolean", default: false },
+        minify: { type: "boolean", default: false },
     },
 });
 const srcDir = values.src;
@@ -48,16 +58,18 @@ async function build() {
     const outFile = path.join(locations.outDir, "app.html");
     const entryFile = path.join(locations.outDir, "client-entry.ts");
     const clientFile = path.join(locations.outDir, "client.js");
-    const { html, usedTags } = await assemble(locations);
+    const scans = await scanAll(locations, srcDir, locations.importsFile);
+    const { html, usedTags } = await assemble({ ...locations, scans });
     await mkdir(locations.outDir, { recursive: true });
     await writeFile(outFile, html, "utf-8");
-    const { resolved } = await resolveElements({ used: usedTags, ...locations });
+    const { resolved } = resolveElements({ used: usedTags, scans });
     await writeFile(entryFile, clientEntrySource(resolved, locations.outDir), "utf-8");
     await esbuild.build({
         entryPoints: [entryFile],
         bundle: true,
         format: "iife",
         outfile: clientFile,
+        minify: values.minify,
     });
     const generatedPages = pagesSource(locations.pages, locations.pageSources, locations.outDir, locations.packageName);
     let pagesMessage = "";
@@ -66,10 +78,16 @@ async function build() {
         await writeFile(pagesFile, generatedPages, "utf-8");
         pagesMessage = ` and ${pagesFile}`;
     }
-    const generatedCss = await stylesSource(locations.cssFiles);
+    const concatenatedCss = await stylesSource(cssFrom(scans));
     let cssMessage = "";
-    if (generatedCss) {
+    if (concatenatedCss) {
         const cssFile = path.join(locations.outDir, "app.css");
+        const generatedCss = values.minify
+            ? (await esbuild.transform(concatenatedCss, {
+                loader: "css",
+                minify: true,
+            })).code
+            : concatenatedCss;
         await writeFile(cssFile, generatedCss, "utf-8");
         cssMessage = ` and ${cssFile}`;
     }

package/dist/build/elements.d.ts

@@ -3,28 +3,23 @@
  * and finding the script to import for it when it can.
  *
  * A used tag is valid if it has a script, a definition, or both:
- *   - a script registers the class that upgrades it. It can come from a
- *     built-in source (this package's own widgets/ or hub/ — hub/ is where
- *     lb-hub itself lives, discovered exactly the same way as any built-in
- *     widget, no special case for it here), an application's own — found
- *     anywhere in its source tree by build/locations.ts, not confined to a
- *     directory — or a third party's, declared by tag in `elements.ts`.
- *   - a definition (an `.html` file, built-in or local) expands the tag's
- *     content at build time. A widget with only a definition and no script
- *     is markup only: expansion already gave it everything it will ever
- *     have, and the tag survives just as an inert wrapper (see expand.ts).
+ *   - a script registers the class that upgrades it.
+ *   - a definition (an `.html` file) expands the tag's content at build
+ *     time. A widget with only a definition and no script is markup only:
+ *     expansion already gave it everything it will ever have, and the tag
+ *     survives as an inert wrapper (see expand.ts).
  *
  * A tag with neither — no script anywhere and no definition — would do
  * nothing were it ever to reach the browser, so that is an error.
  *
- * Every directory and file here is a parameter, resolved once by
- * build/locations.ts — this module never reconstructs one of its own, and
- * the application's own widgets are handed over already found, not scanned
- * again here.
+ * Both halves are looked for in the same ordered origins, and the later
+ * origin wins: an application's own script overrides one from a package it
+ * imported, which overrides a built-in. Two files claiming one tag *within*
+ * one origin is the error case, and build/origins.ts raises it while
+ * scanning. Nothing is scanned here.
  */
-import { type WidgetSource } from "./locations.js";
-/** The shape of an `elements.ts` module's default export. */
-export type ElementManifest = Record<string, string>;
+import type { OriginScan } from "./origins.js";
+export { loadElementManifest, type ElementManifest } from "./origins.js";
 /** A resolved tag: a bare specifier to import, or a local file to import by relative path. */
 export type Resolved = {
     kind: "specifier";
@@ -33,24 +28,15 @@ export type Resolved = {
     kind: "file";
     value: string;
 };
-/**
- * `elements.ts`, executed rather than parsed — it runs through the same
- * loader as the rest of the build, so it is ordinary TypeScript, not a data
- * format with its own rules.
- */
-export declare function loadElementManifest(file: string): Promise<ElementManifest>;
 export interface ResolveOptions {
     used: Set<string>;
-    widgets: Map<string, WidgetSource>;
-    elementsFile?: string;
-    builtinWidgetsDir: string;
-    builtinHubDir: string;
-    packageName: string;
+    /** Every origin, already scanned, in cascade order — see build/origins.ts. */
+    scans: OriginScan[];
 }
 export interface ResolveResult {
     resolved: Map<string, Resolved>;
 }
-export declare function resolveElements({ used, widgets, elementsFile, builtinWidgetsDir, builtinHubDir, packageName, }: ResolveOptions): Promise<ResolveResult>;
+export declare function resolveElements({ used, scans, }: ResolveOptions): ResolveResult;
 /**
  * The generated client entry point — every custom element the assembled
  * document actually uses, and nothing else. Written to `outDir` so a

package/dist/build/elements.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"elements.d.ts","sourceRoot":"","sources":["../../build/elements.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAKH,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEvE,6DAA6D;AAC7D,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAErD,8FAA8F;AAC9F,MAAM,MAAM,QAAQ,GAClB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAmCzE;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,eAAe,CAAC,CA4B1B;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAClB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACnC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;CACjC;AAED,wBAAsB,eAAe,CAAC,EACpC,IAAI,EACJ,OAAO,EACP,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,WAAW,GACZ,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CAoEzC;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,EAC/B,MAAM,EAAE,MAAM,GACb,MAAM,CAcR"}
+{"version":3,"file":"elements.d.ts","sourceRoot":"","sources":["../../build/elements.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,OAAO,EAAE,mBAAmB,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAEzE,8FAA8F;AAC9F,MAAM,MAAM,QAAQ,GAClB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzE,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAClB,8EAA8E;IAC9E,KAAK,EAAE,UAAU,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;CACjC;AAED,wBAAgB,eAAe,CAAC,EAC9B,IAAI,EACJ,KAAK,GACN,EAAE,cAAc,GAAG,aAAa,CAiChC;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,EAC/B,MAAM,EAAE,MAAM,GACb,MAAM,CAcR"}