@shortfuse/materialdesignweb 0.8.0 → 0.9.1

package/types/core/template.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @param {string} [fromString]
+ * @return {DocumentFragment}
+ */
+export function generateFragment(fromString?: string): DocumentFragment;
+/**
+ * @template T
+ * @typedef {Object} RenderOptions
+ * @prop {Object} context
+ * @prop {ParentNode} root
+ * @prop {Object<string, HTMLElement>} refs
+ */
+/**
+ * @param {(data: Partial<any>) => any} fn
+ * @return {string}
+ */
+export function addInlineFunction(fn: (data: Partial<any>) => any): string;
+/**
+ * @template T1
+ * @template T2
+ * @param {TemplateStringsArray} strings
+ * @param  {...(string|DocumentFragment|Element|((this:T1, data:T2) => any))} substitutions
+ * @return {DocumentFragment}
+ */
+export function html<T1, T2>(strings: TemplateStringsArray, ...substitutions: (string | DocumentFragment | Element | ((this: T1, data: T2) => any))[]): DocumentFragment;
+/** @type {Map<string, InlineFunctionEntry<?>>} */
+export const inlineFunctions: Map<string, InlineFunctionEntry<unknown>>;
+export type RenderOptions<T> = {
+    context: Object;
+    root: ParentNode;
+    refs: {
+        [x: string]: HTMLElement;
+    };
+};
+/**
+ * Property are bound to an ID+Node
+ * Values are either getter or via an function
+ */
+export type InlineFunctionEntry<T extends unknown> = {
+    fn: (data: T) => any;
+    props?: string[];
+    deepProps?: string[][];
+    injectionProps?: string[];
+    injectionDeepProps?: string[][];
+    defaultValue?: T;
+};
+//# sourceMappingURL=template.d.ts.map

package/types/core/template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../core/template.js"],"names":[],"mappings":"AAwBA;;;GAGG;AACH,8CAHW,MAAM,GACL,gBAAgB,CAU3B;AAKD;;;;;;GAMG;AAEH;;;GAGG;AACH,sCAHW,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,GAAG,GAC1B,MAAM,CAMjB;AAID;;;;;;GAMG;AACH,qBANa,EAAE,EACF,EAAE,WACJ,oBAAoB,oBAChB,CAAC,MAAM,GAAC,gBAAgB,GAAC,OAAO,GAAC,CAAC,CAAC,IAAI,EAAC,EAAE,EAAE,IAAI,EAAC,EAAE,KAAK,GAAG,CAAC,CAAC,EAAA,GAChE,gBAAgB,CA4C3B;AAxED,kDAAkD;AAClD,8BADW,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,OAAC,CAAC,CAAC,CACL;0BAG5B,CAAC;aAEJ,MAAM;UACN,UAAU;;;;;;;;;gCAxCD,CAAC;QAEV,CAAC,IAAI,EAAC,CAAC,KAAK,GAAG;YACf,MAAM,EAAE;gBACR,MAAM,EAAE,EAAE;qBACV,MAAM,EAAE;yBACR,MAAM,EAAE,EAAE;mBACV,CAAC"}

package/types/core/uid.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {string} [prefix='x'] Prefix all UIDs by string to apply a name or ensure starts with [A-Z] character
+ * @param {number} [n] Maximum number of variations needed. Calculated as 32^n.
+  @return {string} */
+export function generateUID(prefix?: string, n?: number): string;
+//# sourceMappingURL=uid.d.ts.map

package/types/core/uid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uid.d.ts","sourceRoot":"","sources":["../../core/uid.js"],"names":[],"mappings":"AAGA;;;qBAGqB;AACrB,qCAHW,MAAM,MACN,MAAM,GACN,MAAM,CAMhB"}

