@augment-vir/web 30.0.0

package/LICENSE-CC0

@@ -0,0 +1,121 @@
+CC0 1.0 Universal
+
+Creative Commons Legal Code
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

package/LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 electrovir
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/augments/animation-frame.d.ts

@@ -0,0 +1 @@
+export declare function waitForAnimationFrame(frameCount?: number): Promise<void>;

package/dist/augments/animation-frame.js

@@ -0,0 +1,17 @@
+import { DeferredPromise } from '@augment-vir/common';
+export async function waitForAnimationFrame(frameCount = 1) {
+    const deferredPromise = new DeferredPromise();
+    function requestNextFrame() {
+        requestAnimationFrame(() => {
+            frameCount--;
+            if (frameCount) {
+                requestNextFrame();
+            }
+            else {
+                deferredPromise.resolve();
+            }
+        });
+    }
+    requestNextFrame();
+    return deferredPromise.promise;
+}

package/dist/augments/elements/element-children.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Gets all deeply nested elements contained within the given element. Shadow DOMs are traversed.
+ *
+ * Note that `<slot>` elements are included, as well as their nested elements (even if a slot filler
+ * is provided by the parent) and the slot filler itself (if provided).
+ *
+ * Optionally define a second "depth" input to control how far nestings should be pursued. Leave
+ * depth out or set it to undefined or any value <= 0 to allow full depth search.
+ */
+export declare function getNestedChildren(startingElement: Readonly<Element>, depth?: number | undefined): Element[];
+/**
+ * Gets an element's direct children. Includes slotted elements, direct `<slot>` children
+ * themselves, and all direct children of a shadow DOM. Default `<slot>` children are not included
+ * (since they're not "direct" children as they are nested under `<slot>`).
+ *
+ * Note that that slotted elements and light dom elements will always be shown above shadow dom
+ * elements. Besides that, the order of children is preserved.
+ */
+export declare function getDirectChildren(startingElement: Readonly<Element>): Element[];

package/dist/augments/elements/element-children.js

@@ -0,0 +1,39 @@
+/**
+ * Gets all deeply nested elements contained within the given element. Shadow DOMs are traversed.
+ *
+ * Note that `<slot>` elements are included, as well as their nested elements (even if a slot filler
+ * is provided by the parent) and the slot filler itself (if provided).
+ *
+ * Optionally define a second "depth" input to control how far nestings should be pursued. Leave
+ * depth out or set it to undefined or any value <= 0 to allow full depth search.
+ */
+export function getNestedChildren(startingElement, depth) {
+    return recursivelyGetNestedChildren(startingElement, depth ?? 0, 0);
+}
+function recursivelyGetNestedChildren(startingElement, maxDepth, currentDepth) {
+    const children = getDirectChildren(startingElement);
+    return children.flatMap((child) => {
+        const nextDepth = currentDepth + 1;
+        const nested = maxDepth && nextDepth >= maxDepth
+            ? []
+            : recursivelyGetNestedChildren(child, maxDepth, nextDepth);
+        return [
+            child,
+            nested,
+        ].flat();
+    });
+}
+/**
+ * Gets an element's direct children. Includes slotted elements, direct `<slot>` children
+ * themselves, and all direct children of a shadow DOM. Default `<slot>` children are not included
+ * (since they're not "direct" children as they are nested under `<slot>`).
+ *
+ * Note that that slotted elements and light dom elements will always be shown above shadow dom
+ * elements. Besides that, the order of children is preserved.
+ */
+export function getDirectChildren(startingElement) {
+    return [
+        ...startingElement.children,
+        ...(startingElement.shadowRoot?.children ?? []),
+    ];
+}

package/dist/augments/elements/element-focus.d.ts

@@ -0,0 +1 @@
+export declare function isElementFocused(element: Element): boolean;

package/dist/augments/elements/element-focus.js

@@ -0,0 +1,3 @@
+export function isElementFocused(element) {
+    return element.matches(':focus');
+}

package/dist/augments/elements/element-parent.d.ts

@@ -0,0 +1,2 @@
+export declare function getParentElement(element: Node): Element | undefined;
+export declare function findMatchingAncestor(start: Element, testParent: (parent: Element) => boolean): Element | undefined;

package/dist/augments/elements/element-parent.js

