@shortfuse/materialdesignweb 0.8.0 → 0.9.1

package/types/mixins/StateMixin.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Manages interactive state flags (disabled, focused, hovered, pressed, touch)
+ * and derived state expressions used by components.
+ * @param {typeof import('../core/CustomElement.js').default} Base
+ */
+export default function StateMixin(Base: typeof import("../core/CustomElement.js").default): typeof import("../core/CustomElement.js").default & import("../core/CustomElement.js").Class<{
+    disabled: boolean;
+    focused: boolean;
+    hovered: boolean;
+    pressed: boolean;
+    _lastInteraction: "key" | "mouse" | "touch" | "pen";
+    _hovered: boolean;
+    _focused: boolean;
+    _focusedSynthetic: boolean;
+    _keyPressed: boolean;
+    _keyReleased: boolean;
+    _pointerPressed: boolean;
+    stateLayer: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    disabledState: boolean;
+    hoveredState: boolean;
+    focusedState: boolean;
+    pressedState: boolean;
+    touchedState: boolean;
+    pointedState: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    stateTargetElement: HTMLElement;
+}, any[]>;
+//# sourceMappingURL=StateMixin.d.ts.map

package/types/mixins/StateMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateMixin.d.ts","sourceRoot":"","sources":["../../mixins/StateMixin.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,yCAFW,cAAc,0BAA0B,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;UAyO3D"}

package/types/mixins/TextFieldMixin.d.ts

@@ -0,0 +1,153 @@
+/** @typedef {import('../core/CustomElement.js').default} CustomElement */
+/**
+ * Composes a text field with label, supporting text, icons and control wiring.
+ * @param {ReturnType<import('./ControlMixin.js').default>} Base
+ */
+export default function TextFieldMixin(Base: ReturnType<typeof import("./ControlMixin.js").default>): typeof import("../core/CustomElement.js").default & import("../core/CustomElement.js").Class<{
+    disabled: boolean;
+    focused: boolean;
+    hovered: boolean;
+    pressed: boolean;
+    _lastInteraction: "key" | "mouse" | "touch" | "pen";
+    _hovered: boolean;
+    _focused: boolean;
+    _focusedSynthetic: boolean;
+    _keyPressed: boolean;
+    _keyReleased: boolean;
+    _pointerPressed: boolean;
+    stateLayer: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    disabledState: boolean;
+    hoveredState: boolean;
+    focusedState: boolean;
+    pressedState: boolean;
+    touchedState: boolean;
+    pointedState: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    stateTargetElement: HTMLElement;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    color: string;
+    ink: string;
+    typeStyle: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    shapeTop: boolean;
+    shapeBottom: boolean;
+    shapeStart: boolean;
+    shapeEnd: boolean;
+    shapeStyle: string;
+    outlined: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    density: number;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    delegatesFocus: boolean;
+}, any[]> & {
+    formAssociated: true;
+} & import("../core/CustomElement.js").Class<{
+    _ipcListener: EventListener;
+    _ipcTarget: EventTarget;
+    _files: FileList;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    ariaControls: string;
+    autocomplete: string;
+    name: string;
+    readOnly: boolean;
+    formNoValidate: boolean;
+    defaultChecked: boolean;
+    _checkedDirty: boolean;
+    _checked: boolean;
+    required: boolean;
+    type: string;
+    _defaultValue: string;
+    _value: string;
+    _valueDirty: boolean;
+    _userInteracted: boolean;
+    _invalid: boolean;
+    _badInput: boolean;
+    _validationMessage: string;
+    _formDisabled: boolean;
+    _formReset: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    erroredState: boolean;
+    defaultValue: string;
+    _valueBehavior: "default" | "value" | "default/on" | "filename";
+}, any[]> & import("../core/CustomElement.js").Class<{
+    _onSetValue(value: string): void;
+    _onSetChecked(checked: boolean): void;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    value: string;
+    checked: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    form: HTMLFormElement;
+    validity: ValidityState;
+    validationMessage: string;
+    willValidate: boolean;
+    labels: NodeList;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    disabledState: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    checkValidity(): boolean;
+    reportValidity(): boolean;
+    setCustomValidity(error: string): void;
+    _notifyRadioChange(key: string, value: string): void;
+    refreshFormAssociation(): void;
+    formAssociatedCallback(form: HTMLFormElement | null): void;
+    formIPCEvent(event: CustomEvent<[string, string]>): void;
+    formDisabledCallback(disabled: boolean): void;
+    formResetCallback(): void;
+    formStateRestoreCallback(state: string | FormData, mode: "autocomplete" | "restore"): void;
+    _updateFormAssociatedValue(): void;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    ariaLabel: string;
+    _slotInnerText: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    focusableOnDisabled: boolean;
+    controlTagName: string;
+    controlVoidElement: boolean;
+    _slotMutationObserver: any;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    _onControlValue(value: string): void;
+    onValueChangingContentAttribute(): void;
+    focus(options?: FocusOptions): void;
+    click(): void;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    stateTargetElement: HTMLElement;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    checkValidity(): boolean;
+    reportValidity(): boolean;
+    setCustomValidity(error: string): void;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    _computedAriaLabel: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    _computedAriaLabelledby: never;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    /** Show an internal visual state layer element */
+    stateLayer: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    type: string;
+    icon: string;
+    iconVariation: string;
+    label: string;
+    filled: boolean;
+    outlined: boolean;
+    inputPrefix: string;
+    inputSuffix: string;
+    trailingIcon: string;
+    trailingIconInk: string;
+    trailingIconLabel: string;
+    supporting: string;
+    error: string;
+    placeholder: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    erroredState: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    computePlaceholder: () => string;
+    shouldShowSupporting: () => boolean;
+    computeSupportingText: () => string;
+    populatedState: () => boolean;
+    _showLabelText: never;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    _shapeShapeTop: never;
+    computedIconVariation: () => string;
+}, any[]>;
+export type CustomElement = import("../core/CustomElement.js").default;
+//# sourceMappingURL=TextFieldMixin.d.ts.map