package/types/dom/HTMLOptionsCollectionProxy.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @see https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#htmloptionscollection
+ * @template {HTMLOptionElement} T1
+ * @template {HTMLOptGroupElement} T2
+ * @param {Object} options
+ * @param {HTMLElement} options.host
+ * @param {HTMLCollectionOf<T1>} options.collection
+ * @param {new (...args: any[]) => T1} options.OptionConstructor
+ * @param {new (...args: any[]) => T2} options.GroupConstructor
+ * @return {HTMLCollectionOf<T1> & HTMLOptionsCollection}
+ */
+export function constructHTMLOptionsCollectionProxy<T1 extends HTMLOptionElement, T2 extends HTMLOptGroupElement>({ host, collection, OptionConstructor, GroupConstructor }: {
+    host: HTMLElement;
+    collection: HTMLCollectionOf<T1>;
+    OptionConstructor: new (...args: any[]) => T1;
+    GroupConstructor: new (...args: any[]) => T2;
+}): HTMLCollectionOf<T1> & HTMLOptionsCollection;
+//# sourceMappingURL=HTMLOptionsCollectionProxy.d.ts.map

package/types/dom/HTMLOptionsCollectionProxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HTMLOptionsCollectionProxy.d.ts","sourceRoot":"","sources":["../../dom/HTMLOptionsCollectionProxy.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,oDATiC,EAAE,SAArB,iBAAkB,EACG,EAAE,SAAvB,mBAAoB,6DAE/B;IAA6B,IAAI,EAAzB,WAAW;IACmB,UAAU,EAAxC,gBAAgB,CAAC,EAAE,CAAC;IACgB,iBAAiB,EAArD,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE;IACU,gBAAgB,EAApD,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE;CAClC,GAAS,gBAAgB,CAAC,EAAE,CAAC,GAAG,qBAAqB,CAkGvD"}

package/types/index.d.ts

@@ -0,0 +1,88 @@
+export { default as Badge } from "./components/Badge.js";
+export { default as Body } from "./components/Body.js";
+export { default as BottomAppBar } from "./components/BottomAppBar.js";
+export { default as BottomSheet } from "./components/BottomSheet.js";
+export { default as Box } from "./components/Box.js";
+export { default as Button } from "./components/Button.js";
+export { default as Card } from "./components/Card.js";
+export { default as Checkbox } from "./components/Checkbox.js";
+export { default as CheckboxIcon } from "./components/CheckboxIcon.js";
+export { default as Chip } from "./components/Chip.js";
+export { default as Dialog } from "./components/Dialog.js";
+export { default as Divider } from "./components/Divider.js";
+export { default as Display } from "./components/Display.js";
+export { default as Fab } from "./components/Fab.js";
+export { default as FabContainer } from "./components/FabContainer.js";
+export { default as FilterChip } from "./components/FilterChip.js";
+export { default as Grid } from "./components/Grid.js";
+export { default as Headline } from "./components/Headline.js";
+export { default as Icon } from "./components/Icon.js";
+export { default as IconButton } from "./components/IconButton.js";
+export { default as Input } from "./components/Input.js";
+export { default as InputChip } from "./components/InputChip.js";
+export { default as Label } from "./components/Label.js";
+export { default as List } from "./components/List.js";
+export { default as ListItem } from "./components/ListItem.js";
+export { default as ListOption } from "./components/ListOption.js";
+export { default as Listbox } from "./components/Listbox.js";
+export { default as Menu } from "./components/Menu.js";
+export { default as MenuItem } from "./components/MenuItem.js";
+export { default as NavBar } from "./components/NavBar.js";
+export { default as NavBarItem } from "./components/NavBarItem.js";
+export { default as NavDrawer } from "./components/NavDrawer.js";
+export { default as NavDrawerItem } from "./components/NavDrawerItem.js";
+export { default as NavItem } from "./components/NavItem.js";
+export { default as NavRail } from "./components/NavRail.js";
+export { default as NavRailItem } from "./components/NavRailItem.js";
+export { default as Page } from "./components/Page.js";
+export { default as Pane } from "./components/Pane.js";
+export { default as Popup } from "./components/Popup.js";
+export { default as Progress } from "./components/Progress.js";
+export { default as Radio } from "./components/Radio.js";
+export { default as RadioIcon } from "./components/RadioIcon.js";
+export { default as Root } from "./components/Root.js";
+export { default as Search } from "./components/Search.js";
+export { default as SegmentedButton } from "./components/SegmentedButton.js";
+export { default as SegmentedButtonGroup } from "./components/SegmentedButtonGroup.js";
+export { default as Select } from "./components/Select.js";
+export { default as Shape } from "./components/Shape.js";
+export { default as SideSheet } from "./components/SideSheet.js";
+export { default as Slider } from "./components/Slider.js";
+export { default as Snackbar } from "./components/Snackbar.js";
+export { default as SnackbarContainer } from "./components/SnackbarContainer.js";
+export { default as Surface } from "./components/Surface.js";
+export { default as Switch } from "./components/Switch.js";
+export { default as SwitchIcon } from "./components/SwitchIcon.js";
+export { default as Tab } from "./components/Tab.js";
+export { default as TabContent } from "./components/TabContent.js";
+export { default as TabList } from "./components/TabList.js";
+export { default as TabPanel } from "./components/TabPanel.js";
+export { default as TextArea } from "./components/TextArea.js";
+export { default as Title } from "./components/Title.js";
+export { default as Tooltip } from "./components/Tooltip.js";
+export { default as TopAppBar } from "./components/TopAppBar.js";
+export { default as CustomElement } from "./core/CustomElement.js";
+export { default as Composition } from "./core/Composition.js";
+export { default as InputMixin } from "./mixins/InputMixin.js";
+export { default as AriaReflectorMixin } from "./mixins/AriaReflectorMixin.js";
+export { default as ControlMixin } from "./mixins/ControlMixin.js";
+export { default as RTLObserverMixin } from "./mixins/RTLObserverMixin.js";
+export { default as TouchTargetMixin } from "./mixins/TouchTargetMixin.js";
+export { default as ShapeMixin } from "./mixins/ShapeMixin.js";
+export { default as RippleMixin } from "./mixins/RippleMixin.js";
+export { default as FormAssociatedMixin } from "./mixins/FormAssociatedMixin.js";
+export { default as KeyboardNavMixin } from "./mixins/KeyboardNavMixin.js";
+export { default as ResizeObserverMixin } from "./mixins/ResizeObserverMixin.js";
+export { default as DensityMixin } from "./mixins/DensityMixin.js";
+export { default as TooltipTriggerMixin } from "./mixins/TooltipTriggerMixin.js";
+export { default as ScrollListenerMixin } from "./mixins/ScrollListenerMixin.js";
+export { default as FlexableMixin } from "./mixins/FlexableMixin.js";
+export { default as ThemableMixin } from "./mixins/ThemableMixin.js";
+export { default as AriaToolbarMixin } from "./mixins/AriaToolbarMixin.js";
+export { default as TextFieldMixin } from "./mixins/TextFieldMixin.js";
+export { default as ElevationMixin } from "./mixins/ElevationMixin.js";
+export { default as StateMixin } from "./mixins/StateMixin.js";
+export * as jsonMergePatch from "./core/jsonMergePatch.js";
+export * as theme from "./services/theme.js";
+export * as svgAlias from "./services/svgAlias.js";
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

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