@@ -0,0 +1,25 @@
+export function getParentElement(element) {
+    if (element instanceof ShadowRoot) {
+        return getParentElement(element.host);
+    }
+    const parentNode = element.parentNode;
+    if (!parentNode) {
+        return undefined;
+    }
+    else if (parentNode instanceof Element) {
+        return parentNode;
+    }
+    else {
+        return getParentElement(parentNode);
+    }
+}
+export function findMatchingAncestor(start, testParent) {
+    if (testParent(start)) {
+        return start;
+    }
+    const parent = getParentElement(start);
+    if (!parent) {
+        return undefined;
+    }
+    return findMatchingAncestor(parent, testParent);
+}

package/dist/augments/elements/element-position.d.ts

@@ -0,0 +1,5 @@
+import type { Coords } from '@augment-vir/common';
+export declare function checkIfEntirelyInScrollView(element: Element): Promise<unknown>;
+export declare function checkIfInScrollView(element: Element, ratio: number): Promise<unknown>;
+export declare function getCenterOfElement(element: Element): Coords;
+export declare function appendPositionDebugDiv(position: Coords): HTMLDivElement;

package/dist/augments/elements/element-position.js

@@ -0,0 +1,34 @@
+import { assert } from '@augment-vir/assert';
+export async function checkIfEntirelyInScrollView(element) {
+    return checkIfInScrollView(element, 1);
+}
+export async function checkIfInScrollView(element, ratio) {
+    return new Promise((resolve) => {
+        const observer = new IntersectionObserver((entries, observerItself) => {
+            assert.isLengthAtLeast(entries, 1);
+            observerItself.disconnect();
+            resolve(entries[0].intersectionRatio >= ratio);
+        });
+        observer.observe(element);
+    });
+}
+export function getCenterOfElement(element) {
+    const rect = element.getBoundingClientRect();
+    return {
+        x: Math.floor((rect.left + rect.right) / 2),
+        y: Math.floor((rect.bottom + rect.top) / 2),
+    };
+}
+export function appendPositionDebugDiv(position) {
+    const div = document.createElement('div');
+    div.classList.add('debug');
+    div.style.backgroundColor = 'blue';
+    div.style.height = '10px';
+    div.style.left = `${position.x}px`;
+    div.style.position = 'absolute';
+    div.style.top = `${position.y}px`;
+    div.style.width = '10px';
+    div.style.zIndex = '9999';
+    document.body.append(div);
+    return div;
+}

package/dist/augments/elements/element-text.d.ts

@@ -0,0 +1 @@
+export declare function extractElementText(element: Element | ShadowRoot): string;

package/dist/augments/elements/element-text.js

@@ -0,0 +1,17 @@
+export function extractElementText(element) {
+    const value = element.value;
+    const shadowRoot = element.shadowRoot;
+    const textContent = element.textContent?.trim();
+    if (textContent) {
+        return textContent;
+    }
+    else if (shadowRoot) {
+        return extractElementText(shadowRoot);
+    }
+    else if (value) {
+        return value;
+    }
+    else {
+        return '';
+    }
+}

package/dist/augments/elements/element-visibility.d.ts

@@ -0,0 +1,2 @@
+/** Detects `display: none` and only works if the element does not have `position: fixed;`. */
+export declare function isElementVisible(element: HTMLElement): boolean;

package/dist/augments/elements/element-visibility.js

@@ -0,0 +1,5 @@
+/** Detects `display: none` and only works if the element does not have `position: fixed;`. */
+export function isElementVisible(element) {
+    // https://stackoverflow.com/a/21696585
+    return element.offsetParent !== null;
+}

package/dist/augments/elements/overflow-parent.d.ts

@@ -0,0 +1 @@
+export declare function findOverflowParent(start: Element): Element;

package/dist/augments/elements/overflow-parent.js

@@ -0,0 +1,9 @@
+import { findMatchingAncestor, getParentElement } from './element-parent.js';
+export function findOverflowParent(start) {
+    const parentElement = getParentElement(start);
+    return ((parentElement &&
+        findMatchingAncestor(parentElement, (element) => {
+            return globalThis.getComputedStyle(element).overflowY !== 'visible';
+        })) ||
+        document.body);
+}

package/dist/augments/elements/tag-or-definition.d.ts

