@stimulus-library/utilities 0.9.11

package/dist/arrays.d.ts

@@ -0,0 +1 @@
+export declare function wrapArray<T>(x: T | Array<T>): Array<T>;

package/dist/arrays.js

@@ -0,0 +1,3 @@
+export function wrapArray(x) {
+    return Array.isArray(x) ? x : [x];
+}

package/dist/baseController.d.ts

@@ -0,0 +1,11 @@
+import { Context, Controller } from "@hotwired/stimulus";
+export declare class BaseController extends Controller {
+    constructor(context: Context);
+    get el(): HTMLElement;
+    get isTurboPreview(): boolean;
+    get isTurbolinksPreview(): boolean;
+    get csrfToken(): string | null;
+    metaValue(name: string): string | null;
+    eventName(eventName: string): string;
+    dispatchEvent(element: HTMLElement, eventName: string, options?: CustomEventInit): void;
+}

package/dist/baseController.js

@@ -0,0 +1,59 @@
+import { Controller } from "@hotwired/stimulus";
+import { log, logProperty } from "./logging";
+import { dispatchEvent } from "./events";
+export class BaseController extends Controller {
+    constructor(context) {
+        super(context);
+        // @ts-ignore
+        if (!this.application.debug) {
+            return this;
+        }
+        return new Proxy(this, {
+            get: (obj, prop) => {
+                let returnVal = Reflect.get(obj, prop);
+                let self = this;
+                if ("logFormattedMessage" in this.application) {
+                    return returnVal;
+                }
+                if (logProperty(prop.toString())) {
+                    if (typeof returnVal == "function") {
+                        return new Proxy(returnVal, {
+                            apply(target, thisArg, argArray) {
+                                log(self, prop.toString(), {
+                                    args: argArray,
+                                });
+                                return Reflect.apply(target, thisArg, argArray);
+                            },
+                        });
+                    }
+                    else {
+                        log(this, prop.toString());
+                    }
+                }
+                return returnVal;
+            },
+        });
+    }
+    get el() {
+        return this.element;
+    }
+    get isTurboPreview() {
+        return document.documentElement.hasAttribute('data-turbo-preview') || document.documentElement.hasAttribute('data-turbolinks-preview');
+    }
+    get isTurbolinksPreview() {
+        return this.isTurboPreview;
+    }
+    get csrfToken() {
+        return this.metaValue('csrf-token');
+    }
+    metaValue(name) {
+        const element = document.head.querySelector(`meta[name="${name}"]`);
+        return element?.getAttribute('content') || null;
+    }
+    eventName(eventName) {
+        return `${this.identifier}:${eventName}`;
+    }
+    dispatchEvent(element, eventName, options = {}) {
+        dispatchEvent(this, element, eventName, options);
+    }
+}

package/dist/base_controller.d.ts

@@ -0,0 +1,11 @@
+import { Context, Controller } from "@hotwired/stimulus";
+export declare class BaseController extends Controller {
+    constructor(context: Context);
+    get el(): HTMLElement;
+    get isTurboPreview(): boolean;
+    get isTurbolinksPreview(): boolean;
+    get csrfToken(): string | null;
+    metaValue(name: string): string | null;
+    eventName(eventName: string): string;
+    dispatchEvent(element: HTMLElement, eventName: string, options?: CustomEventInit): void;
+}

package/dist/base_controller.js

@@ -0,0 +1,59 @@
+import { Controller } from "@hotwired/stimulus";
+import { log, logProperty } from "./logging";
+import { dispatchEvent } from "./events";
+export class BaseController extends Controller {
+    constructor(context) {
+        super(context);
+        // @ts-ignore
+        if (!this.application.debug) {
+            return this;
+        }
+        return new Proxy(this, {
+            get: (obj, prop) => {
+                let returnVal = Reflect.get(obj, prop);
+                let self = this;
+                if ("logFormattedMessage" in this.application) {
+                    return returnVal;
+                }
+                if (logProperty(prop.toString())) {
+                    if (typeof returnVal == "function") {
+                        return new Proxy(returnVal, {
+                            apply(target, thisArg, argArray) {
+                                log(self, prop.toString(), {
+                                    args: argArray,
+                                });
+                                return Reflect.apply(target, thisArg, argArray);
+                            },
+                        });
+                    }
+                    else {
+                        log(this, prop.toString());
+                    }
+                }
+                return returnVal;
+            },
+        });
+    }
+    get el() {
+        return this.element;
+    }
+    get isTurboPreview() {
+        return document.documentElement.hasAttribute('data-turbo-preview') || document.documentElement.hasAttribute('data-turbolinks-preview');
+    }
+    get isTurbolinksPreview() {
+        return this.isTurboPreview;
+    }
+    get csrfToken() {
+        return this.metaValue('csrf-token');
+    }
+    metaValue(name) {
+        const element = document.head.querySelector(`meta[name="${name}"]`);
+        return element?.getAttribute('content') || null;
+    }
+    eventName(eventName) {
+        return `${this.identifier}:${eventName}`;
+    }
+    dispatchEvent(element, eventName, options = {}) {
+        dispatchEvent(this, element, eventName, options);
+    }
+}

