@es-joy/jsoe 0.12.0 → 0.12.2

package/dist/src/typeChoices.d.ts

@@ -1,30 +0,0 @@
-/**
- * An arbitrary Structured Clone, JSON, etc. value.
- * @typedef {any} StructuredCloneValue
- */
-/**
- * @callback BuildTypeChoices
- * @param {object} cfg
- * @param {string} cfg.format
- * @param {string} cfg.typeNamespace
- * @param {StructuredCloneValue} cfg.value
- * @param {boolean} [cfg.setValue=false]
- * @param {string} cfg.state
- * @param {string} cfg.keySelectClass
- * @param {boolean} cfg.requireObject
- * @param {boolean} cfg.objectHasValue
- * @param {RootElement} cfg.topRoot Always a `div` element?
- * @param {string} cfg.schema Schema name
- * @param {string} cfg.schemaContent Schema contents
- * @returns {[select: Element, typeContainer: Element]}
- */
-/**
- * @type {BuildTypeChoices}
- */
-export const buildTypeChoices: BuildTypeChoices;
-/**
- * An arbitrary Structured Clone, JSON, etc. value.
- */
-export type StructuredCloneValue = any;
-export type BuildTypeChoices = (cfg: object, format: string, typeNamespace: string, value: StructuredCloneValue, setValue?: boolean | undefined, state: string, keySelectClass: string, requireObject: boolean, objectHasValue: boolean, topRoot: RootElement, schema: string, schemaContent: string) => [select: Element, typeContainer: Element];
-//# sourceMappingURL=typeChoices.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"typeChoices.d.ts","sourceRoot":"","sources":["../../src/typeChoices.js"],"names":[],"mappings":"AAOA;;;GAGG;AAEH;;;;;;;;;;;;;;;GAeG;AAEH;;GAEG;AACH,+BAFU,gBAAgB,CA0NxB;;;;mCA/OW,GAAG;qCAKL,MAAM,UACN,MAAM,iBACN,MAAM,SACN,oBAAoB,yCAEpB,MAAM,kBACN,MAAM,iBACN,OAAO,kBACP,OAAO,gCAEP,MAAM,iBACN,MAAM,KACJ,CAAC,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC"}

package/dist/src/types.d.ts