@@ -0,0 +1,8 @@
+import { DeclarativeElementDefinition } from 'element-vir';
+import { SpecTagName } from 'html-spec-tags';
+/**
+ * Reduce an element down to its tag name or its element definition if it's a custom element defined
+ * by element-vir. Note that the types for this won't work in your project if you use custom element
+ * tag names that aren't generated via element-vir.
+ */
+export declare function toTagOrDefinition(element: Element): DeclarativeElementDefinition | SpecTagName;

package/dist/augments/elements/tag-or-definition.js

@@ -0,0 +1,15 @@
+import { DeclarativeElement } from 'element-vir';
+import { ensureSpecTagName } from 'html-spec-tags';
+/**
+ * Reduce an element down to its tag name or its element definition if it's a custom element defined
+ * by element-vir. Note that the types for this won't work in your project if you use custom element
+ * tag names that aren't generated via element-vir.
+ */
+export function toTagOrDefinition(element) {
+    if (element instanceof DeclarativeElement) {
+        return element.definition;
+    }
+    else {
+        return ensureSpecTagName(element.tagName.toLowerCase());
+    }
+}

package/dist/augments/elements/text-dimensions.d.ts

@@ -0,0 +1,8 @@
+import { Dimensions, type PartialWithUndefined } from '@augment-vir/common';
+import type { AnyDuration } from '@date-vir/duration';
+export declare function calculateTextDimensions(parentElement: Element, text: string, customOptions?: PartialWithUndefined<{
+    timeout: AnyDuration;
+    errorMessage: string;
+    /** Set to true to leave the text element in the DOM. */
+    debug: boolean;
+}>): Promise<Dimensions>;

package/dist/augments/elements/text-dimensions.js

@@ -0,0 +1,59 @@
+import { waitUntil } from '@augment-vir/assert';
+export async function calculateTextDimensions(parentElement, text, customOptions) {
+    if (!text) {
+        return {
+            width: 0,
+            height: 0,
+        };
+    }
+    const textWrapperElement = document.createElement('span');
+    textWrapperElement.style.visibility = 'hidden';
+    textWrapperElement.style.position = 'absolute';
+    textWrapperElement.style.zIndex = '-9999';
+    textWrapperElement.style.opacity = '0';
+    textWrapperElement.style.pointerEvents = 'none';
+    textWrapperElement.style.userSelect = 'none';
+    // eslint-disable-next-line sonarjs/deprecation, @typescript-eslint/no-deprecated
+    textWrapperElement.style.webkitUserSelect = 'none';
+    textWrapperElement.style.animation = 'none';
+    textWrapperElement.style.transition = 'none';
+    textWrapperElement.setAttribute('aria-hidden', 'true');
+    /** Automatically account for shadow roots. */
+    const childAttachPoint = parentElement.shadowRoot || parentElement;
+    childAttachPoint.append(textWrapperElement);
+    let latestSize;
+    /**
+     * Use resize observer instead of clientWidth, getComputedStyle, or getBoundingClientRect to
+     * prevent a forced re-layout. See https://gist.github.com/paulirish/5d52fb081b3570c81e3a.
+     */
+    const resizeObserver = new ResizeObserver((entries) => {
+        latestSize = entries[0]?.contentRect;
+    });
+    resizeObserver.observe(textWrapperElement);
+    textWrapperElement.innerText = text;
+    try {
+        await waitUntil.isTruthy(() => !!latestSize, {
+            interval: { milliseconds: 0 },
+            timeout: customOptions?.timeout || { seconds: 10 },
+        }, customOptions?.errorMessage ||
+            `Failed to calculate text size in '${parentElement.tagName}'.`);
+        /**
+         * No way to intentionally trigger this edge case, we're just catching it here for type
+         * purposes
+         */
+        /* node:coverage ignore next 3 */
+        if (!latestSize) {
+            throw new Error('Failed to calculate text size.');
+        }
+        return {
+            height: latestSize.height,
+            width: latestSize.width,
+        };
+    }
+    finally {
+        if (!customOptions?.debug) {
+            textWrapperElement.remove();
+        }
+        resizeObserver.disconnect();
+    }
+}

package/dist/augments/event-target.d.ts

@@ -0,0 +1,11 @@
+import { PartialWithUndefined } from '@augment-vir/common';
+import { Constructor } from 'type-fest';
+export declare function extractEventTarget<ExpectedTargetClassConstructor extends Constructor<Element>>(event: Event, expectedTargetClass: ExpectedTargetClassConstructor, options?: PartialWithUndefined<{
+    /**
+     * By default `extractEventTarget` uses the `Event.currentTarget` field to extract the event
+     * target so that it extract the target to which the event handler was attached to. However,
+     * if you wish to instead use the `Event.target` property, to extract the element which
+     * originally fired the event, set this to true.
+     */
+    useOriginalTarget: boolean;
+}>): InstanceType<ExpectedTargetClassConstructor>;

