@es-joy/jsoe 0.24.2 → 0.25.0

package/dist/rollup.config.d.ts

@@ -0,0 +1,30 @@
+declare const _default: ({
+    input: string;
+    output: {
+        sourcemap: boolean;
+        file: string;
+        format: string;
+        name?: undefined;
+    };
+    plugins: any[];
+} | {
+    input: string;
+    output: {
+        file: string;
+        format: string;
+        sourcemap?: undefined;
+        name?: undefined;
+    };
+    plugins: any[];
+} | {
+    input: string;
+    output: {
+        file: string;
+        format: string;
+        sourcemap: boolean;
+        name: string;
+    };
+    plugins: any[];
+})[];
+export default _default;
+//# sourceMappingURL=rollup.config.d.ts.map

package/dist/rollup.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup.config.d.ts","sourceRoot":"","sources":["../rollup.config.js"],"names":[],"mappings":""}

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../server.js"],"names":[],"mappings":""}

package/dist/src/formatAndTypeChoices.d.ts

@@ -0,0 +1,108 @@
+/**
+ * @callback SetValue
+ * @param {import('./formats.js').StructuredCloneValue} value
+ * @param {import('./types.js').StateObject} stateObj
+ * @returns {Promise<void>}
+ */
+/**
+ * @typedef {import('./formats/schema.js').ZodexSchema} ZodexSchema
+ */
+/**
+ * Builds a selector and container for types.
+ * @param {object} cfg
+ * @param {string[]} [cfg.schemas] The schema names
+ * @param {(schema: string) => Promise<ZodexSchema>} [cfg.getSchemaContent] The
+ *    schema content retriever
+ * @param {boolean} [cfg.hasValue] Set to `true` if you are supplying
+ *   your own value. If `false` and `hasKeyPath` is `true`,
+ *   will initialize with an object.
+ * @param {boolean} [cfg.singleValue] (NOT IN USE)
+ * @param {boolean} [cfg.hasKeyPath] If this is set (because there is a keyPath
+ *   to be found within the object) and `hasValue` is true, an object type
+ *   will be set and required at the root level. This option will also
+ *   prevent selection of indexedDB key at root (since a key cannot be a
+ *   plain object).
+ * @param {boolean} [cfg.arbitraryJS] Whether to allow the choice of
+ *   arbitrary JavaScript
+ * @param {string} [cfg.typeNamespace] Used to prevent conflicts with other
+ *   instances of typeChoices on the page
+ * @param {string} [cfg.selectedSchema]
+ * @param {import('./formats.js').default} [cfg.formats]
+ * @param {import('./types.js').default} [cfg.types]
+ * @param {boolean} [cfg.preselectSchema]
+ * @returns {Promise<{
+ *   formatChoices: FormatChoices,
+ *   typesHolder: TypesHolder,
+ *   domArray: [formatChoices: FormatChoices, typesHolder: TypesHolder],
+ *   getValue: (stateObj: import('./types.js').StateObject,
+ *     currentPath: string) => import('./formats.js').StructuredCloneValue,
+ *   getType: () => string,
+ *   validValuesSet: () => boolean,
+ *   setValue: SetValue,
+ *   formats: import('./formats.js').default,
+ *   types: import('./types.js').default
+ * }>} The selector for types and the container for them. Both should be
+ *   added to the page.
+ */
+export function formatAndTypeChoices({ schemas, getSchemaContent, hasValue, singleValue, hasKeyPath, arbitraryJS, preselectSchema, typeNamespace, selectedSchema, formats, types }: {
+    schemas?: string[] | undefined;
+    getSchemaContent?: ((schema: string) => Promise<ZodexSchema>) | undefined;
+    hasValue?: boolean | undefined;
+    singleValue?: boolean | undefined;
+    hasKeyPath?: boolean | undefined;
+    arbitraryJS?: boolean | undefined;
+    typeNamespace?: string | undefined;
+    selectedSchema?: string | undefined;
+    formats?: Formats | undefined;
+    types?: Types | undefined;
+    preselectSchema?: boolean | undefined;
+}): Promise<{
+    formatChoices: HTMLSelectElement & {
+        $setFormat: (this: HTMLSelectElement & {
+            $buildTypeChoices: (this: HTMLSelectElement & {
+                $buildTypeChoices: /*elided*/ any;
+            }, autoTrigger?: boolean | undefined) => Promise<void>;
+        }, cfg: {
+            valueFormat?: import("./formats.js").AvailableFormat;
+            autoTrigger: boolean;
+            schema?: string;
+        }) => Promise<void>;
+        $buildTypeChoices: (this: HTMLSelectElement & {
+            $buildTypeChoices: /*elided*/ any;
+        }, autoTrigger?: boolean | undefined) => Promise<void>;
+    };
+    typesHolder: HTMLDivElement;
+    domArray: [formatChoices: HTMLSelectElement & {
+        $setFormat: (this: HTMLSelectElement & {
+            $buildTypeChoices: (this: HTMLSelectElement & {
+                $buildTypeChoices: /*elided*/ any;
+            }, autoTrigger?: boolean | undefined) => Promise<void>;
+        }, cfg: {
+            valueFormat?: import("./formats.js").AvailableFormat;
+            autoTrigger: boolean;
+            schema?: string;
+        }) => Promise<void>;
+        $buildTypeChoices: (this: HTMLSelectElement & {
+            $buildTypeChoices: /*elided*/ any;
+        }, autoTrigger?: boolean | undefined) => Promise<void>;
+    }, typesHolder: HTMLDivElement];
+    getValue: (stateObj: import("./types.js").StateObject, currentPath: string) => import("./formats.js").StructuredCloneValue;
+    getType: () => string;
+    validValuesSet: () => boolean;
+    setValue: SetValue;
+    formats: import("./formats.js").default;
+    types: import("./types.js").default;
+}>;
+export function getFormatAndSchemaChoices({ schemas, selectedSchema, hasKeyPath, preselectSchema, arbitraryJS }?: {
+    schemas?: string[] | undefined;
+    selectedSchema?: string | undefined;
+    hasKeyPath?: boolean | undefined;
+    arbitraryJS?: boolean | undefined;
+    preselectSchema?: boolean | undefined;
+}): DocumentFragment;
+export type SetValue = (value: import("./formats.js").StructuredCloneValue, stateObj: import("./types.js").StateObject) => Promise<void>;
+export type ZodexSchema = import("./formats/schema.js").ZodexSchema;
+export type TypeRootGetter = () => HTMLDivElement | null;
+import Formats from './formats.js';
+import Types from './types.js';
+//# sourceMappingURL=formatAndTypeChoices.d.ts.map