@@ -1,333 +0,0 @@
-export function getPropertyValueFromLegend(legend: HTMLLegendElement): string;
-export default Types;
-export type TypeObject = {
-    /**
-     * Creates the option
-     * HTML. May set an option `title` or `value`
-     */
-    option: import('jamilih').JamilihArray;
-    /**
-     * Private context variable. Whether or not
-     * it is an array. Do not use in other types.
-     */
-    array?: boolean | undefined;
-    /**
-     * Used for string parsing.
-     */
-    regexEndings?: string[] | undefined;
-    /**
-     * Used for string parsing. If not
-     * present, use `stringRegexBegin` and `stringRegexEnd`
-     */
-    stringRegex?: RegExp | undefined;
-    /**
-     * Used for string parsing. If not
-     * present, use `stringRegex`
-     */
-    stringRegexBegin?: RegExp | undefined;
-    /**
-     * Used for string parsing. If not
-     * present, use `stringRegex`
-     */
-    stringRegexEnd?: RegExp | undefined;
-    /**
-     * Function to
-     * check whether this subtype matches
-     */
-    valueMatch?: ((ArbitraryValue: any) => boolean) | undefined;
-    /**
-     * The greater fundamental type to which
-     * the type belongs
-     */
-    superType?: string | undefined;
-    /**
-     * Converts from
-     * string to value. May use `stringRegex` to find components.
-     */
-    toValue: (s: string) => ArbitraryValue;
-    /**
-     * Gets the value for the type
-     */
-    getValue: (info: {
-        root?: HTMLDivElement;
-    }) => ArbitraryValue;
-    /**
-     * Should set
-     * the value of the form's `getInput` element
-     */
-    setValue?: ((info: {
-        root?: HTMLDivElement;
-    }) => void) | undefined;
-    viewUI: (info: {
-        value?: ArbitraryValue;
-        typeNamespace?: string;
-        type?: string;
-        topRoot?: HTMLDivElement;
-        resultType?: "keys" | "values" | "both";
-        format?: string;
-    }) => JamilihArray;
-    editUI: (info: {
-        value?: ArbitraryValue;
-        typeNamespace?: string;
-    }) => JamilihArray;
-    /**
-     * Gets the
-     * form control (with `value`)
-     */
-    getInput: (info: {
-        root: HTMLDivElement;
-    }) => HTMLInputElement | HTMLTextareaElement | HTMLSelectElement;
-    /**
-     * Gets the reference. For array and object
-     * references types only
-     */
-    resolveReference?: ((path: string, value: ArbitraryValue) => ArbitraryValue) | undefined;
-    /**
-     * Message will be used if validity is false.
-     */
-    validate?: ((info: {
-        root: HTMLDivElement;
-        topRoot?: HTMLDivElement;
-    }) => {
-        message: string;
-        valid: boolean;
-    }) | undefined;
-    /**
-     * For
-     * validation of array and object references only.
-     */
-    validateAll?: ((info: {
-        topRoot: HTMLDivElement;
-    }) => void) | undefined;
-    /**
-     * The type after which it should be placed and its
-     * context types
-     */
-    stateDependent?: {
-        structuredCloning: {
-            after: string;
-            contexts: string[];
-        };
-    } | undefined;
-};
-export type GetPossibleSchemasForPathAndType = (keypath: string, parentPath: string, arrayOrObjectPropertyName: string, valueType: string) => StateObject;
-export type StateObject = {
-    typeNamespace: string;
-    "readonly": boolean;
-    format: string;
-    error: Error;
-    rootUI: Element;
-    schemaContent: string;
-    getPossibleSchemasForPathAndType: GetPossibleSchemasForPathAndType;
-};
-/**
- * Any other possibilities than `div`?
- */
-export type RootElement = HTMLDivElement;
-declare namespace Types {
-    namespace availableTypes {
-        namespace ValidDate {
-            const valid: boolean;
-        }
-        namespace arrayNonindexKeys {
-            const sparse: boolean;
-        }
-    }
-    /**
-     * Utility to retrieve the type out of a type root element.
-     * @public
-     * @param {?RootElement} root
-     * @returns {string|undefined} Why would it not exist?
-     */
-    function getTypeForRoot(root: HTMLDivElement | null): string | undefined;
-    /**
-     * @typedef {(
-     *     keypath: string,
-    *     parentPath: string,
-    *     arrayOrObjectPropertyName: string,
-    *     valueType: string
-    *   ) => StateObject} GetPossibleSchemasForPathAndType
-     */
-    /**
-     * @typedef {{
-     *   typeNamespace: string,
-     *   "readonly": boolean,
-     *   format: string,
-     *   error: Error,
-     *   rootUI: Element,
-     *   schemaContent: string,
-     *   getPossibleSchemasForPathAndType: GetPossibleSchemasForPathAndType
-     * }} StateObject
-     */
-    /**
-     * Utility to get the value out of a type root element with a given
-     *   state and path.
-     * @public
-     * @param {RootElement} root
-     * @param {StateObject} stateObj
-     * @param {string} [currentPath]
-     * @returns {StructuredCloneValue}
-     */
-    function getValueForRoot(root: HTMLDivElement, stateObj: StateObject, currentPath?: string | undefined): StructuredCloneValue;
-    /**
-     * Utility to get the form control (e.g., input element) for a root.
-     * @public
-     * @param {RootElement} root
-     * @returns {null|HTMLInputElement}
-     */
-    function getFormControlForRoot(root: HTMLDivElement): HTMLInputElement | null;
-    /**
-     * Utility to get the value for a root using its ancestor and state.
-     * @public
-     * @param {string|Element} selOrEl
-     * @param {StateObject} stateObj
-     * @returns {StructuredCloneValue}
-     */
-    function getValueFromRootAncestor(selOrEl: string | Element, stateObj: StateObject): StructuredCloneValue;
-    /**
-     * @public
-     * @param {string|Element} selOrEl
-     * @returns {null|HTMLInputElement}
-     */
-    function getFormControlFromRootAncestor(selOrEl: string | Element): HTMLInputElement | null;
-    /**
-     * @param {string} format
-     * @param {string} state
-     * @returns {string[]}
-     */
-    function getTypesForFormatAndState(format: string, state: string): string[];
-    /**
-     * @public
-     * @param {string} type
-     * @returns {JamilihArray}
-     */
-    function getOptionForType(type: string): JamilihArray;
-    /**
-     * @public
-     * @param {string} format
-     * @param {string} parserState
-     * @returns {JamilihArray[]}
-     */
-    function getTypeOptionsForFormatAndState(format: string, parserState: string): JamilihArray[];
-    /**
-     * @public
-     * @param {object} cfg
-     * @param {boolean} cfg."readonly"
-     * @param {"both"|"keys"|"values"} cfg.resultType
-     * @param {string} cfg.typeNamespace
-     * @param {string} cfg.type
-     * @param {RootElement} cfg.topRoot
-     * @param {boolean} cfg.bringIntoFocus
-     * @param {BuildTypeChoices} cfg.buildTypeChoices
-     * @param {string} cfg.format
-     * @param {string} cfg.schemaContent
-     * @param {GetPossibleSchemasForPathAndType} cfg.schemaState Not currently
-     *   in use
-     * @param {StructuredCloneValue} cfg.value
-     * @param {boolean} cfg.hasValue
-     * @returns {Element}
-     */
-    function getUIForModeAndType({ readonly, resultType, typeNamespace, type, topRoot, bringIntoFocus, buildTypeChoices, format, schemaContent, schemaState, value, hasValue }: {
-        "": boolean;
-        resultType: "keys" | "values" | "both";
-        typeNamespace: string;
-        type: string;
-        topRoot: HTMLDivElement;
-        bringIntoFocus: boolean;
-        buildTypeChoices: BuildTypeChoices;
-        format: string;
-        schemaContent: string;
-        schemaState: GetPossibleSchemasForPathAndType;
-        value: StructuredCloneValue;
-        hasValue: boolean;
-    }): Element;
-    const contexts: {};
-    /**
-     * @public
-     * @param {object} cfg
-     * @param {HTMLFormElement} cfg.form
-     * @param {string} cfg.typeNamespace
-     * @param {string} cfg.keySelectClass
-     * @returns {boolean}
-     */
-    function validValuesSet({ form, typeNamespace, keySelectClass }: {
-        form: HTMLFormElement;
-        typeNamespace: string;
-        keySelectClass: string;
-    }): boolean;
-    /**
-     * Any other possibilities than `div`?
-     * @typedef {HTMLDivElement} RootElement
-     */
-    /**
-     * @public
-     * @param {object} cfg
-     * @param {RootElement} cfg.topRoot
-     * @returns {void}
-     */
-    function validateAllReferences({ topRoot }: {
-        topRoot: HTMLDivElement;
-    }): void;
-    /**
-     * @public
-     * @param {object} cfg
-     * @param {string} cfg.type
-     * @param {RootElement} cfg.root
-     * @param {RootElement} cfg.topRoot
-     * @returns {boolean}
-     */
-    function validate({ type, root, topRoot }: {
-        type: string;
-        root: HTMLDivElement;
-        topRoot: HTMLDivElement;
-    }): boolean;
-    /**
-     * @param {object} cfg
-     * @param {string} cfg.type
-     * @param {RootElement} cfg.root
-     * @param {StructuredCloneValue} cfg.value
-     * @returns {void}
-     */
-    function setValue({ type, root, value }: {
-        type: string;
-        root: HTMLDivElement;
-        value: StructuredCloneValue;
-    }): void;
-    /**
-     * @public
-     * @param {string} s
-     * @param {object} cfg
-     * @param {string} cfg.format
-     * @param {string} cfg.state
-     * @param {TypeObject[]} [cfg.endMatchTypeObjs=[]]
-     * @param {boolean} [cfg.firstRun=true]
-     * @param {
-     *   [
-     *     type: string,
-     *     parent: array|object,
-     *     parentPath: string,
-     *     path: string
-     *   ]
-     * } [cfg.rootHolder=[]]
-     * @param {ArbitraryArray|ArbitraryObject} cfg.parent
-     * @param {string} cfg.parentPath
-     * @returns {{
-     *   value: ArbitraryValue,
-     *   remnant: string,
-     *   beginOnly: boolean,
-     *   assign: boolean
-     * }}
-     */
-    function getValueForString(s: string, { format, state, endMatchTypeObjs, firstRun, rootHolder, parent, parentPath }: {
-        format: string;
-        state: string;
-        endMatchTypeObjs?: TypeObject[] | undefined;
-        firstRun?: boolean | undefined;
-    }): {
-        value: ArbitraryValue;
-        remnant: string;
-        beginOnly: boolean;
-        assign: boolean;
-    };
-}
-//# sourceMappingURL=types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.js"],"names":[],"mappings":"AAoCO,mDAHI,iBAAiB,GACf,MAAM,CAOlB;;;;;;;YAMa,OAAO,SAAS,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAWV,OAAO;;;;;;;;;;iBAIvB,MAAM;;;;qBAEH;QAAC,IAAI,CAAC,EAAE,cAAc,CAAA;KAAC;;;;;uBAGvB;QAAC,IAAI,CAAC,EAAE,cAAc,CAAA;KAAC,KAAK,IAAI;mBAEhC;QACpB,KAAS,CAAC,iBAAiB;QAC3B,aAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,IAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,OAAW,CAAC,EAAE,cAAc,CAAC;QAC7B,UAAc,CAAC,EAAE,MAAM,GAAC,QAAQ,GAAC,MAAM,CAAC;QACxC,MAAU,CAAC,EAAE,MAAM,CAAA;KAChB;mBACiB;QACpB,KAAS,CAAC,iBAAiB;QAC3B,aAAiB,CAAC,EAAE,MAAM,CAAC;KACxB;;;;;qBACiB;QAAC,IAAI,EAAE,cAAc,CAAA;KAAC,KAC1C,gBAAoB,yBAAqB,iBAAiB;;;;;+BAEtC,MAAM;;;;uBAGN;QAAC,IAAI,EAAE,cAAc,CAAC;QAAC,OAAO,CAAC,EAAE,cAAc,CAAA;KAAC,KAAK;QACzE,OAAW,EAAE,MAAM,CAAC;QACpB,KAAS,EAAE,OAAO,CAAA;KACf;;;;;0BACiB;QAAC,OAAO,EAAE,cAAc,CAAA;KAAC,KAAK,IAAI;;;;;;2BAG/B;YACvB,KAAW,EAAE,MAAM,CAAC;YACpB,QAAc,EAAE,MAAM,EAAE,CAAA;SACnB;;;yDAsJU,MAAM,cACJ,MAAM,6BACS,MAAM,aACtB,MAAM,KACd,WAAW;0BAIP;IACZ,aAAiB,EAAE,MAAM,CAAC;IAC1B,UAAc,EAAE,OAAO,CAAC;IACxB,MAAU,EAAE,MAAM,CAAC;IACnB,KAAS,EAAE,KAAK,CAAC;IACjB,MAAU,EAAE,OAAO,CAAC;IACpB,aAAiB,EAAE,MAAM,CAAC;IAC1B,gCAAoC,EAAE,gCAAgC,CAAA;CACnE;;;;0BAwMS,cAAc;;;;;;;;;;IApO3B;;;;;OAKG;IACH,yEAEC;IAED;;;;;;;OAOG;IAEH;;;;;;;;;;OAUG;IAEH;;;;;;;;OAQG;IACH,8HAOC;IAED;;;;;OAKG;IACH,8EAOC;IAED;;;;;;OAMG;IACH,0GAEC;IAED;;;;OAIG;IACH,4FAMC;IAED;;;;OAIG;IACH,4EAE6D;IAE7D;;;;OAIG;IACH,sDAIC;IAED;;;;;OAKG;IACH,8FAOC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH;;;;;;;;;;;;;gBA2BC;;IAoBD;;;;;;;OAOG;IACH;;;;gBA4BC;IAED;;;OAGG;IAEH;;;;;OAKG;IACH;;aAkBC;IAED;;;;;;;OAOG;IACH;;;;gBAgBC;IAED;;;;;;OAMG;IACH;;;;aAKC;IAqBD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;;;;;;;;;;MA6GC"}