package/types/loaders/palette.d.ts

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

package/types/loaders/palette.d.ts.map

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

package/types/loaders/theme.d.ts

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

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

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

package/types/mixins/AriaReflectorMixin.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @template K
+ * @typedef {K extends keyof ARIAMixin ? ARIAMixin[K] extends string ? K : never : never} StringKeyOfARIAMixin
+ */
+/**
+ * Reflects ARIA-like properties to attributes/ElementInternals and vice versa.
+ * @param {typeof import('../core/CustomElement.js').default} Base
+ */
+export default function AriaReflectorMixin(Base: typeof import("../core/CustomElement.js").default): typeof import("../core/CustomElement.js").default & import("../core/CustomElement.js").Class<{
+    _ariaRole: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    /**
+     * Browsers that do not support ARIAMixin in ElementInternals need to have
+     * their attributes set after construction.
+     * @type {Map<StringKeyOfARIAMixin<keyof ARIAMixin>, ARIAMixin[StringKeyOfARIAMixin<keyof ARIAMixin>]>}
+     */
+    _onConnectAriaValues: Map<StringKeyOfARIAMixin<keyof ARIAMixin>, ARIAMixin[StringKeyOfARIAMixin<keyof ARIAMixin>]>;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    /**
+     * @param {keyof HTMLElement & keyof ElementInternals} name
+     */
+    readAriaProperty(name: keyof HTMLElement & keyof ElementInternals): string | ShadowRoot | Element | readonly Element[];
+    /**
+     * @template {StringKeyOfARIAMixin<keyof ARIAMixin>} K
+     * @param {K} name
+     * @param {ARIAMixin[K]} value
+     */
+    updateAriaProperty<K extends StringKeyOfARIAMixin<keyof ARIAMixin>>(name: K, value: ARIAMixin[K]): void;
+}, any[]>;
+export type StringKeyOfARIAMixin<K> = K extends keyof ARIAMixin ? ARIAMixin[K] extends string ? K : never : never;
+//# sourceMappingURL=AriaReflectorMixin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AriaReflectorMixin.d.ts","sourceRoot":"","sources":["../../mixins/AriaReflectorMixin.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AACH,iDAFW,cAAc,0BAA0B,EAAE,OAAO;;;IAStD;;;;OAIG;0BADO,GAAG,CAAC,oBAAoB,CAAC,MAAM,SAAS,CAAC,EAAE,SAAS,CAAC,oBAAoB,CAAC,MAAM,SAAS,CAAC,CAAC,CAAC;;IAKtG;;OAEG;2BADQ,MAAM,WAAW,GAAG,MAAM,gBAAgB;IAgBrD;;;;OAIG;uBAHkD,CAAC,SAAxC,oBAAoB,CAAC,MAAM,SAAS,CAAE,QACzC,CAAC,SACD,SAAS,CAAC,CAAC,CAAC;UA2C5B;iCAtFY,CAAC,IACD,CAAC,SAAS,MAAM,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,CAAC,GAAG,KAAK,GAAG,KAAK"}