package/dist/src/formatAndTypeChoices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatAndTypeChoices.d.ts","sourceRoot":"","sources":["../../src/formatAndTypeChoices.js"],"names":[],"mappings":"AAkEA;;;;;GAKG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,oLAlCG;IAAuB,OAAO;IACyB,gBAAgB,aAAtD,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC;IAE1B,QAAQ;IAGR,WAAW;IACX,UAAU;IAKV,WAAW;IAEZ,aAAa;IAEb,cAAc;IACU,OAAO;IACT,KAAK;IAC1B,eAAe;CACrC,GAAU,OAAO,CAAC;IAChB,aAAa;;;;qDAyDC,OAAO,CAAC,IAAI,CAAC;gBAlBf;YACN,WAAW,CAAC,EAAE,OAAO,cAAc,EAAE,eAAe,CAAC;YACrD,WAAW,EAAE,OAAO,CAAC;YACrB,MAAM,CAAC,EAAE,MAAM,CAAA;SAChB,KAIS,OAAO,CAAC,IAAI,CAAC;;;iDAUb,OAAO,CAAC,IAAI,CAAC;MAzDE;IAC7B,WAAW,iBAAc;IACzB,QAAQ,EAAE,CAAC,aAAa;;;;qDAuDV,OAAO,CAAC,IAAI,CAAC;gBAlBf;YACN,WAAW,CAAC,EAAE,OAAO,cAAc,EAAE,eAAe,CAAC;YACrD,WAAW,EAAE,OAAO,CAAC;YACrB,MAAM,CAAC,EAAE,MAAM,CAAA;SAChB,KAIS,OAAO,CAAC,IAAI,CAAC;;;iDAUb,OAAO,CAAC,IAAI,CAAC;KAvDY,EAAE,WAAW,gBAAa,CAAC,CAAC;IACnE,QAAQ,EAAE,CAAC,QAAQ,EAAE,OAAO,YAAY,EAAE,WAAW,EACnD,WAAW,EAAE,MAAM,KAAK,OAAO,cAAc,EAAE,oBAAoB,CAAC;IACtE,OAAO,EAAE,MAAM,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,OAAO,CAAC;IAC9B,QAAQ,EAAE,QAAQ,CAAC;IACnB,OAAO,EAAE,OAAO,cAAc,EAAE,OAAO,CAAC;IACxC,KAAK,EAAE,OAAO,YAAY,EAAE,OAAO,CAAA;CACpC,CAAC,CAkPJ;AAxUM,kHAVJ;IAAuB,OAAO;IACT,cAAc;IACb,UAAU;IAGV,WAAW;IAEX,eAAe;CACrC,GAAU,gBAAgB,CAyC5B;+BAIU,OAAO,cAAc,EAAE,oBAAoB,YAC3C,OAAO,YAAY,EAAE,WAAW,KAC9B,OAAO,CAAC,IAAI,CAAC;0BAIb,OAAO,qBAAqB,EAAE,WAAW;mCAlEzC,cAAc,GAAC,IAAI;oBALZ,cAAc;kBADhB,YAAY"}