package/dist/src/utils/dialogs.d.ts

@@ -1,29 +0,0 @@
-export default dialogs;
-declare namespace dialogs {
-    function setLocale(locale?: {}): void;
-    function makeDialog({ atts, children, close, remove }?: {
-        atts?: {} | undefined;
-        children?: any[] | undefined;
-        close: any;
-        remove?: boolean | undefined;
-    }): import("../../vendor/jamilih/dist/jml-es.js").JamilihReturn;
-    function makeSubmitDialog({ submit, submitClass, ...args }: {
-        [x: string]: any;
-        submit: any;
-        submitClass?: string | undefined;
-    }): import("../../vendor/jamilih/dist/jml-es.js").JamilihReturn;
-    function makeCancelDialog({ submit, cancel, cancelClass, submitClass, ...args }: {
-        [x: string]: any;
-        submit: any;
-        cancel: any;
-        cancelClass?: string | undefined;
-        submitClass?: string | undefined;
-    }): import("../../vendor/jamilih/dist/jml-es.js").JamilihReturn;
-    function alert(message: any): Promise<any>;
-    function confirm({ atts, message, submitClass }: {
-        atts?: {} | undefined;
-        message: any;
-        submitClass?: string | undefined;
-    }): Promise<any>;
-}
-//# sourceMappingURL=dialogs.d.ts.map