package/dist/debounce.d.ts

@@ -0,0 +1 @@
+export declare function debounce<T extends (...args: any[]) => any>(func: T, wait: number, immediate?: boolean): T;

package/dist/debounce.js

@@ -0,0 +1,19 @@
+export function debounce(func, wait, immediate = false) {
+    let timeout;
+    return function (...args) {
+        const later = () => {
+            timeout = null;
+            if (!immediate) {
+                func.apply(this, args);
+            }
+        };
+        const callNow = immediate && !timeout;
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+        timeout = setTimeout(later, wait);
+        if (callNow) {
+            func.apply(this, args);
+        }
+    };
+}

package/dist/easingFunctions.d.ts

@@ -0,0 +1,34 @@
+export type EasingFunction = (progress: number) => number;
+export declare const EasingFunctions: {
+    linear: (x: number) => number;
+    easeInQuad: (x: number) => number;
+    easeOutQuad: (x: number) => number;
+    easeInOutQuad: (x: number) => number;
+    easeInCubic: (x: number) => number;
+    easeOutCubic: (x: number) => number;
+    easeInOutCubic: (x: number) => number;
+    easeInQuart: (x: number) => number;
+    easeOutQuart: (x: number) => number;
+    easeInOutQuart: (x: number) => number;
+    easeInQuint: (x: number) => number;
+    easeOutQuint: (x: number) => number;
+    easeInOutQuint: (x: number) => number;
+    easeInSine: (x: number) => number;
+    easeOutSine: (x: number) => number;
+    easeInOutSine: (x: number) => number;
+    easeInExpo: (x: number) => number;
+    easeOutExpo: (x: number) => number;
+    easeInOutExpo: (x: number) => number;
+    easeInCirc: (x: number) => number;
+    easeOutCirc: (x: number) => number;
+    easeInOutCirc: (x: number) => number;
+    easeInBack: (x: number) => number;
+    easeOutBack: (x: number) => number;
+    easeInOutBack: (x: number) => number;
+    easeInElastic: (x: number) => number;
+    easeOutElastic: (x: number) => number;
+    easeInOutElastic: (x: number) => number;
+    easeInBounce: (x: number) => number;
+    easeOutBounce: EasingFunction;
+    easeInOutBounce: (x: number) => number;
+};

package/dist/easingFunctions.js