package/dist/src/formats/arbitraryJS.d.ts

@@ -0,0 +1,4 @@
+export default arbitraryJS;
+/** @type {import('../formats.js').Format} */
+declare const arbitraryJS: import("../formats.js").Format;
+//# sourceMappingURL=arbitraryJS.d.ts.map

package/dist/src/formats/arbitraryJS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arbitraryJS.d.ts","sourceRoot":"","sources":["../../../src/formats/arbitraryJS.js"],"names":[],"mappings":";AAEA,6CAA6C;AAC7C,2BADW,OAAO,eAAe,EAAE,MAAM,CAsBvC"}

package/dist/src/formats/indexedDBKey.d.ts

@@ -0,0 +1,4 @@
+export default indexedDBKey;
+/** @type {import('../formats.js').Format} */
+declare const indexedDBKey: import("../formats.js").Format;
+//# sourceMappingURL=indexedDBKey.d.ts.map

package/dist/src/formats/indexedDBKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexedDBKey.d.ts","sourceRoot":"","sources":["../../../src/formats/indexedDBKey.js"],"names":[],"mappings":";AAEA,6CAA6C;AAC7C,4BADW,OAAO,eAAe,EAAE,MAAM,CA4CvC"}

package/dist/src/formats/json.d.ts

@@ -0,0 +1,4 @@
+export default json;
+/** @type {import('../formats.js').Format} */
+declare const json: import("../formats.js").Format;
+//# sourceMappingURL=json.d.ts.map

package/dist/src/formats/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../src/formats/json.js"],"names":[],"mappings":";AAWA,6CAA6C;AAC7C,oBADW,OAAO,eAAe,EAAE,MAAM,CA2CvC"}

package/dist/src/formats/schema.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @param {ZodexSchema} schemaObject
+ * @param {ZodexSchema} originalJSON
+ * @returns {Set<ZodexSchema>}
+ */
+export function getTypesForSchema(schemaObject: ZodexSchema, originalJSON: ZodexSchema): Set<ZodexSchema>;
+export default schema;
+export type ZodexSchema = import("zodex").SzType;
+export type NestedObject = import("../utils/objects.js").NestedObject;
+/**
+ * <T>
+ */
+export type ValueOf<T> = T[keyof T];
+export type AvailableZodexType = ValueOf<Pick<import("zodex").SzType, "type">>;
+/** @type {import('../formats.js').Format} */
+declare const schema: import("../formats.js").Format;
+//# sourceMappingURL=schema.d.ts.map

package/dist/src/formats/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/formats/schema.js"],"names":[],"mappings":"AA0MA;;;;GAIG;AACH,gDAJW,WAAW,gBACX,WAAW,GACT,GAAG,CAAC,WAAW,CAAC,CAiV5B;;0BAjeY,OAAO,OAAO,EAAE,MAAM;2BAGtB,OAAO,qBAAqB,EAAE,YAAY;;;;oBAtD1C,CAAC,IADD,CAAC,CAAC,MAAM,CAAC,CAAC;iCAKV,OAAO,CAChB,IAAI,CAAC,OAAO,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CACrC;AAghBH,6CAA6C;AAC7C,sBADW,OAAO,eAAe,EAAE,MAAM,CAoNvC"}

package/dist/src/formats/structuredCloning.d.ts

@@ -0,0 +1,19 @@
+export default structuredCloning;
+/**
+ * Delegates data-based UI building to method for adding child elements (a
+ *   method which is housed in the array type object).
+ */
+export type AddAndSetArrayElement = (info: {
+    propName: string;
+    type: import("../types.js").AvailableArbitraryType;
+    value: import("../formats.js").StructuredCloneValue;
+    bringIntoFocus?: boolean;
+    setAValue?: boolean;
+    schemaContent?: import("../formats/schema.js").ZodexSchema;
+    mustBeOptional?: boolean;
+    schemaIdx?: number;
+}) => HTMLElement | null;
+export type EncapsulateObserver = import("typeson-registry").EncapsulateObserver;
+/** @type {import('../formats.js').Format} */
+declare const structuredCloning: import("../formats.js").Format;
+//# sourceMappingURL=structuredCloning.d.ts.map

package/dist/src/formats/structuredCloning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structuredCloning.d.ts","sourceRoot":"","sources":["../../../src/formats/structuredCloning.js"],"names":[],"mappings":";;;;;oCAwBa,CAAC,IAAI,EAAE;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,OAAO,aAAa,EAAE,sBAAsB,CAAC;IACnD,KAAK,EAAE,OAAO,eAAe,EAAE,oBAAoB,CAAC;IACpD,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,aAAa,CAAC,EAAE,OAAO,sBAAsB,EAAE,WAAW,CAAC;IAC3D,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,KAAK,WAAW,GAAC,IAAI;kCAIZ,OAAO,kBAAkB,EAAE,mBAAmB;AAmc3D,6CAA6C;AAC7C,iCADW,OAAO,eAAe,EAAE,MAAM,CAqKvC"}