package/types/mixins/TextFieldMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextFieldMixin.d.ts","sourceRoot":"","sources":["../../mixins/TextFieldMixin.js"],"names":[],"mappings":"AAIA,0EAA0E;AAE1E;;;GAGG;AACH,6CAFW,UAAU,CAAC,0CAAmC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAOpD,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAkvBvD;4BA7vBa,OAAO,0BAA0B,EAAE,OAAO"}

package/types/mixins/ThemableMixin.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Adds theming attributes (`color`, `ink`, `typeStyle`) that map to CSS tokens.
+ * @param {typeof import('../core/CustomElement.js').default} Base
+ */
+export default function ThemableMixin(Base: typeof import("../core/CustomElement.js").default): typeof import("../core/CustomElement.js").default & import("../core/CustomElement.js").Class<{
+    color: string;
+    ink: string;
+    typeStyle: string;
+}, any[]>;
+//# sourceMappingURL=ThemableMixin.d.ts.map

package/types/mixins/ThemableMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThemableMixin.d.ts","sourceRoot":"","sources":["../../mixins/ThemableMixin.js"],"names":[],"mappings":"AAwCA;;;GAGG;AACH,4CAFW,cAAc,0BAA0B,EAAE,OAAO;;;;UAmG3D"}

package/types/mixins/TooltipTriggerMixin.d.ts