@@ -0,0 +1,143 @@
+const pow = Math.pow;
+const sqrt = Math.sqrt;
+const sin = Math.sin;
+const cos = Math.cos;
+const PI = Math.PI;
+const c1 = 1.70158;
+const c2 = c1 * 1.525;
+const c3 = c1 + 1;
+const c4 = (2 * PI) / 3;
+const c5 = (2 * PI) / 4.5;
+const bounceOut = function (x) {
+    const n1 = 7.5625;
+    const d1 = 2.75;
+    if (x < 1 / d1) {
+        return n1 * x * x;
+    }
+    else if (x < 2 / d1) {
+        return n1 * (x -= 1.5 / d1) * x + 0.75;
+    }
+    else if (x < 2.5 / d1) {
+        return n1 * (x -= 2.25 / d1) * x + 0.9375;
+    }
+    else {
+        return n1 * (x -= 2.625 / d1) * x + 0.984375;
+    }
+};
+export const EasingFunctions = {
+    linear: (x) => x,
+    easeInQuad: function (x) {
+        return x * x;
+    },
+    easeOutQuad: function (x) {
+        return 1 - (1 - x) * (1 - x);
+    },
+    easeInOutQuad: function (x) {
+        return x < 0.5 ? 2 * x * x : 1 - pow(-2 * x + 2, 2) / 2;
+    },
+    easeInCubic: function (x) {
+        return x * x * x;
+    },
+    easeOutCubic: function (x) {
+        return 1 - pow(1 - x, 3);
+    },
+    easeInOutCubic: function (x) {
+        return x < 0.5 ? 4 * x * x * x : 1 - pow(-2 * x + 2, 3) / 2;
+    },
+    easeInQuart: function (x) {
+        return x * x * x * x;
+    },
+    easeOutQuart: function (x) {
+        return 1 - pow(1 - x, 4);
+    },
+    easeInOutQuart: function (x) {
+        return x < 0.5 ? 8 * x * x * x * x : 1 - pow(-2 * x + 2, 4) / 2;
+    },
+    easeInQuint: function (x) {
+        return x * x * x * x * x;
+    },
+    easeOutQuint: function (x) {
+        return 1 - pow(1 - x, 5);
+    },
+    easeInOutQuint: function (x) {
+        return x < 0.5 ? 16 * x * x * x * x * x : 1 - pow(-2 * x + 2, 5) / 2;
+    },
+    easeInSine: function (x) {
+        return 1 - cos((x * PI) / 2);
+    },
+    easeOutSine: function (x) {
+        return sin((x * PI) / 2);
+    },
+    easeInOutSine: function (x) {
+        return -(cos(PI * x) - 1) / 2;
+    },
+    easeInExpo: function (x) {
+        return x === 0 ? 0 : pow(2, 10 * x - 10);
+    },
+    easeOutExpo: function (x) {
+        return x === 1 ? 1 : 1 - pow(2, -10 * x);
+    },
+    easeInOutExpo: function (x) {
+        return x === 0
+            ? 0
+            : x === 1
+                ? 1
+                : x < 0.5
+                    ? pow(2, 20 * x - 10) / 2
+                    : (2 - pow(2, -20 * x + 10)) / 2;
+    },
+    easeInCirc: function (x) {
+        return 1 - sqrt(1 - pow(x, 2));
+    },
+    easeOutCirc: function (x) {
+        return sqrt(1 - pow(x - 1, 2));
+    },
+    easeInOutCirc: function (x) {
+        return x < 0.5
+            ? (1 - sqrt(1 - pow(2 * x, 2))) / 2
+            : (sqrt(1 - pow(-2 * x + 2, 2)) + 1) / 2;
+    },
+    easeInBack: function (x) {
+        return c3 * x * x * x - c1 * x * x;
+    },
+    easeOutBack: function (x) {
+        return 1 + c3 * pow(x - 1, 3) + c1 * pow(x - 1, 2);
+    },
+    easeInOutBack: function (x) {
+        return x < 0.5
+            ? (pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2)) / 2
+            : (pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2;
+    },
+    easeInElastic: function (x) {
+        return x === 0
+            ? 0
+            : x === 1
+                ? 1
+                : -pow(2, 10 * x - 10) * sin((x * 10 - 10.75) * c4);
+    },
+    easeOutElastic: function (x) {
+        return x === 0
+            ? 0
+            : x === 1
+                ? 1
+                : pow(2, -10 * x) * sin((x * 10 - 0.75) * c4) + 1;
+    },
+    easeInOutElastic: function (x) {
+        return x === 0
+            ? 0
+            : x === 1
+                ? 1
+                : x < 0.5
+                    ? -(pow(2, 20 * x - 10) * sin((20 * x - 11.125) * c5)) / 2
+                    : (pow(2, -20 * x + 10) * sin((20 * x - 11.125) * c5)) / 2 + 1;
+    },
+    easeInBounce: function (x) {
+        return 1 - bounceOut(1 - x);
+    },
+    easeOutBounce: bounceOut,
+    easeInOutBounce: function (x) {
+        return x < 0.5
+            ? (1 - bounceOut(1 - 2 * x)) / 2
+            : (1 + bounceOut(2 * x - 1)) / 2;
+    },
+};

package/dist/elements.d.ts