package/dist/src/utils/dialogs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dialogs.d.ts","sourceRoot":"","sources":["../../../src/utils/dialogs.js"],"names":[],"mappings":";;IAYE,sCAEC;IACD;;;;;oEAiBC;IACD;;;;oEAcC;IACD;;;;;;oEAsBC;IACD,2CAiBC;IACD;;;;qBAoBC"}

package/dist/src/utils/jsonPointer.d.ts

@@ -1,42 +0,0 @@
-/**
- * @param {...string} args
- * @returns {string}
- */
-export function makeJSONPointer(...args: string[]): string;
-/**
- * @param {string} path
- * @returns {string}
- */
-export function escapeJSONPointer(path: string): string;
-/**
- * @param {string} pathPart
- * @returns {string}
- */
-export function unescapeJSONPointerPart(pathPart: string): string;
-/**
- * @param {string} path
- * @returns {string[]}
- */
-export function getJSONPointerParts(path: string): string[];
-/**
- * @param {ArbitraryObject} obj
- * @param {string} pathPart
- * @returns {ArbitraryObject|string}
- */
-export function reduceJSONPointerParts(obj: ArbitraryObject, pathPart: string): ArbitraryObject | string;
-/**
- * @param {object} cfg
- * @param {string} cfg.path
- * @param {ArbitraryObject} cfg.obj
- * @returns {string|ArbitraryObject}
- */
-export function resolveJSONPointer({ path, obj }: {
-    path: string;
-    obj: ArbitraryObject;
-}): string | ArbitraryObject;
-/**
- * @param {string} path
- * @returns {string}
- */
-export function typesonPathToJSONPointer(path: string): string;
-//# sourceMappingURL=jsonPointer.d.ts.map