@@ -0,0 +1,114 @@
+/** @typedef {import('../components/Tooltip.js').default} Tooltip */
+/**
+ * Adds tooltip scheduling, positioning, and show/hide behavior for host elements.
+ * @param {ReturnType<import('./StateMixin.js').default>} Base
+ */
+export default function TooltipTriggerMixin(Base: ReturnType<typeof import("./StateMixin.js").default>): typeof import("../index.js").CustomElement & import("../core/CustomElement.js").Class<{
+    disabled: boolean;
+    focused: boolean;
+    hovered: boolean;
+    pressed: boolean;
+    _lastInteraction: "key" | "mouse" | "touch" | "pen";
+    _hovered: boolean;
+    _focused: boolean;
+    _focusedSynthetic: boolean;
+    _keyPressed: boolean;
+    _keyReleased: boolean;
+    _pointerPressed: boolean;
+    stateLayer: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    disabledState: boolean;
+    hoveredState: boolean;
+    focusedState: boolean;
+    pressedState: boolean;
+    touchedState: boolean;
+    pointedState: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    stateTargetElement: HTMLElement;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    /** Idle delay before showing tooltip for mouse (ms) */
+    TOOLTIP_MOUSE_IDLE_MS: number;
+    /** Idle delay before showing tooltip for touch (ms) */
+    TOOLTIP_TOUCH_IDLE_MS: number;
+    /** Timer id used for tooltip show/hide debouncing */
+    /** @type {any} */
+    _idleDebounce: any;
+    /** Parents being observed for layout changes */
+    /** @type {HTMLElement[]} */
+    _watchedParents: HTMLElement[];
+    /** ResizeObserver used to track tooltip/anchor size changes */
+    /** @type {ResizeObserver} */
+    _resizeObserver: ResizeObserver;
+    /** IntersectionObserver used to detect occlusion */
+    /** @type {IntersectionObserver} */
+    _intersectObserver: IntersectionObserver;
+    /** Bound scroll listener attached to parent elements */
+    _parentScrollListener: any;
+    /** Slot id to use when cloning tooltip content */
+    tooltipSlotId: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    tooltip: string;
+    autoTooltip: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    cancelShowTooltip(): void;
+    /** @param {'mouse'|'touch'|'keyboard'} type */
+    scheduleHideTooltip(type: "mouse" | "touch" | "keyboard"): void;
+    /** @param {'mouse'|'touch'|'keyboard'} type */
+    scheduleShowTooltip(type: "mouse" | "touch" | "keyboard"): void;
+    showTooltip(): void;
+    hideTooltip(cancelSchedule?: boolean): void;
+    /**
+     * TODO: Throttle multiple calls
+     * @param {DOMRect} [domRect]
+     * @return {void}
+     */
+    updateTooltipPosition(domRect?: DOMRect): void;
+    recloneTooltip(): void;
+    closeIfNotHovered(): void;
+}, any[]>;
+export type Tooltip = typeof import("../index.js").CustomElement & import("../core/CustomElement.js").Class<{
+    _ariaRole: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    _onConnectAriaValues: Map<import("./AriaReflectorMixin.js").StringKeyOfARIAMixin<keyof ARIAMixin>, ARIAMixin[import("./AriaReflectorMixin.js").StringKeyOfARIAMixin<keyof ARIAMixin>]>;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    readAriaProperty(name: keyof HTMLElement & keyof ElementInternals): string | ShadowRoot | Element | readonly Element[];
+    updateAriaProperty<K extends StringKeyOfARIAMixin<keyof ARIAMixin>>(name: K, value: ARIAMixin[K]): void;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    disabled: boolean;
+    focused: boolean;
+    hovered: boolean;
+    pressed: boolean;
+    _lastInteraction: "key" | "mouse" | "touch" | "pen";
+    _hovered: boolean;
+    _focused: boolean;
+    _focusedSynthetic: boolean;
+    _keyPressed: boolean;
+    _keyReleased: boolean;
+    _pointerPressed: boolean;
+    stateLayer: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    disabledState: boolean;
+    hoveredState: boolean;
+    focusedState: boolean;
+    pressedState: boolean;
+    touchedState: boolean;
+    pointedState: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    stateTargetElement: HTMLElement;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    color: string;
+    ink: string;
+    typeStyle: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    shapeTop: boolean;
+    shapeBottom: boolean;
+    shapeStart: boolean;
+    shapeEnd: boolean;
+    shapeStyle: string;
+    outlined: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    _ariaRole: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    open: boolean;
+}, any[]>;
+//# sourceMappingURL=TooltipTriggerMixin.d.ts.map

package/types/mixins/TooltipTriggerMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TooltipTriggerMixin.d.ts","sourceRoot":"","sources":["../../mixins/TooltipTriggerMixin.js"],"names":[],"mappings":"AAIA,oEAAoE;AAEpE;;;GAGG;AACH,kDAFW,UAAU,CAAC,wCAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;IAKlD,uDAAuD;;IAEvD,uDAAuD;;IAEvD,qDAAqD;IACrD,kBAAkB;mBAAP,GAAG;IAEd,gDAAgD;IAChD,4BAA4B;qBAAjB,WAAW,EAAE;IAExB,+DAA+D;IAC/D,6BAA6B;qBAAlB,cAAc;IAEzB,oDAAoD;IACpD,mCAAmC;wBAAxB,oBAAoB;IAE/B,wDAAwD;;IAExD,kDAAkD;;;;;;;IAoBlD,+CAA+C;8BAAnC,OAAO,GAAC,OAAO,GAAC,UAAU;IAyBtC,+CAA+C;8BAAnC,OAAO,GAAC,OAAO,GAAC,UAAU;;;IAkEtC;;;;OAIG;oCAFQ,OAAO,GACN,IAAI;;;UAyLrB"}

