smoothly 1.1.1-alpha.99 → 1.2.1-alpha.0

package/dist/cjs/{Submit-a58ac294.js → Scrollable-a60d6091.js}

@@ -19,13 +19,6 @@ class Type {
     constructor(_name, _condition) {
         this._name = _name;
         this._condition = _condition;
-        /**
-         * Return the value if the value is valid for the type, otherwise undefined.
-         * For objects, unknown properties are filtered.
-         *
-         * Eg: isly.number().value(NaN) returns undefined
-         */
-        this.get = value => (this.is(value) ? this.getValue(value) : undefined);
         /**
          * Return a flaw object, describing the flaws of the value compared to expected type.
          *
@@ -33,7 +26,7 @@ class Type {
          *
          * Implemented as a closure.
          */
-        this.flaw = value => {
+        this.flaw = (value) => {
             return this.is(value)
                 ? {
                     type: this.name,
@@ -48,6 +41,15 @@ class Type {
                 };
         };
     }
+    /**
+     * Return the value if the value is valid for the type, otherwise undefined.
+     * For objects, unknown properties are filtered.
+     *
+     * Eg: isly.number().value(NaN) returns undefined
+     */
+    get(value) {
+        return this.is(value) ? this.getValue(value) : undefined;
+    }
     getValue(value) {
         return value;
     }
@@ -71,7 +73,8 @@ class IslyOptional extends Type {
     constructor(backend) {
         super(() => backend.name + " | undefined", backend.condition);
         this.backend = backend;
-        this.is = (value => value == undefined || this.backend.is(value));
+        this.class = "optional";
+        this.is = (value) => value == undefined || this.backend.is(value);
     }
     createFlaw(value) {
         return this.createFlawFromType(this.backend, value);
@@ -81,7 +84,8 @@ class IslyReadonly extends Type {
     constructor(backend) {
         super(() => `Readonly<${backend.name}>`, backend.condition);
         this.backend = backend;
-        this.is = (value => value == undefined || this.backend.is(value));
+        this.class = "readonly";
+        this.is = (value) => value == undefined || this.backend.is(value);
     }
     createFlaw(value) {
         return this.createFlawFromType(this.backend, value);
@@ -109,9 +113,10 @@ class IslyArray extends Type {
         super(() => this.baseName() + "[]", options.length > 0 ? options.map(c => criteriaFunctions$1[c.criteria].condition(c.value)).join(" & ") : undefined);
         this.itemType = itemType;
         this.options = options;
-        this.is = (value => globalThis.Array.isArray(value) &&
+        this.class = "array";
+        this.is = (value) => globalThis.Array.isArray(value) &&
             this.options.every(option => criteriaFunctions$1[option.criteria].is(value, option.value)) &&
-            value.every(item => this.itemType.is(item)));
+            value.every(item => this.itemType.is(item));
     }
     baseName() {
         return this.itemType.name.includes(" ") ? `(${this.itemType.name})` : this.itemType.name;
@@ -135,28 +140,18 @@ class IslyArray extends Type {
     }
 }
 
+function boolean(booleanValue) {
+    return new IslyBoolean(booleanValue);
+}
 class IslyBoolean extends Type {
     constructor(booleanValue) {
         super(booleanValue == undefined ? "boolean" : booleanValue ? "true" : "false");
         this.booleanValue = booleanValue;
-        this.is = (value => typeof value == "boolean" && (this.booleanValue == undefined || value == this.booleanValue));
+        this.class = "boolean";
+        this.is = (value) => typeof value == "boolean" && (this.booleanValue == undefined || value == this.booleanValue);
     }
 }
-function boolean(booleanValue) {
-    return new IslyBoolean(booleanValue);
-}
 
-class IslyLazy extends Type {
-    constructor(factory, name) {
-        super(name ?? (() => (this.backend ??= factory()).name), () => (this.backend ??= factory()).condition);
-        this.factory = factory;
-        this.is = (value => (this.backend ??= this.factory()).is(value));
-        this.get = value => this.backend.get(value);
-    }
-    createFlaw(value) {
-        return this.createFlawFromType((this.backend ??= this.factory()), value);
-    }
-}
 /**
  * Late evaluation of a type
  * Can be used for for recursive types.
@@ -168,30 +163,51 @@ class IslyLazy extends Type {
 function lazy(factory, name) {
     return new IslyLazy(factory, name);
 }
+class IslyLazy extends Type {
+    constructor(factory, name) {
+        super(name ?? (() => (this.backend ??= factory()).name), () => (this.backend ??= factory()).condition);
+        this.factory = factory;
+        this.class = "lazy";
+        this.is = (value) => (this.backend ??= this.factory()).is(value);
+    }
+    createFlaw(value) {
+        return this.createFlawFromType((this.backend ??= this.factory()), value);
+    }
+    getBackend() {
+        return this.backend;
+    }
+    get(value) {
+        return this.backend.get(value);
+    }
+}
 
+function object(properties, name) {
+    return new IslyObject(properties ?? {}, name);
+}
 class IslyObject extends Type {
-    constructor(baseType, properties, name) {
+    constructor(properties, name, baseType) {
         super(() => name ??
             (this.baseType ? `${this.baseType.name} & ` : "") +
                 `{${globalThis.Object.entries(this.properties)
                     .map(([property, type]) => `${property}: ${type.name}`)
                     .join(", ")}}`);
-        this.baseType = baseType;
         this.properties = properties;
-        this.is = (value => !!(value &&
+        this.baseType = baseType;
+        this.class = "object";
+        this.is = (value) => !!(value &&
             (this.baseType == undefined || this.baseType.is(value)) &&
             typeof value == "object" &&
             !globalThis.Array.isArray(value) &&
-            globalThis.Object.entries(this.properties).every(([property, type]) => type.is(value[property]))));
+            globalThis.Object.entries(this.properties).every(([property, type]) => type.is(value[property])));
     }
     extend(properties, name) {
-        return new IslyObject(this, properties, name);
+        return new IslyObject(properties, name, this);
     }
     omit(omits, name) {
-        return new IslyObject(this.baseType?.omit(omits), globalThis.Object.fromEntries(globalThis.Object.entries(this.properties).filter(([key]) => !omits.includes(key))), name ?? `Omit<${this.name}, ${omits.map(key => `"${String(key)}"`).join(" | ")}>`);
+        return new IslyObject(globalThis.Object.fromEntries(globalThis.Object.entries(this.properties).filter(([key]) => !omits.includes(key))), name ?? `Omit<${this.name}, ${omits.map(key => `"${String(key)}"`).join(" | ")}>`, this.baseType?.omit(omits));
     }
     pick(picks, name) {
-        return new IslyObject(this.baseType?.pick(picks), globalThis.Object.fromEntries(globalThis.Object.entries(this.properties).filter(([key]) => picks.includes(key))), name ?? `Pick<${this.name}, ${picks.map(key => `"${String(key)}"`).join(" | ")}>`);
+        return new IslyObject(globalThis.Object.fromEntries(globalThis.Object.entries(this.properties).filter(([key]) => picks.includes(key))), name ?? `Pick<${this.name}, ${picks.map(key => `"${String(key)}"`).join(" | ")}>`, this.baseType?.pick(picks));
     }
     createFlaw(value) {
         return {
@@ -217,11 +233,14 @@ class IslyObject extends Type {
                     result[key] = type.get(value[key]);
         return result;
     }
-}
-function object(properties, name) {
-    return new IslyObject(undefined, properties ?? {}, name);
+    getProperties() {
+        return { ...this.baseType?.getProperties(), ...this.properties };
+    }
 }
 
+function string(condition) {
+    return new IslyString(condition);
+}
 class IslyString extends Type {
     constructor(stringCondition) {
         super(typeof stringCondition == "string" ? `"${stringCondition}"` : "string", () => {
@@ -233,7 +252,8 @@ class IslyString extends Type {
                     .join(" | ");
         });
         this.stringCondition = stringCondition;
-        this.is = (value => {
+        this.class = "string";
+        this.is = (value) => {
             const conditionObject = this.getConditionObject();
             return (typeof value == "string" &&
                 (conditionObject instanceof RegExp
@@ -241,7 +261,7 @@ class IslyString extends Type {
                     : typeof conditionObject == "object"
                         ? value in conditionObject //TODO, avoid "hasOwnProperty toString etc."
                         : conditionObject));
-        });
+        };
     }
     getConditionObject() {
         return (this.conditionObject ??= Array.isArray(this.stringCondition)
@@ -256,9 +276,6 @@ class IslyString extends Type {
                     : true);
     }
 }
-function string(condition) {
-    return new IslyString(condition);
-}
 
 var Flaw;
 (function (Flaw) {
@@ -274,28 +291,30 @@ var Flaw;
     Flaw.flaw = Flaw.type.flaw;
 })(Flaw || (Flaw = {}));
 
+function fromIs(name, is) {
+    return new IslyFromIs(name, is);
+}
 class IslyFromIs extends Type {
     constructor(name, isFunction) {
         super(name);
         this.isFunction = isFunction;
-        this.is = (value => this.isFunction(value));
+        this.class = "fromIs";
+        this.is = (value) => this.isFunction(value);
     }
 }
-function fromIs(name, is) {
-    return new IslyFromIs(name, is);
-}
 
+// eslint-disable-next-line @typescript-eslint/ban-types
+function islyFunction() {
+    return new IslyFunction();
+}
 // eslint-disable-next-line @typescript-eslint/ban-types
 class IslyFunction extends Type {
     constructor() {
         super("function");
-        this.is = (value => !!(value && typeof value == "function"));
+        this.class = "function";
+        this.is = (value) => !!(value && typeof value == "function");
     }
 }
-// eslint-disable-next-line @typescript-eslint/ban-types
-function islyFunction() {
-    return new IslyFunction();
-}
 
 const criteriaFunctions = {
     positive: {
@@ -311,6 +330,17 @@ const criteriaFunctions = {
         condition: "Number.isInteger",
     },
 };
+/**
+ * NaN, Infinite and -Infinite is not considered to be numbers by this type,
+ * since that it is hardly ever desirable when validating input data.
+ *
+ * @param criteria
+ * @returns
+ */
+function number(criteria) {
+    const [isFunction, condition] = criteria == undefined ? [undefined, undefined] : fromCriteria(criteria);
+    return new IslyNumber(isFunction, condition);
+}
 function fromCriteria(criteria) {
     return /* Eg: criteria == 42 */ typeof criteria == "number"
         ? [value => value == criteria, " == " + criteria.toString()]
@@ -339,32 +369,26 @@ class IslyNumber extends Type {
     constructor(isFunction, condition) {
         super("number", condition);
         this.isFunction = isFunction;
-        this.is = (value => typeof value == "number" &&
+        this.class = "number";
+        this.is = (value) => typeof value == "number" &&
             !Number.isNaN(value - value) && // NaN-NaN==NaN && Infinity-Infinity==NaN &&  (-Infinity)-(-Infinity)==NaN
-            (!this.isFunction || this.isFunction(value)));
+            (!this.isFunction || this.isFunction(value));
     }
 }
-/**
- * NaN, Infinite and -Infinite is not considered to be numbers by this type,
- * since that it is hardly ever desirable when validating input data.
- *
- * @param criteria
- * @returns
- */
-function number(criteria) {
-    const [isFunction, condition] = criteria == undefined ? [undefined, undefined] : fromCriteria(criteria);
-    return new IslyNumber(isFunction, condition);
-}
 
+function record(keyType, valueType) {
+    return new IslyRecord(keyType, valueType);
+}
 class IslyRecord extends Type {
     constructor(keyType, valueType) {
         super(() => `Record<${keyType.name}, ${valueType.name}>`);
         this.keyType = keyType;
         this.valueType = valueType;
-        this.is = (value => !!(value &&
+        this.class = "record";
+        this.is = (value) => !!(value &&
             typeof value == "object" &&
             !globalThis.Array.isArray(value) &&
-            globalThis.Object.entries(value).every(([key, value]) => this.keyType.is(this.keyType.name == "number" && `${+key}` == key ? +key : key) && this.valueType.is(value))));
+            globalThis.Object.entries(value).every(([key, value]) => this.keyType.is(this.keyType.name == "number" && `${+key}` == key ? +key : key) && this.valueType.is(value)));
     }
     createFlaw(value) {
         return {
@@ -383,14 +407,15 @@ class IslyRecord extends Type {
         return globalThis.Object.fromEntries(globalThis.Object.entries(value).map(([key, value]) => [key, this.valueType.get(value)]));
     }
 }
-function record(keyType, valueType) {
-    return new IslyRecord(keyType, valueType);
-}
 
+function union(...types) {
+    return new IslyUnion(...types);
+}
 class IslyUnion extends Type {
     constructor(...types) {
         super(() => types.map(type => type.name).join(" | "));
-        this.is = (value => this.types.some(type => type.is(value)));
+        this.class = "union";
+        this.is = (value) => this.types.some(type => type.is(value));
         this.types = types;
     }
     createFlaw(value) {
@@ -402,22 +427,161 @@ class IslyUnion extends Type {
         return this.types.find(type => type.is(value))?.get(value);
     }
 }
-function union(...types) {
-    return new IslyUnion(...types);
-}
 
+function islyUndefined(name) {
+    return new IslyUndefined(name ?? "undefined");
+}
 class IslyUndefined extends Type {
     constructor() {
         super(...arguments);
-        this.is = (value => value === undefined);
+        this.class = "undefined";
+        this.is = (value) => value === undefined;
     }
 }
-function islyUndefined(name) {
-    return new IslyUndefined(name ?? "undefined");
-}
+
+var Hex;
+(function (Hex) {
+    Hex.type = string(new RegExp(/^#([0-9a-f]{3}|[0-9a-f]{6})$/i));
+    function toRGB(hex) {
+        hex = hex.replace(/^#/, "");
+        if (hex.length === 3) {
+            hex = hex
+                .split("")
+                .map(char => char + char)
+                .join("");
+        }
+        const bigint = parseInt(hex, 16);
+        const r = (bigint >> 16) & 255;
+        const g = (bigint >> 8) & 255;
+        const b = bigint & 255;
+        return { r, g, b };
+    }
+    Hex.toRGB = toRGB;
+})(Hex || (Hex = {}));
+
+var HSL;
+(function (HSL) {
+    HSL.type = object({
+        h: number().optional(),
+        s: number().optional(),
+        l: number().optional(),
+    });
+    function toRGB({ h, s, l }) {
+        let r = 0;
+        let g = 0;
+        let b = 0;
+        if (h !== undefined && s !== undefined && l !== undefined) {
+            s /= 100;
+            l /= 100;
+            const c = (1 - Math.abs(2 * l - 1)) * s;
+            const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+            const m = l - c / 2;
+            if (0 <= h && h < 60) {
+                r = c;
+                g = x;
+                b = 0;
+            }
+            else if (60 <= h && h < 120) {
+                r = x;
+                g = c;
+                b = 0;
+            }
+            else if (120 <= h && h < 180) {
+                r = 0;
+                g = c;
+                b = x;
+            }
+            else if (180 <= h && h < 240) {
+                r = 0;
+                g = x;
+                b = c;
+            }
+            else if (240 <= h && h < 300) {
+                r = x;
+                g = 0;
+                b = c;
+            }
+            else if (300 <= h && h < 360) {
+                r = c;
+                g = 0;
+                b = x;
+            }
+            r = (r + m) * 255;
+            g = (g + m) * 255;
+            b = (b + m) * 255;
+        }
+        return { r, g, b };
+    }
+    HSL.toRGB = toRGB;
+})(HSL || (HSL = {}));
+
+exports.RGB = void 0;
+(function (RGB) {
+    RGB.type = object({
+        r: number().optional(),
+        g: number().optional(),
+        b: number().optional(),
+    });
+    function toHex(rgb) {
+        let hex = "";
+        for (const component of Object.values(rgb)) {
+            if (component === 0) {
+                hex += "00";
+            }
+            else if (component && component >= 0 && component <= 255) {
+                const temp = Math.round(component).toString(16);
+                hex += temp.length === 1 ? "0" + temp : temp;
+            }
+        }
+        const hexPairs = [hex.slice(0, 2), hex.slice(2, 4), hex.slice(4, 6)];
+        hexPairs.every(pair => pair[0] === pair[1]) && (hex = hexPairs.map(pair => pair[0]).join(""));
+        return "#" + hex;
+    }
+    RGB.toHex = toHex;
+    function toHSL({ r, g, b }) {
+        let h, s, l;
+        if (r !== undefined && g !== undefined && b !== undefined) {
+            r /= 255;
+            g /= 255;
+            b /= 255;
+            const max = Math.max(r, g, b);
+            const min = Math.min(r, g, b);
+            l = (max + min) / 2;
+            if (max === min) {
+                h = s = 0;
+            }
+            else {
+                const d = max - min;
+                s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+                switch (max) {
+                    case r:
+                        h = (g - b) / d + (g < b ? 6 : 0);
+                        break;
+                    case g:
+                        h = (b - r) / d + 2;
+                        break;
+                    case b:
+                        h = (r - g) / d + 4;
+                        break;
+                    default:
+                        h = 0;
+                }
+                h /= 6;
+            }
+            h = h * 360;
+            s = s * 100;
+            l = l * 100;
+        }
+        return { h, s, l };
+    }
+    RGB.toHSL = toHSL;
+})(exports.RGB || (exports.RGB = {}));
 
 exports.Color = void 0;
 (function (Color) {
+    Color.Hex = Hex;
+    Color.HSL = HSL;
+    Color.RGB = exports.RGB;
     Color.types = [
         "default",
         "primary",
@@ -455,6 +619,514 @@ exports.Icon = void 0;
             names[n] = url;
     }
     Icon.add = add;
+    (function (Name) {
+        Name.values = [
+            "accessibility",
+            "add-circle",
+            "add",
+            "airplane",
+            "alarm",
+            "albums",
+            "alert-circle",
+            "alert",
+            "american-football",
+            "analytics",
+            "aperture",
+            "apps",
+            "archive",
+            "arrow-back-circle",
+            "arrow-back",
+            "arrow-down-circle",
+            "arrow-down",
+            "arrow-forward-circle",
+            "arrow-forward",
+            "arrow-redo-circle",
+            "arrow-redo",
+            "arrow-undo-circle",
+            "arrow-undo",
+            "arrow-up-circle",
+            "arrow-up",
+            "at-circle",
+            "at",
+            "attach",
+            "backspace",
+            "bag",
+            "bag-add",
+            "bag-check",
+            "bag-handle",
+            "balloon",
+            "ban",
+            "bandage",
+            "barbell",
+            "bar-chart",
+            "barcode",
+            "baseball",
+            "basketball",
+            "basket",
+            "battery-charging",
+            "battery-dead",
+            "battery-full",
+            "battery-half",
+            "beaker",
+            "bed",
+            "beer",
+            "bicycle",
+            "bluetooth",
+            "boat",
+            "body",
+            "bonfire",
+            "bowling-ball",
+            "bookmarks",
+            "bookmark",
+            "book",
+            "briefcase",
+            "browsers",
+            "brush",
+            "bug",
+            "build",
+            "bulb",
+            "business",
+            "bus",
+            "cafe",
+            "calculator",
+            "calendar",
+            "calendar-clear",
+            "calendar-number",
+            "call",
+            "camera-reverse",
+            "camera",
+            "card",
+            "caret-back-circle",
+            "caret-back",
+            "caret-down-circle",
+            "caret-down",
+            "caret-forward-circle",
+            "caret-forward",
+            "caret-up-circle",
+            "caret-up",
+            "car-sport",
+            "car",
+            "cart",
+            "cash",
+            "cellular",
+            "chatbox-ellipses",
+            "chatbox",
+            "chatbubble-ellipses",
+            "chatbubbles",
+            "chatbubble",
+            "checkbox",
+            "checkmark-circle",
+            "checkmark-done-circle",
+            "checkmark-done",
+            "checkmark",
+            "chevron-back-circle",
+            "chevron-back",
+            "chevron-down-circle",
+            "chevron-down",
+            "chevron-forward-circle",
+            "chevron-forward",
+            "chevron-up-circle",
+            "chevron-up",
+            "clipboard",
+            "close-circle",
+            "close",
+            "cloud-circle",
+            "cloud-done",
+            "cloud-download",
+            "cloud-offline",
+            "cloud",
+            "cloud-upload",
+            "cloudy-night",
+            "cloudy",
+            "code-download",
+            "code-slash",
+            "code",
+            "code-working",
+            "cog",
+            "color-fill",
+            "color-filter",
+            "color-palette",
+            "color-wand",
+            "compass",
+            "construct",
+            "contract",
+            "contrast",
+            "copy",
+            "create",
+            "crop",
+            "cube",
+            "cut",
+            "desktop",
+            "diamond",
+            "dice",
+            "disc",
+            "document-attach",
+            "document-lock",
+            "documents",
+            "document",
+            "document-text",
+            "download",
+            "duplicate",
+            "ear",
+            "earth",
+            "easel",
+            "egg",
+            "ellipse",
+            "ellipsis-horizontal-circle",
+            "ellipsis-horizontal",
+            "ellipsis-vertical-circle",
+            "ellipsis-vertical",
+            "enter",
+            "exit",
+            "expand",
+            "eyedrop",
+            "eye-off",
+            "eye",
+            "fast-food",
+            "female",
+            "file-tray-full",
+            "file-tray-stacked",
+            "file-tray",
+            "film",
+            "filter",
+            "filter-circle",
+            "finger-print",
+            "fish",
+            "fitness",
+            "flag",
+            "flame",
+            "flashlight",
+            "flash-off",
+            "flash",
+            "flask",
+            "flower",
+            "folder-open",
+            "folder",
+            "football",
+            "footsteps",
+            "funnel",
+            "game-controller",
+            "gift",
+            "git-branch",
+            "git-commit",
+            "git-compare",
+            "git-merge",
+            "git-network",
+            "git-pull-request",
+            "glasses",
+            "globe",
+            "golf",
+            "grid",
+            "hammer",
+            "hand-left",
+            "hand-right",
+            "happy",
+            "hardware-chip",
+            "headset",
+            "heart-circle",
+            "heart-dislike-circle",
+            "heart-dislike",
+            "heart-half",
+            "heart",
+            "help-buoy",
+            "help-circle",
+            "help",
+            "home",
+            "hourglass",
+            "ice-cream",
+            "id-card",
+            "images",
+            "image",
+            "infinite",
+            "information-circle",
+            "information",
+            "journal",
+            "invert-mode",
+            "keypad",
+            "key",
+            "language",
+            "laptop",
+            "layers",
+            "leaf",
+            "library",
+            "link",
+            "list-circle",
+            "list",
+            "locate",
+            "location",
+            "lock-closed",
+            "lock-open",
+            "log-in",
+            "log-out",
+            "magnet",
+            "mail-open",
+            "mail",
+            "mail-unread",
+            "male-female",
+            "male",
+            "man",
+            "map",
+            "medal",
+            "medical",
+            "medkit",
+            "megaphone",
+            "menu",
+            "mic-circle",
+            "mic-off-circle",
+            "mic-off",
+            "mic",
+            "moon",
+            "move",
+            "musical-notes",
+            "musical-note",
+            "navigate-circle",
+            "navigate",
+            "newspaper",
+            "notifications-circle",
+            "notifications-off-circle",
+            "notifications-off",
+            "notifications",
+            "nuclear",
+            "nutrition",
+            "open",
+            "options",
+            "paper-plane",
+            "partly-sunny",
+            "pause-circle",
+            "pause",
+            "paw",
+            "pencil",
+            "people-circle",
+            "people",
+            "person-add",
+            "person-circle",
+            "person-remove",
+            "person",
+            "phone-landscape",
+            "phone-portrait",
+            "pie-chart",
+            "pin",
+            "pint",
+            "pizza",
+            "planet",
+            "play-back-circle",
+            "play-back",
+            "play-circle",
+            "play-forward-circle",
+            "play-forward",
+            "play-skip-back-circle",
+            "play-skip-back",
+            "play-skip-forward-circle",
+            "play-skip-forward",
+            "play",
+            "podium",
+            "power",
+            "pricetags",
+            "prism",
+            "pricetag",
+            "print",
+            "pulse",
+            "push",
+            "qr-code",
+            "radio-button-off",
+            "radio-button-on",
+            "radio",
+            "rainy",
+            "reader",
+            "receipt",
+            "recording",
+            "refresh-circle",
+            "refresh",
+            "reload-circle",
+            "reload",
+            "remove-circle",
+            "remove",
+            "reorder-four",
+            "reorder-three",
+            "reorder-two",
+            "repeat",
+            "resize",
+            "restaurant",
+            "return-down-back",
+            "return-down-forward",
+            "return-up-back",
+            "return-up-forward",
+            "ribbon",
+            "rocket",
+            "rose",
+            "sad",
+            "save",
+            "scan-circle",
+            "scale",
+            "scan",
+            "school",
+            "search-circle",
+            "search",
+            "send",
+            "server",
+            "settings",
+            "shapes",
+            "share-social",
+            "share",
+            "shield-checkmark",
+            "shield-half",
+            "shield",
+            "shirt",
+            "shuffle",
+            "skull",
+            "snow",
+            "sparkles",
+            "speedometer",
+            "square",
+            "star-half",
+            "star",
+            "stats-chart",
+            "stop-circle",
+            "stop",
+            "stopwatch",
+            "storefront",
+            "subway",
+            "sunny",
+            "swap-horizontal",
+            "swap-vertical",
+            "sync-circle",
+            "sync",
+            "tablet-landscape",
+            "tablet-portrait",
+            "telescope",
+            "tennisball",
+            "terminal",
+            "text",
+            "thermometer",
+            "thumbs-down",
+            "thumbs-up",
+            "thunderstorm",
+            "ticket",
+            "timer",
+            "time",
+            "today",
+            "toggle",
+            "trail-sign",
+            "train",
+            "transgender",
+            "trash-bin",
+            "trash",
+            "trending-down",
+            "trending-up",
+            "triangle",
+            "trophy",
+            "tv",
+            "umbrella",
+            "unlink",
+            "videocam-off",
+            "walk",
+            "wallet",
+            "warning",
+            "watch",
+            "water",
+            "videocam",
+            "wifi",
+            "wine",
+            "volume-high",
+            "volume-low",
+            "volume-medium",
+            "volume-mute",
+            "volume-off",
+            "woman",
+        ];
+    })(Icon.Name || (Icon.Name = {}));
+    (function (Logo) {
+        Logo.values = [
+            "logo-alipay",
+            "logo-amazon",
+            "logo-amplify",
+            "logo-android",
+            "logo-angular",
+            "logo-apple-appstore",
+            "logo-apple",
+            "logo-apple-ar",
+            "logo-behance",
+            "logo-bitbucket",
+            "logo-bitcoin",
+            "logo-buffer",
+            "logo-capacitor",
+            "logo-chrome",
+            "logo-closed-captioning",
+            "logo-codepen",
+            "logo-css3",
+            "logo-designernews",
+            "logo-deviantart",
+            "logo-discord",
+            "logo-docker",
+            "logo-dribbble",
+            "logo-dropbox",
+            "logo-edge",
+            "logo-electron",
+            "logo-euro",
+            "logo-facebook",
+            "logo-firebase",
+            "logo-firefox",
+            "logo-flickr",
+            "logo-foursquare",
+            "logo-github",
+            "logo-gitlab",
+            "logo-google-playstore",
+            "logo-google",
+            "logo-hackernews",
+            "logo-html5",
+            "logo-instagram",
+            "logo-ionic",
+            "logo-ionitron",
+            "logo-javascript",
+            "logo-laravel",
+            "logo-linkedin",
+            "logo-markdown",
+            "logo-mastodon",
+            "logo-medium",
+            "logo-microsoft",
+            "logo-nodejs",
+            "logo-no-smoking",
+            "logo-npm",
+            "logo-octocat",
+            "logo-paypal",
+            "logo-pinterest",
+            "logo-playstation",
+            "logo-pwa",
+            "logo-python",
+            "logo-react",
+            "logo-reddit",
+            "logo-rss",
+            "logo-sass",
+            "logo-skype",
+            "logo-slack",
+            "logo-snapchat",
+            "logo-soundcloud",
+            "logo-stackoverflow",
+            "logo-steam",
+            "logo-stencil",
+            "logo-tableau",
+            "logo-tiktok",
+            "logo-tumblr",
+            "logo-tux",
+            "logo-twitch",
+            "logo-twitter",
+            "logo-usd",
+            "logo-web-component",
+            "logo-venmo",
+            "logo-whatsapp",
+            "logo-vercel",
+            "logo-vimeo",
+            "logo-windows",
+            "logo-vk",
+            "logo-wordpress",
+            "logo-vue",
+            "logo-xbox",
+            "logo-xing",
+            "logo-yahoo",
+            "logo-yen",
+            "logo-youtube",
+        ];
+    })(Icon.Logo || (Icon.Logo = {}));
 })(exports.Icon || (exports.Icon = {}));
 
 exports.Message = void 0;
@@ -589,7 +1261,7 @@ exports.Data = void 0;
     }
     Data.deepen = deepen;
     function isArrayRecord(d) {
-        return object().is(d) && Object.keys(d).every(k => parseInt(k).toString() == k);
+        return (object().is(d) && (keys => !!keys.length && keys.every(k => parseInt(k).toString() == k))(Object.keys(d)));
     }
     function convertArrays(data) {
         return isArrayRecord(data)
@@ -597,7 +1269,7 @@ exports.Data = void 0;
                 arr[k] = convertArrays(v);
                 return arr;
             }, [])
-            : object().is(data)
+            : object().is(data) && !(data instanceof Blob || data instanceof File)
                 ? Object.fromEntries(Object.entries(data).map(([k, v]) => [k, convertArrays(v)]))
                 : data;
     }
@@ -606,6 +1278,26 @@ exports.Data = void 0;
         return Object.entries(changes).reduce((r, [name, value]) => set(r, name.split("."), value), data);
     }
     Data.merge = merge;
+    function remove(data, name) {
+        const keys = name.split(".");
+        removeKey(data, keys);
+        return data;
+    }
+    Data.remove = remove;
+    function removeKey(current, [head, ...tail]) {
+        if (tail.length === 0) {
+            if (typeof current === "object" && head in current)
+                delete current[head];
+        }
+        else if (typeof current === "object" && head in current) {
+            removeKey(current[head], tail);
+            if (isEmpty(current[head]))
+                delete current[head];
+        }
+    }
+    function isEmpty(current) {
+        return typeof current === "object" && Object.keys(current).length === 0;
+    }
 })(exports.Data || (exports.Data = {}));
 
 exports.Submit = void 0;
@@ -620,6 +1312,23 @@ exports.Submit = void 0;
     Submit.flaw = Submit.type.flaw;
 })(exports.Submit || (exports.Submit = {}));
 
+exports.Scrollable = void 0;
+(function (Scrollable) {
+    function is(element) {
+        const overflow = window.getComputedStyle(element).overflowY;
+        return (overflow == "scroll" ||
+            ((overflow == "auto" || document.documentElement == element) && element.scrollHeight > element.clientHeight));
+    }
+    Scrollable.is = is;
+    function findParent(element) {
+        let parent = element.parentElement;
+        while (parent && !is(parent))
+            parent = parent.parentElement;
+        return parent && is(parent) ? parent : undefined;
+    }
+    Scrollable.findParent = findParent;
+})(exports.Scrollable || (exports.Scrollable = {}));
+
 exports.Listenable = Listenable;
 exports.Type = Type;
 exports.boolean = boolean;
@@ -629,6 +1338,5 @@ exports.number = number;
 exports.object = object;
 exports.record = record;
 exports.string = string;
-exports.union = union;
 
-//# sourceMappingURL=Submit-a58ac294.js.map
+//# sourceMappingURL=Scrollable-a60d6091.js.map