package/dist/src/formats.d.ts

@@ -0,0 +1,135 @@
+export default Formats;
+/**
+ * An arbitrary Structured Clone, JSON, etc. value.
+ */
+export type StructuredCloneValue = any;
+export type GetTypesAndSchemasForFormatAndState = (types: import("./types.js").default, format: AvailableFormat, state?: string | undefined, schemaObject?: import("./formatAndTypeChoices.js").ZodexSchema | undefined, schemaOriginal?: import("./formatAndTypeChoices.js").ZodexSchema | undefined) => TypesAndSchemaObjects | undefined;
+export type AvailableFormat = "indexedDBKey" | "json" | "structuredCloning" | "arbitraryJS" | "schema";
+export type TypesAndSchemaObjects = {
+    types: (import("./types.js").AvailableArbitraryType)[];
+    schemaObjects: import("./formats/schema.js").ZodexSchema[];
+};
+/**
+ * Responsible for traversing over data (along with state information) to build
+ *   and return a relevant UI element.
+ */
+export type FormatIterator = (records: StructuredCloneValue, stateObj: import("./types.js").StateObject) => Promise<Required<import("./types.js").StateObject>>;
+export type Format = {
+    /**
+     * Returns list
+     * of types generally available to structured cloning. See
+     * {@link getTypesAndSchemasForState} for context-dependent method.
+     */
+    types: () => (import("./types.js").AvailableArbitraryType)[];
+    /**
+     * Traverses over data to build and return
+     * a relevant UI element.
+     */
+    iterate: FormatIterator;
+    /**
+     * Gets the
+     * specific types (and schemas) relevant to a given state.
+     */
+    getTypesAndSchemasForState: (types: import("./types.js").default, state?: string, schemaObject?: import("./formatAndTypeChoices.js").ZodexSchema | undefined, schemaOriginal?: import("./formatAndTypeChoices.js").ZodexSchema | undefined) => TypesAndSchemaObjects | undefined;
+    testInvalid?: ((newType: string, value: Date | Array<StructuredCloneValue>) => boolean | undefined) | undefined;
+    convertFromTypeson?: ((typesonType: import("./types.js").AvailableArbitraryType, types: import("./types.js").default, v?: import("./formats.js").StructuredCloneValue, arrayOrObjectPropertyName?: string, parentSchema?: [import("zodex").SzType, number | undefined] | undefined, stateObj?: import("./types.js").StateObject) => {
+        type: import("./types.js").AvailableArbitraryType | undefined;
+        schema?: import("zodex").SzType | undefined;
+        mustBeOptional?: boolean;
+        schemaIdx?: number;
+    }) | undefined;
+};
+/**
+ * An arbitrary Structured Clone, JSON, etc. value.
+ * @typedef {any} StructuredCloneValue
+ */
+/**
+ * @callback GetTypesAndSchemasForFormatAndState
+ * @param {import('./types.js').default} types
+ * @param {AvailableFormat} format
+ * @param {string} [state]
+ * @param {import('./formatAndTypeChoices.js').ZodexSchema|
+ *   undefined} [schemaObject]
+ * @param {import('./formatAndTypeChoices.js').ZodexSchema|
+ *   undefined} [schemaOriginal]
+ * @returns {TypesAndSchemaObjects|undefined}
+ */
+/**
+ * @typedef {"indexedDBKey"|"json"|"structuredCloning"|
+ *   "arbitraryJS"|"schema"} AvailableFormat
+ */
+/**
+ * @typedef {{
+ *   types: (import('./types.js').AvailableArbitraryType)[],
+ *   schemaObjects: import('./formats/schema.js').ZodexSchema[]
+ * }} TypesAndSchemaObjects
+ */
+/**
+ * Responsible for traversing over data (along with state information) to build
+ *   and return a relevant UI element.
+ * @callback FormatIterator
+ * @param {StructuredCloneValue} records
+ * @param {import('./types.js').StateObject} stateObj
+ * @returns {Promise<Required<import('./types.js').StateObject>>}
+ */
+/**
+ * @typedef {object} Format
+ * @property {() => (
+ *   import('./types.js').AvailableArbitraryType
+ * )[]} types Returns list
+ *   of types generally available to structured cloning. See
+ *   {@link getTypesAndSchemasForState} for context-dependent method.
+ * @property {FormatIterator} iterate Traverses over data to build and return
+ *   a relevant UI element.
+ * @property {(
+ *   types: import('./types.js').default,
+ *   state?: string,
+ *   schemaObject?: import('./formatAndTypeChoices.js').ZodexSchema|
+ *     undefined,
+ *   schemaOriginal?: import('./formatAndTypeChoices.js').ZodexSchema|
+ *     undefined
+ * ) => TypesAndSchemaObjects|undefined} getTypesAndSchemasForState Gets the
+ *   specific types (and schemas) relevant to a given state.
+ * @property {(
+ *     newType: string, value: Date|Array<StructuredCloneValue>
+ *   ) => boolean|undefined} [testInvalid]
+ * @property {(
+ *   typesonType: import('./types.js').AvailableArbitraryType,
+ *   types: import('./types.js').default,
+ *   v?: import('./formats.js').StructuredCloneValue,
+ *   arrayOrObjectPropertyName?: string,
+ *   parentSchema?: [
+ *     import('zodex').SzType,
+ *     number|undefined
+ *   ]|undefined,
+ *   stateObj?: import('./types.js').StateObject,
+ * ) => {
+ *   type: import('./types.js').AvailableArbitraryType|undefined
+ *   schema?: import('zodex').SzType|undefined,
+ *   mustBeOptional?: boolean,
+ *   schemaIdx?: number
+ * }} [convertFromTypeson]
+ */
+/**
+ * Class for processing multiple formats.
+ */
+declare class Formats {
+    availableFormats: {
+        [key: string]: Format;
+    };
+    /**
+     * @param {import('./types.js').default} types
+     * @param {AvailableFormat} format
+     * @param {StructuredCloneValue} record
+     * @param {import('./types.js').StateObject} stateObj
+     * @returns {Promise<Required<import('./types.js').StateObject>>}
+     */
+    getControlsForFormatAndValue(types: import("./types.js").default, format: AvailableFormat, record: StructuredCloneValue, stateObj: import("./types.js").StateObject): Promise<Required<import("./types.js").StateObject>>;
+    getTypesAndSchemasForFormatAndState(types: import("./types.js").default, format: AvailableFormat, state?: string | undefined, schemaObject?: import("./formatAndTypeChoices.js").ZodexSchema | undefined, schemaOriginal?: import("./formatAndTypeChoices.js").ZodexSchema | undefined): TypesAndSchemaObjects | undefined;
+    /**
+     * @param {AvailableFormat} format
+     * @returns {Format}
+     */
+    getAvailableFormat(format: AvailableFormat): Format;
+}
+//# sourceMappingURL=formats.d.ts.map