package/types/mixins/TouchTargetMixin.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Provides a visually hidden touch target area to meet touch size recommendations.
+ * @param {typeof import('../core/CustomElement.js').default} Base
+ */
+export default function TouchTargetMixin(Base: typeof import("../core/CustomElement.js").default): typeof import("../core/CustomElement.js").default;
+//# sourceMappingURL=TouchTargetMixin.d.ts.map

package/types/mixins/TouchTargetMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TouchTargetMixin.d.ts","sourceRoot":"","sources":["../../mixins/TouchTargetMixin.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,+CAFW,cAAc,0BAA0B,EAAE,OAAO,qDAmC3D"}

package/types/mixins/TypographyMixin.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Provides typographic padding and leading helpers for text content.
+ * @param {typeof import('../core/CustomElement.js').default} Base
+ */
+export default function TypographyMixin(Base: typeof import("../core/CustomElement.js").default): typeof import("../core/CustomElement.js").default & import("../core/CustomElement.js").Class<{
+    delegatesFocus: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    textPadding: string;
+    textPaddingTop: string;
+    textLeading: string;
+    textPaddingBottom: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    _computedTextPaddingTop: string;
+    _computedTextPaddingBottom: string;
+    _computedTextLeading: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    _beforeStyle: string;
+    _afterStyle: string;
+}, any[]>;
+//# sourceMappingURL=TypographyMixin.d.ts.map

package/types/mixins/TypographyMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypographyMixin.d.ts","sourceRoot":"","sources":["../../mixins/TypographyMixin.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH,8CAFW,cAAc,0BAA0B,EAAE,OAAO;;;;;;;;;;;;;;UA+G3D"}

package/types/services/rtl.d.ts

@@ -0,0 +1,3 @@
+/** @return {void} */
+export function loadGlobalStyles(): void;
+//# sourceMappingURL=rtl.d.ts.map

package/types/services/rtl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rtl.d.ts","sourceRoot":"","sources":["../../services/rtl.js"],"names":[],"mappings":"AAIA,qBAAqB;AACrB,oCADa,IAAI,CAKhB"}

package/types/services/svgAlias.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @param {string} name
+ * @param {string} path
+ * @param {string} [viewBox]
+ */
+export function addSVGAlias(name: string, path: string, viewBox?: string): void;
+/** @type {Map<string, {path:string, viewBox:string}>} */
+export const svgAliasMap: Map<string, {
+    path: string;
+    viewBox: string;
+}>;
+export const unaliased: Set<any>;
+//# sourceMappingURL=svgAlias.d.ts.map

package/types/services/svgAlias.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svgAlias.d.ts","sourceRoot":"","sources":["../../services/svgAlias.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,kCAJW,MAAM,QACN,MAAM,YACN,MAAM,QAShB;AAhBD,yDAAyD;AACzD,0BADW,GAAG,CAAC,MAAM,EAAE;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,OAAO,EAAC,MAAM,CAAA;CAAC,CAAC,CAChB;AACrC,iCAAmC"}

package/types/services/theme.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @param {typeof TYPOGRAPHY_DEFAULT} config
+ * @return {string}
+ */
+export function generateTypographyCSS(config?: typeof TYPOGRAPHY_DEFAULT): string;
+/** @return {string} */
+export function generateTypographyGlobalCSS(): string;
+/**
+ * @param {typeof SHAPE_ROUNDED_DEFAULT} [config]
+ * @return {string}
+ */
+export function generateShapeCSS(config?: typeof SHAPE_ROUNDED_DEFAULT): string;
+/**
+ * @param {ThemeOptions} options
+ * @return {string}
+ */
+export function generateColorCSS({ color, custom, lightness }: ThemeOptions): string;
+/**
+ * @param {ThemeOptions} options
+ * @return {void}
+ */
+export function setupTheme({ color, custom, lightness }: ThemeOptions): void;
+/**
+ * @param {URLSearchParams} searchParams
+ * @return {ThemeOptions}
+ */
+export function themeOptionsFromSearchParams(searchParams: URLSearchParams): ThemeOptions;
+/**
+ * @param {ThemeOptions} options
+ * @return {string}
+ */
+export function generateThemeCSS({ color, custom, lightness }: ThemeOptions): string;
+export const PALETTES: string[];
+export const TYPE_STYLES: string[];
+export type ThemeOptions = {
+    color?: string;
+    /**
+     * Map()
+     */
+    custom?: Iterable<[string, string?]>;
+    lightness?: "auto" | "light" | "dark";
+};
+import { TYPOGRAPHY_DEFAULT } from '../constants/typography.js';
+import { SHAPE_ROUNDED_DEFAULT } from '../constants/shapes.js';
+//# sourceMappingURL=theme.d.ts.map