package/dist/src/utils/jsonPointer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonPointer.d.ts","sourceRoot":"","sources":["../../../src/utils/jsonPointer.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,yCAHc,MAAM,KACP,MAAM,CAMlB;AAED;;;GAGG;AACH,wCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;GAGG;AACH,kDAHW,MAAM,GACJ,MAAM,CASlB;AAED;;;GAGG;AACH,0CAHW,MAAM,GACJ,MAAM,EAAE,CAMpB;AAED;;;;GAIG;AACH,uEAHW,MAAM,GACJ,kBAAgB,MAAM,CAQlC;AAED;;;;;GAKG;AACH;IAJuB,IAAI,EAAhB,MAAM;IACe,GAAG;IACtB,MAAM,kBAAgB,CAOlC;AAED;;;GAGG;AACH,+CAHW,MAAM,GACJ,MAAM,CAYlB"}

package/dist/src/utils/templateUtils.d.ts

@@ -1,59 +0,0 @@
-export namespace U {
-    export { nbsp };
-    export { upArrow };
-    export { downArrow };
-}
-/**
- * @param {string} sel
- * @returns {Element|null}
- */
-export function $(sel: string): Element | null;
-/**
- * @param {string} sel
- * @returns {Element[]}
- */
-export function $$(sel: string): Element[];
-/**
- * @param {Element|string} el
- * @param {string} descendentsSel
- * @returns {Element|null}
- */
-export function $e(el: Element | string, descendentsSel: string): Element | null;
-/**
- * @param {Element|string} el
- * @param {string} descendentsSel
- * @returns {Element[]}
- */
-export function $$e(el: Element | string, descendentsSel: string): Element[];
-export namespace DOM {
-    export { removeChildren };
-    export { removeIfExists };
-    export { filterChildElements };
-    export { initialCaps };
-}
-declare const nbsp: " ";
-declare const upArrow: "↑";
-declare const downArrow: "↓";
-/**
- * @param {Node} node
- * @returns {void}
- */
-declare function removeChildren(node: Node): void;
-/**
- * @param {Element|string} sel
- * @returns {void}
- */
-declare function removeIfExists(sel: Element | string): void;
-/**
- * @param {Element} el
- * @param {string|string[]} selectors
- * @returns {Element[]}
- */
-declare function filterChildElements(el: Element, selectors: string | string[]): Element[];
-/**
- * @param {string} s
- * @returns {string}
- */
-declare function initialCaps(s: string): string;
-export {};
-//# sourceMappingURL=templateUtils.d.ts.map