@@ -0,0 +1,48 @@
+export declare function isHTMLLinkElement(element: Element): element is HTMLLinkElement;
+export declare function isHTMLAnchorElement(element: Element): element is HTMLAnchorElement;
+export declare function isHTMLFormElement(element: Element): element is HTMLFormElement;
+export declare function isHTMLInputElement(element: Element): element is HTMLInputElement;
+export declare function isHTMLLabelElement(element: Element): element is HTMLLabelElement;
+export declare function isHTMLTextAreaElement(element: Element): element is HTMLTextAreaElement;
+export declare function isHTMLButtonElement(element: Element): element is HTMLButtonElement;
+export declare function isHTMLSelectElement(element: Element): element is HTMLSelectElement;
+export declare function isHTMLImageElement(element: Element): element is HTMLImageElement;
+export declare function isHTMLButtonInputElement(element: Element): element is HTMLInputElement & {
+    type: "button";
+};
+export declare function isHTMLSubmitInputElement(element: Element): element is HTMLInputElement & {
+    type: "submit";
+};
+export declare function isHTMLResetInputElement(element: Element): element is HTMLInputElement & {
+    type: "reset";
+};
+export declare function isHTMLButtonButtonElement(element: Element): element is HTMLButtonElement & {
+    type: "button";
+};
+export declare function isHTMLSubmitButtonElement(element: Element): element is HTMLButtonElement & {
+    type: "submit";
+};
+export declare function isHTMLResetButtonElement(element: Element): element is HTMLButtonElement & {
+    type: "reset";
+};
+export declare function isTypeOfResetButtonElement(element: Element): element is (HTMLButtonElement | HTMLInputElement) & {
+    type: "reset";
+};
+export declare function isTypeOfSubmitButtonElement(element: Element): element is (HTMLButtonElement | HTMLInputElement) & {
+    type: "submit";
+};
+export declare function isTypeOfButtonableElement(element: Element): element is HTMLButtonElement | (HTMLInputElement & {
+    type: "submit" | "reset";
+});
+export declare function isElementCheckable(element: Element): element is HTMLInputElement & {
+    checked: boolean;
+};
+export declare function isTypeOfFormInputElement(element: Element): element is (HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement);
+export declare function createHiddenButton(type: "submit" | "reset"): HTMLButtonElement;
+export declare function createHiddenInput(name: string, value: string): HTMLInputElement;
+export declare function insertElement<T extends Element>(targetElement: Element, insertPosition: InsertPosition, element: T): T;
+export declare function insertHiddenInput(name: string, value: string, targetElement: Element, insertPosition: InsertPosition): HTMLInputElement;
+export declare function insertHiddenButton(type: "submit" | "reset", targetElement: Element, insertPosition: InsertPosition): HTMLButtonElement;
+export declare function getAllRadiosInGroup(radio: HTMLInputElement): HTMLInputElement[];
+export declare function getOtherRadiosInGroup(radio: HTMLInputElement): HTMLInputElement[];
+export declare function isElementInViewport(el: Element): boolean;

package/dist/elements.js