package/dist/src/formats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formats.d.ts","sourceRoot":"","sources":["../../src/formats.js"],"names":[],"mappings":";;;;mCAQa,GAAG;0DAKL,OAAO,YAAY,EAAE,OAAO,UAC5B,eAAe,6CAEf,OAAO,2BAA2B,EAAE,WAAW,GACzD,SAAa,mBACH,OAAO,2BAA2B,EAAE,WAAW,GACzD,SAAa,KACD,qBAAqB,GAAC,SAAS;8BAa/B,cAAc,GAAC,MAAM,GAAC,mBAAmB,GACrD,aAAiB,GAAC,QAAQ;oCAId;IACR,KAAK,EAAE,CAAC,OAAO,YAAY,EAAE,sBAAsB,CAAC,EAAE,CAAC;IACvD,aAAa,EAAE,OAAO,qBAAqB,EAAE,WAAW,EAAE,CAAA;CAC3D;;;;;uCAOO,oBAAoB,YACpB,OAAO,YAAY,EAAE,WAAW,KAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,YAAY,EAAE,WAAW,CAAC,CAAC;;;;;;;WAKlD,MAAM,CACnB,OAAW,YAAY,EAAE,sBAAsB,CAC5C,EAAE;;;;;aAGQ,cAAc;;;;;gCAEd,CACT,KAAK,EAAE,OAAO,YAAY,EAAE,OAAO,EACnC,KAAK,CAAC,EAAE,MAAM,EACd,YAAY,CAAC,EAAE,OAAO,2BAA2B,EAAE,WAAW,GAClE,SAAe,EACX,cAAc,CAAC,EAAE,OAAO,2BAA2B,EAAE,WAAW,GACpE,SAAe,KACR,qBAAqB,GAAC,SAAS;6BAGvB,MAAM,SAAS,IAAI,GAAC,KAAK,CAAC,oBAAoB,CAAC,KACrD,OAAO,GAAC,SAAS;wCAET,OAAO,YAAY,EAAE,sBAAsB,SACjD,OAAO,YAAY,EAAE,OAAO,MAC/B,OAAO,cAAc,EAAE,oBAAoB,8BACnB,MAAM,iBACnB,CACnB,OAAa,OAAO,EAAE,MAAM,EAC5B,MAAY,GAAC,SAAS,CACjB,GAAC,SAAS,aACA,OAAO,YAAY,EAAE,WAAW,KACxC;QACH,IAAI,EAAE,OAAO,YAAY,EAAE,sBAAsB,GAAC,SAAS,CAAA;QAC3D,MAAM,CAAC,EAAE,OAAO,OAAO,EAAE,MAAM,GAAC,SAAS,CAAC;QAC1C,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,SAAS,CAAC,EAAE,MAAM,CAAA;KACnB;;AAnFJ;;;GAGG;AAEH;;;;;;;;;;GAUG;AAWH;;;GAGG;AAEH;;;;;GAKG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH;;GAEG;AACH;IA+BI;;MAME;IAGJ;;;;;;OAMG;IACH,oCANW,OAAO,YAAY,EAAE,OAAO,UAC5B,eAAe,UACf,oBAAoB,YACpB,OAAO,YAAY,EAAE,WAAW,GAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,YAAY,EAAE,WAAW,CAAC,CAAC,CAY/D;IA5IA,2CACQ,OAAO,YAAY,EAAE,OAAO,UAC5B,eAAe,6CAEf,OAAO,2BAA2B,EAAE,WAAW,GACzD,SAAa,mBACH,OAAO,2BAA2B,EAAE,WAAW,GACzD,SAAa,GACD,qBAAqB,GAAC,SAAS,CAC3C;IAgJC;;;OAGG;IACH,2BAHW,eAAe,GACb,MAAM,CAIlB;CACF"}