package/dist/augments/event-target.js

@@ -0,0 +1,12 @@
+export function extractEventTarget(event, expectedTargetClass, options = {}) {
+    const target = options.useOriginalTarget ? event.target : event.currentTarget;
+    if (!(target instanceof expectedTargetClass)) {
+        const expectedName = expectedTargetClass.name;
+        const actualName = target?.constructor.name;
+        const message = options.useOriginalTarget
+            ? `Current target from event '${event.type}' was not of type '${expectedName}'. Got '${actualName}'.`
+            : `Target from event '${event.type}' was not of type '${expectedName}'. Got '${actualName}'.`;
+        throw new Error(message);
+    }
+    return target;
+}

package/dist/augments/image.d.ts

@@ -0,0 +1 @@
+export declare function loadImage(imageUrl: string): Promise<HTMLImageElement>;

package/dist/augments/image.js

@@ -0,0 +1,13 @@
+import { DeferredPromise } from '@augment-vir/common';
+export async function loadImage(imageUrl) {
+    const deferredPromise = new DeferredPromise();
+    const newImage = new Image();
+    newImage.onload = () => {
+        deferredPromise.resolve(newImage);
+    };
+    newImage.onerror = () => {
+        deferredPromise.reject(new Error(`Failed to load '${imageUrl}'`));
+    };
+    newImage.src = imageUrl;
+    return deferredPromise.promise;
+}

package/dist/augments/query-through-shadow.d.ts

@@ -0,0 +1,17 @@
+import type { PartialWithUndefined } from '@augment-vir/common';
+export type QueryThroughShadowOptions = PartialWithUndefined<{
+    all: boolean;
+}>;
+export declare function queryThroughShadow(element: Element | ShadowRoot, query: string | {
+    tagName: string;
+}, options: {
+    all: true;
+}): Element[];
+export declare function queryThroughShadow(element: Element | ShadowRoot, query: string | {
+    tagName: string;
+}, options: {
+    all?: false | undefined;
+}): Element | undefined;
+export declare function queryThroughShadow(element: Element | ShadowRoot, query: string | {
+    tagName: string;
+}, options: QueryThroughShadowOptions): Element | Element[] | undefined;

package/dist/augments/query-through-shadow.js

@@ -0,0 +1,79 @@
+import { check } from '@augment-vir/assert';
+import { stringify } from '@augment-vir/core';
+export function queryThroughShadow(element, rawQuery, options) {
+    if (!rawQuery) {
+        if (element instanceof Element) {
+            return element;
+        }
+        else {
+            return element.host;
+        }
+    }
+    const query = check.isString(rawQuery) ? rawQuery : rawQuery.tagName;
+    const splitQuery = query.split(' ').filter(check.isTruthy);
+    if (splitQuery.length > 1) {
+        return handleNestedQueries(element, query, options, splitQuery);
+    }
+    else if ('shadowRoot' in element && element.shadowRoot) {
+        return queryThroughShadow(element.shadowRoot, query, options);
+    }
+    const shadowRootChildren = getShadowRootChildren(element);
+    if (options.all) {
+        const outerResults = Array.from(element.querySelectorAll(query));
+        const nestedResults = shadowRootChildren.flatMap((shadowRootChild) => {
+            return queryThroughShadow(shadowRootChild, query, options);
+        });
+        return [
+            ...outerResults,
+            ...nestedResults,
+        ];
+    }
+    else {
+        const basicResult = element.querySelector(query);
+        if (basicResult) {
+            return basicResult;
+        }
+        else {
+            for (const shadowRootChild of shadowRootChildren) {
+                const nestedResult = queryThroughShadow(shadowRootChild, query, options);
+                if (nestedResult) {
+                    return nestedResult;
+                }
+            }
+            return undefined;
+        }
+    }
+}
+function getShadowRootChildren(element) {
+    return Array.from(element.querySelectorAll('*'))
+        .filter((child) => !!child.shadowRoot)
+        .map((child) => child.shadowRoot);
+}
+function handleNestedQueries(element, originalQuery, options, queries) {
+    const firstQuery = queries[0];
+    /**
+     * No way to intentionally trigger this edge case, we're just catching it here for type
+     * purposes.
+     */
+    /* node:coverage ignore next 7 */
+    if (!firstQuery) {
+        throw new Error(`Somehow the first query was empty in '[${queries.join(',')}]' for query '${stringify(originalQuery)}'`);
+    }
+    const results = queryThroughShadow(element, firstQuery, options);
+    if (queries.length <= 1) {
+        return results;
+    }
+    if (check.isArray(results)) {
+        return results
+            .flatMap((result) => {
+            return handleNestedQueries(result, originalQuery, options, queries.slice(1));
+        })
+            .filter(check.isTruthy);
+    }
+    else if (results) {
+        return handleNestedQueries(results, originalQuery, options, queries.slice(1));
+    }
+    else {
+        return undefined;
+    }
+}