@@ -0,0 +1,102 @@
+export function isHTMLLinkElement(element) {
+    return element.nodeName == "LINK";
+}
+export function isHTMLAnchorElement(element) {
+    return element.nodeName == "A";
+}
+export function isHTMLFormElement(element) {
+    return element.nodeName == "FORM";
+}
+export function isHTMLInputElement(element) {
+    return element.nodeName == "INPUT";
+}
+export function isHTMLLabelElement(element) {
+    return element.nodeName == "LABEL";
+}
+export function isHTMLTextAreaElement(element) {
+    return element.nodeName == "TEXTAREA";
+}
+export function isHTMLButtonElement(element) {
+    return element.nodeName == "BUTTON";
+}
+export function isHTMLSelectElement(element) {
+    return element.nodeName == "SELECT";
+}
+export function isHTMLImageElement(element) {
+    return element.nodeName == "IMG";
+}
+export function isHTMLButtonInputElement(element) {
+    return element.nodeName == "INPUT" && element.type == "button";
+}
+export function isHTMLSubmitInputElement(element) {
+    return element.nodeName == "INPUT" && element.type == "submit";
+}
+export function isHTMLResetInputElement(element) {
+    return element.nodeName == "INPUT" && element.type == "reset";
+}
+export function isHTMLButtonButtonElement(element) {
+    return element.nodeName == "BUTTON" && element.type == "button";
+}
+export function isHTMLSubmitButtonElement(element) {
+    return element.nodeName == "BUTTON" && element.type == "submit";
+}
+export function isHTMLResetButtonElement(element) {
+    return element.nodeName == "BUTTON" && element.type == "reset";
+}
+export function isTypeOfResetButtonElement(element) {
+    return isHTMLResetButtonElement(element) || isHTMLResetInputElement(element);
+}
+export function isTypeOfSubmitButtonElement(element) {
+    return isHTMLSubmitButtonElement(element) || isHTMLSubmitInputElement(element);
+}
+export function isTypeOfButtonableElement(element) {
+    return isTypeOfResetButtonElement(element) || isTypeOfSubmitButtonElement(element) || isHTMLButtonButtonElement(element);
+}
+export function isElementCheckable(element) {
+    return isHTMLInputElement(element) && (element.type === "radio" || element.type === "checkbox");
+}
+export function isTypeOfFormInputElement(element) {
+    return isHTMLInputElement(element) || isHTMLSelectElement(element) || isHTMLTextAreaElement(element);
+}
+export function createHiddenButton(type) {
+    let button = document.createElement('button');
+    button.type = type;
+    button.style.display = 'none';
+    button.dataset.sythentic = 'true';
+    return button;
+}
+export function createHiddenInput(name, value) {
+    let input = document.createElement('input');
+    input.type = 'hidden';
+    input.name = name;
+    input.value = value;
+    return input;
+}
+export function insertElement(targetElement, insertPosition, element) {
+    let createdElement = targetElement.insertAdjacentElement(insertPosition, element);
+    if (!createdElement) {
+        throw new Error(`Failed to insert element ${element.nodeName} into ${targetElement.nodeName}`);
+    }
+    return createdElement;
+}
+export function insertHiddenInput(name, value, targetElement, insertPosition) {
+    return insertElement(targetElement, insertPosition, createHiddenInput(name, value));
+}
+export function insertHiddenButton(type, targetElement, insertPosition) {
+    return insertElement(targetElement, insertPosition, createHiddenButton(type));
+}
+export function getAllRadiosInGroup(radio) {
+    let parent = radio.form || document;
+    return Array.from(parent.querySelectorAll(`input[type="radio"][name="${radio.name}"]`));
+}
+export function getOtherRadiosInGroup(radio) {
+    return getAllRadiosInGroup(radio).filter((r) => r !== radio);
+}
+export function isElementInViewport(el) {
+    const rect = el.getBoundingClientRect();
+    const windowHeight = window.innerHeight || document.documentElement.clientHeight;
+    const windowWidth = window.innerWidth || document.documentElement.clientWidth;
+    const vertInView = rect.top <= windowHeight && rect.top + rect.height >= 0;
+    const horInView = rect.left <= windowWidth && rect.left + rect.width >= 0;
+    return vertInView && horInView;
+}

package/dist/ephemeralController.d.ts

@@ -0,0 +1,5 @@
+import { BaseController } from "./baseController";
+export declare class EphemeralController extends BaseController {
+    _cleanupSelf(): void;
+    cleanup(element: HTMLElement): void;
+}

package/dist/ephemeralController.js

@@ -0,0 +1,40 @@
+import { camelCase } from "./strings";
+import { BaseController } from "./baseController";
+export class EphemeralController extends BaseController {
+    _cleanupSelf() {
+        this.cleanup(this.el);
+    }
+    cleanup(element) {
+        // @ts-ignore
+        element.dataset.controller = element.dataset.controller?.replaceAll(new RegExp(`(\\s|^)${this.identifier}(\\s|$)`, "g"), "") || "";
+        if (element.dataset.controller == "") {
+            // If there are no controllers left, remove the attribute
+            delete element.dataset.controller;
+        }
+        let substringIdentifierValueRegex = new RegExp(`(\\s|^)${this.identifier}\\..+?(\\s|$)`, "g");
+        // @ts-ignore
+        element.dataset.target = element.dataset.target?.replaceAll(substringIdentifierValueRegex, "") || "";
+        delete element.dataset[camelCase(`${this.identifier}-target`)];
+        if (element.dataset.target == "") {
+            // If there are no targets left, remove the attribute
+            delete element.dataset.target;
+        }
+        // @ts-ignore
+        element.dataset.action = element.dataset.target?.replaceAll(substringIdentifierValueRegex, "") || "";
+        delete element.dataset[camelCase(`${this.identifier}-action`)];
+        if (element.dataset.action == "") {
+            // If there are no actions left, remove the attribute
+            delete element.dataset.action;
+        }
+        // @ts-ignore
+        let values = this.constructor.values;
+        if (values) {
+            Object.keys(values).forEach(val => delete element.dataset[camelCase(`${this.identifier}-${val}-value`)]);
+        }
+        // @ts-ignore
+        let classes = this.constructor.classes;
+        if (classes) {
+            Object.keys(classes).forEach(val => delete element.dataset[camelCase(`${this.identifier}-${val}-class`)]);
+        }
+    }
+}