package/types/services/theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../services/theme.js"],"names":[],"mappings":"AA2FA;;;GAGG;AACH,+CAHW,OAAO,kBAAkB,GACxB,MAAM,CAoGjB;AAED,uBAAuB;AACvB,+CADa,MAAM,CAalB;AAED;;;GAGG;AACH,0CAHW,OAAO,qBAAqB,GAC3B,MAAM,CAsBjB;AAaD;;;GAGG;AACH,+DAHW,YAAY,GACX,MAAM,CAWjB;AAED;;;GAGG;AACH,yDAHW,YAAY,GACX,IAAI,CAiBf;AAED;;;GAGG;AACH,2DAHW,eAAe,GACd,YAAY,CAWvB;AAED;;;GAGG;AACH,+DAHW,YAAY,GACX,MAAM,CAqBjB;AA3TD,gCAME;AAEF,mCAME;;YAIQ,MAAM;;;;aACN,QAAQ,CAAC,CAAC,MAAM,EAAC,MAAM,CAAC,CAAC,CAAC;gBAC1B,MAAM,GAAC,OAAO,GAAC,MAAM;;mCAxBI,4BAA4B;sCADzB,wBAAwB"}

package/types/utils/cli.d.ts

@@ -0,0 +1,3 @@
+/** @return {URLSearchParams} */
+export function getSearchParams(): URLSearchParams;
+//# sourceMappingURL=cli.d.ts.map

package/types/utils/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../utils/cli.js"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,mCADa,eAAe,CAU3B"}

package/types/utils/function.d.ts

@@ -0,0 +1,3 @@
+/** @return {void} */
+export function noop(): void;
+//# sourceMappingURL=function.d.ts.map

package/types/utils/function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../utils/function.js"],"names":[],"mappings":"AAAA,qBAAqB;AAErB,wBAFa,IAAI,CAEQ"}

package/types/utils/jsx-runtime.d.ts

@@ -0,0 +1,20 @@
+/** eslint-env browser */
+export const FRAGMENT_TAG: "$FRAGMENT";
+/**
+ * @param {string} tagName
+ * @param {{ children?: DocumentFragment|string } & Record<string, any>} attrs
+ * @return {HTMLElement|DocumentFragment}
+ */
+export function jsx(tagName: string, attrs?: {
+    children?: DocumentFragment | string;
+} & Record<string, any>): HTMLElement | DocumentFragment;
+/**
+ * @param {string} tagName
+ * @param {Record<string, any> & { children: HTMLElement[], style:string|CSSStyleDeclaration }} attrs
+ * @return {HTMLElement|DocumentFragment}
+ */
+export function jsxs(tagName: string, attrs: Record<string, any> & {
+    children: HTMLElement[];
+    style: string | CSSStyleDeclaration;
+}): HTMLElement | DocumentFragment;
+//# sourceMappingURL=jsx-runtime.d.ts.map

package/types/utils/jsx-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-runtime.d.ts","sourceRoot":"","sources":["../../utils/jsx-runtime.js"],"names":[],"mappings":"AAAA,yBAAyB;AAEzB,2BAA4B,WAAW,CAAC;AAsDxC;;;;GAIG;AACH,6BAJW,MAAM,UACN;IAAE,QAAQ,CAAC,EAAE,gBAAgB,GAAC,MAAM,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC3D,WAAW,GAAC,gBAAgB,CA2CvC;AA/FD;;;;GAIG;AACH,8BAJW,MAAM,SACN,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG;IAAE,QAAQ,EAAE,WAAW,EAAE,CAAC;IAAC,KAAK,EAAC,MAAM,GAAC,mBAAmB,CAAA;CAAE,GAClF,WAAW,GAAC,gBAAgB,CA4CvC"}