package/dist/src/utils/templateUtils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"templateUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/templateUtils.js"],"names":[],"mappings":";;;;;AAMA;;;GAGG;AACH,uBAHW,MAAM,GACJ,OAAO,GAAC,IAAI,CAEqB;AAE9C;;;GAGG;AACH,wBAHW,MAAM,GACJ,OAAO,EAAE,CAEiC;AAEvD;;;;GAIG;AACH,uBAJW,OAAO,GAAC,MAAM,kBACd,MAAM,GACJ,OAAO,GAAC,IAAI,CAQxB;AAED;;;;GAIG;AACH,wBAJW,OAAO,GAAC,MAAM,kBACd,MAAM,GACJ,OAAO,EAAE,CAQrB;;;;;;;AAzCD,wBAAsB;AACtB,2BAAyB;AACzB,6BAA2B;AAyC3B;;;GAGG;AACH,sCAHW,IAAI,GACF,IAAI,CAUhB;AAED;;;GAGG;AACH,qCAHW,OAAO,GAAC,MAAM,GACZ,IAAI,CAOhB;AAED;;;;GAIG;AACH,yCAJW,OAAO,aACP,MAAM,GAAC,MAAM,EAAE,GACb,OAAO,EAAE,CA+BrB;AAED;;;GAGG;AACH,gCAHW,MAAM,GACJ,MAAM,CAIlB"}

package/dist/src/utils/types.d.ts

@@ -1,2 +0,0 @@
-export function isNullish(obj: unknown): boolean;
-//# sourceMappingURL=types.d.ts.map

package/dist/src/utils/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/utils/types.js"],"names":[],"mappings":"AAGO,+BAFI,OAAO,WAIjB"}

package/dist/superTypes/SpecialNumberSuperType.d.ts

@@ -1,14 +0,0 @@
-export default SpecialNumberSuperType;
-export type SuperTypeObject = import('../types.js').TypeObject & {
-    childTypes: string[];
-};
-/**
- * @typedef {import('../types.js').TypeObject & {
- *   childTypes: string[]
- * }} SuperTypeObject
- */
-/**
- * @type {SuperTypeObject}
- */
-declare const SpecialNumberSuperType: SuperTypeObject;
-//# sourceMappingURL=SpecialNumberSuperType.d.ts.map

package/dist/superTypes/SpecialNumberSuperType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SpecialNumberSuperType.d.ts","sourceRoot":"","sources":["../../src/superTypes/SpecialNumberSuperType.js"],"names":[],"mappings":";8BAGa,OAAO,aAAa,EAAE,UAAU,GAAG;IAC/C,UAAc,EAAE,MAAM,EAAE,CAAA;CACrB;AAHJ;;;;GAIG;AAEH;;GAEG;AACH,sCAFU,eAAe,CAgEvB"}

package/dist/superTypes/SpecialRealNumberSuperType.d.ts

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

package/dist/superTypes/SpecialRealNumberSuperType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SpecialRealNumberSuperType.d.ts","sourceRoot":"","sources":["../../src/superTypes/SpecialRealNumberSuperType.js"],"names":[],"mappings":";AAEA;;GAEG;AACH,0CAFU,OAAO,6BAA6B,EAAE,eAAe,CAwD7D"}