package/dist/ephemeral_controller.d.ts

@@ -0,0 +1,5 @@
+import { BaseController } from "./base_controller";
+export declare class EphemeralController extends BaseController {
+    _cleanupSelf(): void;
+    cleanup(element: HTMLElement): void;
+}

package/dist/ephemeral_controller.js

@@ -0,0 +1,40 @@
+import { camelCase } from "./strings";
+import { BaseController } from "./base_controller";
+export class EphemeralController extends BaseController {
+    _cleanupSelf() {
+        this.cleanup(this.el);
+    }
+    cleanup(element) {
+        // @ts-ignore
+        element.dataset.controller = element.dataset.controller?.replaceAll(new RegExp(`(\\s|^)${this.identifier}(\\s|$)`, "g"), "") || "";
+        if (element.dataset.controller == "") {
+            // If there are no controllers left, remove the attribute
+            delete element.dataset.controller;
+        }
+        let substringIdentifierValueRegex = new RegExp(`(\\s|^)${this.identifier}\\..+?(\\s|$)`, "g");
+        // @ts-ignore
+        element.dataset.target = element.dataset.target?.replaceAll(substringIdentifierValueRegex, "") || "";
+        delete element.dataset[camelCase(`${this.identifier}-target`)];
+        if (element.dataset.target == "") {
+            // If there are no targets left, remove the attribute
+            delete element.dataset.target;
+        }
+        // @ts-ignore
+        element.dataset.action = element.dataset.target?.replaceAll(substringIdentifierValueRegex, "") || "";
+        delete element.dataset[camelCase(`${this.identifier}-action`)];
+        if (element.dataset.action == "") {
+            // If there are no actions left, remove the attribute
+            delete element.dataset.action;
+        }
+        // @ts-ignore
+        let values = this.constructor.values;
+        if (values) {
+            Object.keys(values).forEach(val => delete element.dataset[camelCase(`${this.identifier}-${val}-value`)]);
+        }
+        // @ts-ignore
+        let classes = this.constructor.classes;
+        if (classes) {
+            Object.keys(classes).forEach(val => delete element.dataset[camelCase(`${this.identifier}-${val}-class`)]);
+        }
+    }
+}

package/dist/eventBus.d.ts

@@ -0,0 +1,3 @@
+export declare const EventBus: import("mitt").Emitter<{
+    [idx: string]: any;
+}>;

package/dist/eventBus.js

@@ -0,0 +1,2 @@
+import mitt from 'mitt';
+export const EventBus = mitt();

package/dist/event_bus.d.ts

@@ -0,0 +1 @@
+export declare const EventBus: any;

package/dist/event_bus.js

@@ -0,0 +1,2 @@
+import mitt from 'mitt';
+export const EventBus = mitt();

package/dist/events.d.ts

@@ -0,0 +1,2 @@
+import { Controller } from "@hotwired/stimulus";
+export declare function dispatchEvent(controller: Controller, element: HTMLElement, eventName: string, options?: CustomEventInit): void;

package/dist/events.js

@@ -0,0 +1,10 @@
+import { logEvent } from "./logging";
+export function dispatchEvent(controller, element, eventName, options = {}) {
+    let mergedOptions = Object.assign({}, { bubbles: true, cancelable: true, detail: { target: element } }, options);
+    if (!mergedOptions.detail.target) {
+        mergedOptions.detail.target = element;
+    }
+    let event = new CustomEvent(eventName, mergedOptions);
+    logEvent(controller, eventName, event, element);
+    element.dispatchEvent(event);
+}

package/dist/fetchRetry.d.ts

@@ -0,0 +1 @@
+export declare function fetchRetry(n: number, input: RequestInfo, init?: RequestInit): Promise<Response>;

package/dist/fetchRetry.js

@@ -0,0 +1,11 @@
+export async function fetchRetry(n, input, init) {
+    try {
+        return await fetch(input, init);
+    }
+    catch (err) {
+        if (n === 1) {
+            throw err;
+        }
+        return await fetchRetry(n - 1, input, init);
+    }
+}

package/dist/getSet.d.ts

@@ -0,0 +1,3 @@
+export declare function stringToPath(str: string): string[];
+export declare function get<T extends object>(object: T, path: string, defaultValue?: any): any;
+export declare function set<T extends object>(object: T, path: string, value: any): any;