package/types/utils/material-color/blend.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Functions for blending in HCT and CAM16.
+ */
+/**
+ * Blend the design color's HCT hue towards the key color's HCT
+ * hue, in a way that leaves the original color recognizable and
+ * recognizably shifted towards the key color.
+ * @param {number} designColor ARGB representation of an arbitrary color.
+ * @param {number} sourceColor ARGB representation of the main theme color.
+ * @return {number} The design color with a hue shifted towards the
+ * system's color, a slightly warmer/cooler variant of the design
+ * color's hue.
+ */
+export function harmonize(designColor: number, sourceColor: number): number;
+/**
+ * Blend in CAM16-UCS space.
+ * @param {number} from ARGB representation of color
+ * @param {number} to ARGB representation of color
+ * @param {number} amount how much blending to perform; 0.0 >= and <= 1.0
+ * @return {number} from, blended towards to. Hue, chroma, and tone will
+ * change.
+ */
+export function cam16Ucs(from: number, to: number, amount: number): number;
+/**
+ * Blends hue from one color into another. The chroma and tone of
+ * the original color are maintained.
+ * @param {number} from ARGB representation of color
+ * @param {number} to ARGB representation of color
+ * @param {number} amount how much blending to perform; 0.0 >= and <= 1.0
+ * @return {number} from, with a hue blended towards to. Chroma and tone
+ * are constant.
+ */
+export function hctHue(from: number, to: number, amount: number): number;
+//# sourceMappingURL=blend.d.ts.map

package/types/utils/material-color/blend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blend.d.ts","sourceRoot":"","sources":["../../../utils/material-color/blend.js"],"names":[],"mappings":"AAsBA;;GAEG;AAEH;;;;;;;;;GASG;AACH,uCANW,MAAM,eACN,MAAM,GACL,MAAM,CAcjB;AAED;;;;;;;GAOG;AACH,+BANW,MAAM,MACN,MAAM,UACN,MAAM,GACL,MAAM,CAgBjB;AAED;;;;;;;;GAQG;AACH,6BANW,MAAM,MACN,MAAM,UACN,MAAM,GACL,MAAM,CAajB"}

package/types/utils/material-color/hct/Cam16.d.ts