package/dist/augments/video.d.ts

@@ -0,0 +1 @@
+export declare function loadVideo(videoUrl: string): Promise<HTMLVideoElement>;

package/dist/augments/video.js

@@ -0,0 +1,14 @@
+import { DeferredPromise } from '@augment-vir/common';
+export async function loadVideo(videoUrl) {
+    const deferredPromise = new DeferredPromise();
+    const videoElement = document.createElement('video');
+    videoElement.addEventListener('loadeddata', () => {
+        deferredPromise.resolve(videoElement);
+    });
+    videoElement.onerror = () => {
+        deferredPromise.reject(new Error(`Failed to load '${videoUrl}'`));
+    };
+    videoElement.src = videoUrl;
+    videoElement.load();
+    return deferredPromise.promise;
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from './augments/animation-frame.js';
+export * from './augments/elements/element-children.js';
+export * from './augments/elements/element-focus.js';
+export * from './augments/elements/element-parent.js';
+export * from './augments/elements/element-position.js';
+export * from './augments/elements/element-text.js';
+export * from './augments/elements/element-visibility.js';
+export * from './augments/elements/overflow-parent.js';
+export * from './augments/elements/tag-or-definition.js';
+export * from './augments/elements/text-dimensions.js';
+export * from './augments/event-target.js';
+export * from './augments/image.js';
+export * from './augments/query-through-shadow.js';
+export * from './augments/video.js';

package/dist/index.js

@@ -0,0 +1,14 @@
+export * from './augments/animation-frame.js';
+export * from './augments/elements/element-children.js';
+export * from './augments/elements/element-focus.js';
+export * from './augments/elements/element-parent.js';
+export * from './augments/elements/element-position.js';
+export * from './augments/elements/element-text.js';
+export * from './augments/elements/element-visibility.js';
+export * from './augments/elements/overflow-parent.js';
+export * from './augments/elements/tag-or-definition.js';
+export * from './augments/elements/text-dimensions.js';
+export * from './augments/event-target.js';
+export * from './augments/image.js';
+export * from './augments/query-through-shadow.js';
+export * from './augments/video.js';

package/package.json

@@ -0,0 +1,49 @@
+{
+    "name": "@augment-vir/web",
+    "version": "30.0.0",
+    "homepage": "https://github.com/electrovir/augment-vir",
+    "bugs": {
+        "url": "https://github.com/electrovir/augment-vir/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/electrovir/augment-vir.git"
+    },
+    "license": "(MIT or CC0 1.0)",
+    "author": {
+        "name": "electrovir",
+        "url": "https://github.com/electrovir"
+    },
+    "type": "module",
+    "main": "dist/index.js",
+    "module": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "compile": "virmator compile",
+        "docs": "virmator docs",
+        "test": "virmator --no-deps test web",
+        "test:coverage": "virmator --no-deps test web coverage",
+        "test:docs": "virmator docs check",
+        "test:update": "npm test"
+    },
+    "dependencies": {
+        "@augment-vir/assert": "^30.0.0",
+        "@augment-vir/common": "^30.0.0",
+        "@date-vir/duration": "^6.0.0",
+        "html-spec-tags": "^2.2.0",
+        "type-fest": "^4.25.0"
+    },
+    "devDependencies": {
+        "@augment-vir/test": "^30.0.0",
+        "typescript": "^5.5.4"
+    },
+    "peerDependencies": {
+        "element-vir": ">=22.0.0"
+    },
+    "engines": {
+        "node": ">=22"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}