package/types/mixins/AriaToolbarMixin.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Provides ARIA toolbar semantics and keyboard navigation defaults.
+ * @param {typeof import('../core/CustomElement.js').default} Base
+ */
+export default function AriaToolbarMixin(Base: typeof import("../core/CustomElement.js").default): typeof import("../core/CustomElement.js").default & 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<{
+    kbdNav: string;
+    _kbdFocusable: boolean;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    kbdNavQuery: string;
+    kbdNavFocusableWhenDisabled: boolean;
+    ariaOrientationDefault: "horizontal" | "vertical";
+}, any[]> & import("../core/CustomElement.js").Class<{
+    kbdNavChildren: NodeListOf<HTMLElement>;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    _ariaOrientationIsVertical(): boolean;
+    focusCurrentOrFirst(): HTMLElement;
+    focusNext(current?: HTMLElement, loop?: boolean, reverse?: boolean): HTMLElement;
+    focusPrevious(current?: HTMLElement, loop?: boolean): HTMLElement;
+    focus(options?: FocusOptions): void;
+    refreshTabIndexes(): void;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    /** Default orientation for toolbar: 'horizontal' or 'vertical'. */
+    ariaOrientationDefault: string;
+    /** Default ARIA role applied to the host (e.g. 'toolbar'). */
+    _ariaRole: string;
+}, any[]>;
+//# sourceMappingURL=AriaToolbarMixin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AriaToolbarMixin.d.ts","sourceRoot":"","sources":["../../mixins/AriaToolbarMixin.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,+CAFW,cAAc,0BAA0B,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;IAOtD,mEAAmE;;IAEnE,8DAA8D;;UAGnE"}

package/types/mixins/ControlMixin.d.ts