package/dist/src/fundamentalTypes/BooleanObjectType.d.ts

@@ -0,0 +1,8 @@
+export default BooleanObjectType;
+/**
+ * @type {import('../types.js').TypeObject & {ct: number}}
+ */
+declare const BooleanObjectType: import("../types.js").TypeObject & {
+    ct: number;
+};
+//# sourceMappingURL=BooleanObjectType.d.ts.map

package/dist/src/fundamentalTypes/BooleanObjectType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BooleanObjectType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/BooleanObjectType.js"],"names":[],"mappings":";AAGA;;GAEG;AACH,iCAFU,OAAO,aAAa,EAAE,UAAU,GAAG;IAAC,EAAE,EAAE,MAAM,CAAA;CAAC,CA8DvD"}

package/dist/src/fundamentalTypes/NumberObjectType.d.ts

@@ -0,0 +1,6 @@
+export default NumberObjectType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const NumberObjectType: import("../types.js").TypeObject;
+//# sourceMappingURL=NumberObjectType.d.ts.map

package/dist/src/fundamentalTypes/NumberObjectType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NumberObjectType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/NumberObjectType.js"],"names":[],"mappings":";AAIA;;GAEG;AACH,gCAFU,OAAO,aAAa,EAAE,UAAU,CAiDxC"}

package/dist/src/fundamentalTypes/StringObjectType.d.ts

@@ -0,0 +1,6 @@
+export default StringObjectType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const StringObjectType: import("../types.js").TypeObject;
+//# sourceMappingURL=StringObjectType.d.ts.map

package/dist/src/fundamentalTypes/StringObjectType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringObjectType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/StringObjectType.js"],"names":[],"mappings":";AAGA;;GAEG;AACH,gCAFU,OAAO,aAAa,EAAE,UAAU,CA0CxC"}

package/dist/src/fundamentalTypes/arrayReferenceType.d.ts

@@ -0,0 +1,8 @@
+export default arrayReferenceType;
+/**
+ * @type {import('../types.js').TypeObject & {type: "array"}}
+ */
+declare const arrayReferenceType: import("../types.js").TypeObject & {
+    type: "array";
+};
+//# sourceMappingURL=arrayReferenceType.d.ts.map

package/dist/src/fundamentalTypes/arrayReferenceType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayReferenceType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/arrayReferenceType.js"],"names":[],"mappings":";AAMA;;GAEG;AACH,kCAFU,OAAO,aAAa,EAAE,UAAU,GAAG;IAAC,IAAI,EAAE,OAAO,CAAA;CAAC,CAiN1D"}

package/dist/src/fundamentalTypes/arrayType.d.ts

@@ -0,0 +1,29 @@
+export default arrayType;
+export type Integer = number;
+export type ParseInt = (this: HTMLInputElement) => false | Integer;
+export type InputsExceedingLength = () => HTMLInputElement[];
+export type GetMapKeySelects = () => (HTMLSelectElement & {
+    $getValue: import("../typeChoices.js").GetValue;
+})[];
+export type ValidateMapKey = () => void;
+export type GetPropertyInputs = () => HTMLInputElement[];
+export type RedrawMoveArrows = () => void;
+export type GetArrayItems = () => HTMLDivElement & {
+    $inputsExceedingLength: InputsExceedingLength;
+    $getPropertyInputs: GetPropertyInputs;
+    $redrawMoveArrows: RedrawMoveArrows;
+    $getMapKeySelects: GetMapKeySelects;
+};
+export type Validate = () => Promise<void>;
+export type Resort = (cfg: {
+    alwaysFocus?: true;
+}) => void;
+export type GetPropertyInput = () => HTMLInputElement | undefined;
+export type AnyValue = any;
+/**
+ * @type {import('../types.js').TypeObject & {sparse?: boolean|undefined}}
+ */
+declare const arrayType: import("../types.js").TypeObject & {
+    sparse?: boolean | undefined;
+};
+//# sourceMappingURL=arrayType.d.ts.map