@@ -0,0 +1,142 @@
+/**
+ * CAM16, a color appearance model. Colors are not just defined by their hex
+ * code, but rather, a hex code and viewing conditions.
+ *
+ * CAM16 instances also have coordinates in the CAM16-UCS space, called J*, a*,
+ * b*, or jstar, astar, bstar in code. CAM16-UCS is included in the CAM16
+ * specification, and should be used when measuring distances between colors.
+ *
+ * In traditional color spaces, a color can be identified solely by the
+ * observer's measurement of the color. Color appearance models such as CAM16
+ * also use information about the environment where the color was
+ * observed, known as the viewing conditions.
+ *
+ * For example, white under the traditional assumption of a midday sun white
+ * point is accurately measured as a slightly chromatic blue by CAM16. (roughly,
+ * hue 203, chroma 3, lightness 100)
+ */
+export default class Cam16 {
+    /**
+     * @param {number} argb ARGB representation of a color.
+     * @return {Cam16} CAM16 color, assuming the color was viewed in default viewing
+     *     conditions.
+     */
+    static fromInt(argb: number): Cam16;
+    /**
+     * @param {number} argb ARGB representation of a color.
+     * @param {ViewingConditions} viewingConditions Information about the environment where the color
+     *     was observed.
+     * @return {Cam16} CAM16 color.
+     */
+    static fromIntInViewingConditions(argb: number, viewingConditions: ViewingConditions): Cam16;
+    /**
+     * @param {number} j CAM16 lightness
+     * @param {number} c CAM16 chroma
+     * @param {number} h CAM16 hue
+     * @return {Cam16}
+     */
+    static fromJch(j: number, c: number, h: number): Cam16;
+    /**
+     * @param {number} j CAM16 lightness
+     * @param {number} c CAM16 chroma
+     * @param {number} h CAM16 hue
+     * @param {ViewingConditions} viewingConditions Information about the environment where the color
+     *     was observed.
+     */
+    static fromJchInViewingConditions(j: number, c: number, h: number, viewingConditions: ViewingConditions): Cam16;
+    /**
+     * @param {number} jstar CAM16-UCS lightness.
+     * @param {number} astar CAM16-UCS a dimension. Like a* in L*a*b*, it is a Cartesian
+     *     coordinate on the Y axis.
+     * @param {number} bstar CAM16-UCS b dimension. Like a* in L*a*b*, it is a Cartesian
+     *     coordinate on the X axis.
+     * @return {Cam16}
+     */
+    static fromUcs(jstar: number, astar: number, bstar: number): Cam16;
+    /**
+     * @param {number} jstar CAM16-UCS lightness.
+     * @param {number} astar CAM16-UCS a dimension. Like a* in L*a*b*, it is a Cartesian
+     *     coordinate on the Y axis.
+     * @param {number} bstar CAM16-UCS b dimension. Like a* in L*a*b*, it is a Cartesian
+     *     coordinate on the X axis.
+     * @param {ViewingConditions} viewingConditions Information about the environment where the color
+     *     was observed.
+     */
+    static fromUcsInViewingConditions(jstar: number, astar: number, bstar: number, viewingConditions: ViewingConditions): Cam16;
+    /**
+     * Given color expressed in XYZ and viewed in [viewingConditions], convert to
+     * CAM16.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {ViewingConditions} viewingConditions
+     * @return {Cam16}
+     */
+    static fromXyzInViewingConditions(x: number, y: number, z: number, viewingConditions: ViewingConditions): Cam16;
+    /**
+     * All of the CAM16 dimensions can be calculated from 3 of the dimensions, in
+     * the following combinations:
+     *      -  {j or q} and {c, m, or s} and hue
+     *      - jstar, astar, bstar
+     * Prefer using a static method that constructs from 3 of those dimensions.
+     * This constructor is intended for those methods to use to return all
+     * possible dimensions.
+     * @param {number} hue
+     * @param {number} chroma informally, colorfulness / color intensity. like saturation
+     *     in HSL, except perceptually accurate.
+     * @param {number} j lightness
+     * @param {number} q brightness; ratio of lightness to white point's lightness
+     * @param {number} m colorfulness
+     * @param {number} s saturation; ratio of chroma to white point's chroma
+     * @param {number} jstar CAM16-UCS J coordinate
+     * @param {number} astar CAM16-UCS a coordinate
+     * @param {number} bstar CAM16-UCS b coordinate
+     */
+    constructor(hue: number, chroma: number, j: number, q: number, m: number, s: number, jstar: number, astar: number, bstar: number);
+    /** @readonly */
+    readonly hue: number;
+    /** @readonly */
+    readonly chroma: number;
+    /** @readonly */
+    readonly j: number;
+    /** @readonly */
+    readonly q: number;
+    /** @readonly */
+    readonly m: number;
+    /** @readonly */
+    readonly s: number;
+    /** @readonly */
+    readonly jstar: number;
+    /** @readonly */
+    readonly astar: number;
+    /** @readonly */
+    readonly bstar: number;
+    /**
+     * CAM16 instances also have coordinates in the CAM16-UCS space, called J*,
+     * a*, b*, or jstar, astar, bstar in code. CAM16-UCS is included in the CAM16
+     * specification, and is used to measure distances between colors.
+     * @param {Cam16} other
+     * @return {number}
+     */
+    distance(other: Cam16): number;
+    /**
+     *  @return {number} ARGB representation of color, assuming the color was viewed in
+     *     default viewing conditions, which are near-identical to the default
+     *     viewing conditions for sRGB.
+     */
+    toInt(): number;
+    /**
+     * @param {ViewingConditions} viewingConditions Information about the environment where the color
+     *     will be viewed.
+     * @return {number} ARGB representation of color
+     */
+    viewed(viewingConditions: ViewingConditions): number;
+    /**
+     * XYZ representation of CAM16 seen in [viewingConditions].
+     * @param {ViewingConditions} viewingConditions
+     * @return {number[]}
+     */
+    xyzInViewingConditions(viewingConditions: ViewingConditions): number[];
+}
+import ViewingConditions from './ViewingConditions.js';
+//# sourceMappingURL=Cam16.d.ts.map