@@ -0,0 +1,124 @@
+/** @typedef {import('../core/CustomElement.js').default} CustomElement */
+/** @typedef {'align'|'useMap'} DeprecatedHTMLInputElementProperties */
+/** @typedef {HTMLInputElement|HTMLTextAreaElement|HTMLSelectElement} HTMLControlElement */
+/**
+ * Adds form-control behavior and wiring to an internal control element.
+ * @param {ReturnType<import('./StateMixin.js').default>} Base
+ */
+export default function ControlMixin(Base: ReturnType<typeof import("./StateMixin.js").default>): typeof import("../core/CustomElement.js").default & import("../core/CustomElement.js").Class<{
+    delegatesFocus: boolean;
+}, 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[]> & {
+    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<{
+    /**
+     * Default behavior can be overridden
+     * @param {string} value
+     */
+    _onControlValue(value: string): void;
+    onValueChangingContentAttribute(): void;
+    focus(options?: FocusOptions): void;
+    /** Redirect click requests to control itself */
+    click(): void;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    stateTargetElement: HTMLElement;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    checkValidity(): boolean;
+    reportValidity(): boolean;
+    /**
+     * @param {string} error
+     * @return {void}
+     */
+    setCustomValidity(error: string): void;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    _computedAriaLabel: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    _computedAriaLabelledby: never;
+}, any[]>;
+export type CustomElement = import("../core/CustomElement.js").default;
+export type DeprecatedHTMLInputElementProperties = "align" | "useMap";
+export type HTMLControlElement = HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;
+//# sourceMappingURL=ControlMixin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ControlMixin.d.ts","sourceRoot":"","sources":["../../mixins/ControlMixin.js"],"names":[],"mappings":"AAQA,0EAA0E;AAE1E,uEAAuE;AAEvE,2FAA2F;AAE3F;;;GAGG;AACH,2CAFW,UAAU,CAAC,wCAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmBlD;;;OAGG;2BADQ,MAAM;;;IAqBjB,gDAAgD;;;;;;;IAiChD;;;OAGG;6BAFQ,MAAM,GACL,IAAI;;;;;UAqLrB;4BA1Qa,OAAO,0BAA0B,EAAE,OAAO;mDAE1C,OAAO,GAAC,QAAQ;iCAEhB,gBAAgB,GAAC,mBAAmB,GAAC,iBAAiB"}

package/types/mixins/DelegatesFocusMixin.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Enables focus delegation to an internal focus target and manages tabindex behavior.
+ * @param {typeof import('../core/CustomElement.js').default} Base
+ */
+/**
+ * Adds delegated focus behavior to the element's internals for keyboard navigation.
+ * @param {typeof import('../core/CustomElement.js').default} Base
+ */
+export default function DelegatesFocusMixin(Base: typeof import("../core/CustomElement.js").default): typeof import("../core/CustomElement.js").default & import("../core/CustomElement.js").Class<{
+    /** When true, the element delegates focus to an internal focus target. */
+    delegatesFocus: boolean;
+}, any[]>;
+//# sourceMappingURL=DelegatesFocusMixin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DelegatesFocusMixin.d.ts","sourceRoot":"","sources":["../../mixins/DelegatesFocusMixin.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;;;GAGG;AACH,kDAFW,cAAc,0BAA0B,EAAE,OAAO;IAKtD,0EAA0E;;UAgD/E"}

package/types/mixins/DensityMixin.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Adds a `density` property to control component spacing and compactness.
+ * @param {typeof import('../core/CustomElement.js').default} Base
+ */
+export default function DensityMixin(Base: typeof import("../core/CustomElement.js").default): typeof import("../core/CustomElement.js").default & import("../core/CustomElement.js").Class<{
+    density: number;
+}, any[]>;
+//# sourceMappingURL=DensityMixin.d.ts.map

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

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

package/types/mixins/ElevationMixin.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Adds CSS properties for elevation via shadows or underlighting.
+ * @param {ReturnType<import('./StateMixin.js').default> & ReturnType<import('./ThemableMixin.js').default>} Base
+ */
+export default function ElevationMixin(Base: ReturnType<typeof import("./StateMixin.js").default> & ReturnType<typeof import("./ThemableMixin.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<{
+    color: string;
+    ink: string;
+    typeStyle: string;
+}, any[]>;
+//# sourceMappingURL=ElevationMixin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ElevationMixin.d.ts","sourceRoot":"","sources":["../../mixins/ElevationMixin.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,6CAFW,UAAU,CAAC,wCAAiC,CAAC,GAAG,UAAU,CAAC,2CAAoC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;UA0D1G"}

package/types/mixins/FlexableMixin.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Layout helper mixin providing flexible box utilities (gap, padding, axis).
+ * @param {typeof import('../core/CustomElement.js').default} Base
+ */
+export default function FlexableMixin(Base: typeof import("../core/CustomElement.js").default): typeof import("../core/CustomElement.js").default & import("../core/CustomElement.js").Class<{
+    block: boolean;
+    inline: boolean;
+    row: boolean;
+    x: string;
+    y: string;
+    gap: number;
+    padding: string;
+}, any[]>;
+//# sourceMappingURL=FlexableMixin.d.ts.map

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

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

package/types/mixins/FormAssociatedMixin.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Implements form-associated element behavior (internals, validity, files, value handling).
+ * @param {ReturnType<import('./StateMixin.js').default>} Base
+ */
+export default function FormAssociatedMixin(Base: ReturnType<typeof import("./StateMixin.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[]> & {
+    formAssociated: true;
+} & import("../core/CustomElement.js").Class<{
+    /** @type {EventListener} */
+    _ipcListener: EventListener;
+    /** @type {EventTarget} */
+    _ipcTarget: EventTarget;
+    /** @type {FileList} */
+    _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<{
+    /**
+     * Default behavior should likely be overridden
+     * @param {string} value
+     */
+    _onSetValue(value: string): void;
+    /**
+     * Default behavior should likely be overridden
+     * @param {boolean} checked
+     */
+    _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;
+    /**
+     * @param {string} error
+     * @return {void}
+     */
+    setCustomValidity(error: string): void;
+    /**
+     * @param {string} key
+     * @param {string} value
+     * @return {void}
+     */
+    _notifyRadioChange(key: string, value: string): void;
+    refreshFormAssociation(): void;
+    /**
+     * New lifecycle callback. This is called when association with
+     * <form> is changed.
+     * @param {HTMLFormElement?} form
+     * @return {void}
+     */
+    formAssociatedCallback(form: HTMLFormElement | null): void;
+    /**
+     * @param {CustomEvent<[string, string]>} event
+     * @return {void}
+     */
+    formIPCEvent(event: CustomEvent<[string, string]>): void;
+    /** @param {boolean} disabled */
+    formDisabledCallback(disabled: boolean): void;
+    formResetCallback(): void;
+    /**
+     * @param {string|FormData} state
+     * @param {'autocomplete'|'restore'} mode
+     */
+    formStateRestoreCallback(state: string | FormData, mode: "autocomplete" | "restore"): void;
+    _updateFormAssociatedValue(): void;
+}, any[]>;
+export type HTMLControlElement = HTMLElement & {
+    value: string;
+};
+export type CustomElement = import("../core/CustomElement.js").default;
+//# sourceMappingURL=FormAssociatedMixin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FormAssociatedMixin.d.ts","sourceRoot":"","sources":["../../mixins/FormAssociatedMixin.js"],"names":[],"mappings":"AAYA;;;GAGG;AACH,kDAFW,UAAU,CAAC,wCAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;IAQlD,4BAA4B;kBAAjB,aAAa;IAExB,0BAA0B;gBAAf,WAAW;IAEtB,uBAAuB;YAAZ,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;IAiEnB;;;OAGG;uBADQ,MAAM;IAKjB;;;OAGG;2BADQ,OAAO;;;;;;;;;;;;;;;IAgFlB;;;OAGG;6BAFQ,MAAM,GACL,IAAI;IAShB;;;;OAIG;4BAHQ,MAAM,SACN,MAAM,GACL,IAAI;;IAwBhB;;;;;OAKG;iCAFQ,eAAe,OAAC,GACf,IAAI;IAOhB;;;OAGG;wBAFQ,WAAW,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC5B,IAAI;IAqBhB,gCAAgC;mCAApB,OAAO;;IAanB;;;OAGG;oCAFQ,MAAM,GAAC,QAAQ,QACf,cAAc,GAAC,SAAS;;UA2GxC;iCAlXa,WAAW,GAAG;IAAC,KAAK,EAAC,MAAM,CAAA;CAAC;4BAE5B,OAAO,0BAA0B,EAAE,OAAO"}

package/types/mixins/HyperlinkMixin.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Adds hyperlink-related properties and URL helpers (href, target, rel, etc.).
+ * @param {typeof import('../core/CustomElement.js').default} Base
+ */
+export default function HyperlinkMixin(Base: typeof import("../core/CustomElement.js").default): typeof import("../core/CustomElement.js").default & import("../core/CustomElement.js").Class<{
+    href: string;
+    target: string;
+    download: string;
+    ping: string;
+    rel: string;
+    hreflang: string;
+    referrerPolicy: string;
+}, any[]> & import("../core/CustomElement.js").Class<{
+    origin: string;
+    protocol: string;
+    username: string;
+    password: string;
+    host: string;
+    hostname: string;
+    port: string;
+    pathname: string;
+    search: string;
+    hash: string;
+}, any[]> & import("../core/CustomElement.js").Class<object, any[]>;
+//# sourceMappingURL=HyperlinkMixin.d.ts.map

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

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