package/dist/src/fundamentalTypes/arrayType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/arrayType.js"],"names":[],"mappings":";sBAaa,MAAM;mDAKN,KAAK,GAAC,OAAO;oCAGb,MAAM,gBAAgB,EAAE;+BAGxB,MAAM,CAAC,iBAAiB,GAAG;IACnC,SAAS,EAAE,OAAO,mBAAmB,EAAE,QAAQ,CAAA;CAChD,CAAC,EAAE;6BAGM,MAAM,IAAI;sCAIV,gBAAgB,EAAE;qCAKlB,IAAI;4BAGJ,MAAM,cAAc,GAAG;IAC/B,sBAAsB,EAAE,qBAAqB,CAAC;IAC9C,kBAAkB,EAAE,iBAAiB,CAAC;IACtC,iBAAiB,EAAE,gBAAgB,CAAC;IACpC,iBAAiB,EAAE,gBAAgB,CAAA;CACpC;uBAGS,MAAM,OAAO,CAAC,IAAI,CAAC;2BAKrB;IAAC,WAAW,CAAC,EAAE,IAAI,CAAA;CAAC,KAClB,IAAI;+BAIJ,MAAM,gBAAgB,GAAC,SAAS;uBAIhC,GAAG;AAmBhB;;GAEG;AACH,yBAFU,OAAO,aAAa,EAAE,UAAU,GAAG;IAAC,MAAM,CAAC,EAAE,OAAO,GAAC,SAAS,CAAA;CAAC,CAw1EvE"}

package/dist/src/fundamentalTypes/bigintObjectType.d.ts

@@ -0,0 +1,6 @@
+export default bigintObjectType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const bigintObjectType: import("../types.js").TypeObject;
+//# sourceMappingURL=bigintObjectType.d.ts.map

package/dist/src/fundamentalTypes/bigintObjectType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigintObjectType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/bigintObjectType.js"],"names":[],"mappings":";AAGA;;GAEG;AACH,gCAFU,OAAO,aAAa,EAAE,UAAU,CAyDxC"}

package/dist/src/fundamentalTypes/bigintType.d.ts

@@ -0,0 +1,6 @@
+export default bigintType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const bigintType: import("../types.js").TypeObject;
+//# sourceMappingURL=bigintType.d.ts.map

package/dist/src/fundamentalTypes/bigintType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigintType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/bigintType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,0BAFU,OAAO,aAAa,EAAE,UAAU,CAyExC"}

package/dist/src/fundamentalTypes/blobType.d.ts

@@ -0,0 +1,11 @@
+export default blobType;
+export type BlobInfo = Blob | {
+    size: string;
+    type: string;
+};
+export type SetValue = (blob: BlobInfo) => void;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const blobType: import("../types.js").TypeObject;
+//# sourceMappingURL=blobType.d.ts.map

package/dist/src/fundamentalTypes/blobType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blobType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/blobType.js"],"names":[],"mappings":";uBAMa,IAAI,GAAC;IACb,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAC3B;uBAIS,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI;AAsIrC;;GAEG;AACH,wBAFU,OAAO,aAAa,EAAE,UAAU,CA02BxC"}

package/dist/src/fundamentalTypes/booleanType.d.ts

@@ -0,0 +1,8 @@
+export default booleanType;
+/**
+ * @type {import('../types.js').TypeObject & {ct: number}}
+ */
+declare const booleanType: import("../types.js").TypeObject & {
+    ct: number;
+};
+//# sourceMappingURL=booleanType.d.ts.map

package/dist/src/fundamentalTypes/booleanType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"booleanType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/booleanType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,2BAFU,OAAO,aAAa,EAAE,UAAU,GAAG;IAAC,EAAE,EAAE,MAAM,CAAA;CAAC,CAgEvD"}

package/dist/src/fundamentalTypes/catchType.d.ts

@@ -0,0 +1,6 @@
+export default catchType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const catchType: import("../types.js").TypeObject;
+//# sourceMappingURL=catchType.d.ts.map

package/dist/src/fundamentalTypes/catchType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catchType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/catchType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,yBAFU,OAAO,aAAa,EAAE,UAAU,CAoIxC"}

package/dist/src/fundamentalTypes/dateType.d.ts

@@ -0,0 +1,26 @@
+export default dateType;
+export type SetValidity = (legitimateInvalid?: boolean | undefined) => void;
+/**
+ * @typedef {(
+ *   legitimateInvalid?: boolean|undefined
+ * ) => void} SetValidity
+ */
+/**
+ * @type {import('../types.js').TypeObject & {
+ *   dateRegex: RegExp,
+ *   isInvalid: (cfg: {root: HTMLDivElement}) => boolean,
+ *   isValueInvalid: (
+ *     value: import('../formats.js').StructuredCloneValue
+ *   ) => boolean
+ *   valid?: true
+ * }}
+ */
+declare const dateType: import("../types.js").TypeObject & {
+    dateRegex: RegExp;
+    isInvalid: (cfg: {
+        root: HTMLDivElement;
+    }) => boolean;
+    isValueInvalid: (value: import("../formats.js").StructuredCloneValue) => boolean;
+    valid?: true;
+};
+//# sourceMappingURL=dateType.d.ts.map

package/dist/src/fundamentalTypes/dateType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dateType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/dateType.js"],"names":[],"mappings":";0BAIa,CACR,iBAAiB,CAAC,EAAE,OAAO,GAAC,SAAS,KAClC,IAAI;AAHZ;;;;GAIG;AAEH;;;;;;;;;GASG;AACH,wBATU,OAAO,aAAa,EAAE,UAAU,GAAG;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,CAAC,GAAG,EAAE;QAAC,IAAI,EAAE,cAAc,CAAA;KAAC,KAAK,OAAO,CAAC;IACpD,cAAc,EAAE,CACd,KAAK,EAAE,OAAO,eAAe,EAAE,oBAAoB,KAChD,OAAO,CAAA;IACZ,KAAK,CAAC,EAAE,IAAI,CAAA;CACb,CAkLF"}

package/dist/src/fundamentalTypes/domexceptionType.d.ts

@@ -0,0 +1,6 @@
+export default domexceptionType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const domexceptionType: import("../types.js").TypeObject;
+//# sourceMappingURL=domexceptionType.d.ts.map

package/dist/src/fundamentalTypes/domexceptionType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domexceptionType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/domexceptionType.js"],"names":[],"mappings":";AAKA;;GAEG;AACH,gCAFU,OAAO,aAAa,EAAE,UAAU,CAiHxC"}

package/dist/src/fundamentalTypes/enumType.d.ts

@@ -0,0 +1,6 @@
+export default enumType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const enumType: import("../types.js").TypeObject;
+//# sourceMappingURL=enumType.d.ts.map

package/dist/src/fundamentalTypes/enumType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/enumType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,wBAFU,OAAO,aAAa,EAAE,UAAU,CA8CxC"}

package/dist/src/fundamentalTypes/errorType.d.ts

@@ -0,0 +1,6 @@
+export default errorType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const errorType: import("../types.js").TypeObject;
+//# sourceMappingURL=errorType.d.ts.map

package/dist/src/fundamentalTypes/errorType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/errorType.js"],"names":[],"mappings":";AAIA;;GAEG;AACH,yBAFU,OAAO,aAAa,EAAE,UAAU,CAwaxC"}

package/dist/src/fundamentalTypes/fileType.d.ts

@@ -0,0 +1,13 @@
+export default fileType;
+export type FileInfo = File | {
+    name: string;
+    size: string;
+    type: string;
+    lastModified: string;
+};
+export type SetValue = (file: FileInfo) => void;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const fileType: import("../types.js").TypeObject;
+//# sourceMappingURL=fileType.d.ts.map

package/dist/src/fundamentalTypes/fileType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/fileType.js"],"names":[],"mappings":";uBAMa,IAAI,GAAC;IACb,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IACzC,YAAY,EAAE,MAAM,CAAA;CACrB;uBAIS,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI;AAuJrC;;GAEG;AACH,wBAFU,OAAO,aAAa,EAAE,UAAU,CA27BxC"}

package/dist/src/fundamentalTypes/filelistType.d.ts

@@ -0,0 +1,6 @@
+export default filelistType;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const filelistType: import("../types.js").TypeObject;
+//# sourceMappingURL=filelistType.d.ts.map

package/dist/src/fundamentalTypes/filelistType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filelistType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/filelistType.js"],"names":[],"mappings":";AAGA;;GAEG;AACH,4BAFU,OAAO,aAAa,EAAE,UAAU,CAkCxC"}

package/dist/src/fundamentalTypes/functionType.d.ts

@@ -0,0 +1,7 @@
+export default functionType;
+export type ArbitraryFunction = Function;
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+declare const functionType: import("../types.js").TypeObject;
+//# sourceMappingURL=functionType.d.ts.map

package/dist/src/fundamentalTypes/functionType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functionType.d.ts","sourceRoot":"","sources":["../../../src/fundamentalTypes/functionType.js"],"names":[],"mappings":";;AAkKA;;GAEG;AACH,4BAFU,OAAO,aAAa,EAAE,UAAU,CAsJxC"}