@m3e/web 2.0.0

package/dist/src/core/shared/tokens/TypescaleToken.d.ts

@@ -0,0 +1,220 @@
+/** Design tokens that control typescale. */
+export declare const TypescaleToken: {
+    /** Standard typescale variant. */
+    readonly standard: {
+        /** Short, important text or numerals. */
+        readonly display: {
+            readonly large: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly medium: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly small: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+        };
+        /** Short, high-emphasis text on smaller screens. */
+        readonly headline: {
+            readonly large: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly medium: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly small: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+        };
+        /** Medium-emphasis text that remains relatively short. */
+        readonly title: {
+            readonly large: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly medium: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly small: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+        };
+        /** Longer passages of text. */
+        readonly body: {
+            readonly large: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly medium: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly small: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+        };
+        /** Smaller, utilitarian text. */
+        readonly label: {
+            readonly large: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly medium: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly small: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+        };
+    };
+    /** Emphasized typescale variant. */
+    readonly emphasized: {
+        /** Short, important text or numerals. */
+        readonly display: {
+            readonly large: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly medium: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly small: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+        };
+        /** Short, high-emphasis text on smaller screens. */
+        readonly headline: {
+            readonly large: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly medium: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly small: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+        };
+        /** Medium-emphasis text that remains relatively short. */
+        readonly title: {
+            readonly large: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly medium: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly small: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+        };
+        /** Longer passages of text. */
+        readonly body: {
+            readonly large: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly medium: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly small: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+        };
+        /** Smaller, utilitarian text. */
+        readonly label: {
+            readonly large: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly medium: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+            readonly small: {
+                readonly fontSize: import("lit").CSSResult;
+                readonly fontWeight: import("lit").CSSResult;
+                readonly lineHeight: import("lit").CSSResult;
+                readonly tracking: import("lit").CSSResult;
+            };
+        };
+    };
+};
+//# sourceMappingURL=TypescaleToken.d.ts.map

package/dist/src/core/shared/tokens/TypescaleToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypescaleToken.d.ts","sourceRoot":"","sources":["../../../../../src/core/shared/tokens/TypescaleToken.ts"],"names":[],"mappings":"AAEA,4CAA4C;AAC5C,eAAO,MAAM,cAAc;IACzB,kCAAkC;;QAEhC,yCAAyC;;;;;;;;;;;;;;;;;;;;;QAsBzC,oDAAoD;;;;;;;;;;;;;;;;;;;;;QAsBpD,0DAA0D;;;;;;;;;;;;;;;;;;;;;QAsB1D,+BAA+B;;;;;;;;;;;;;;;;;;;;;QAsB/B,iCAAiC;;;;;;;;;;;;;;;;;;;;;;IAuBnC,oCAAoC;;QAElC,yCAAyC;;;;;;;;;;;;;;;;;;;;;QAsBzC,oDAAoD;;;;;;;;;;;;;;;;;;;;;QAsBpD,0DAA0D;;;;;;;;;;;;;;;;;;;;;QAsB1D,+BAA+B;;;;;;;;;;;;;;;;;;;;;QAsB/B,iCAAiC;;;;;;;;;;;;;;;;;;;;;;CAsB3B,CAAC"}

package/dist/src/core/shared/tokens/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./DesignToken";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/core/shared/tokens/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/core/shared/tokens/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/dist/src/core/shared/utils/VelocityTracker.d.ts

@@ -0,0 +1,22 @@
+/** Utility for computing gesture velocity over a rolling time window. */
+export declare class VelocityTracker {
+    #private;
+    /**
+     * @param {number} [windowMs = 100] The size of the rolling sampling window in milliseconds.
+     */
+    constructor(windowMs?: number);
+    /**
+     * Adds a new sample to the tracker.
+     * @param {number} value The value in pixels.
+     * @param {number} [timestamp=performance.now()] The timestamp when `value` changed.
+     */
+    add(value: number, timestamp?: number): void;
+    /**
+     * Computes the current velocity in px/s.
+     * @returns The vertical velocity in pixels per second.
+     */
+    getVelocity(): number;
+    /** Clears all stored samples. */
+    reset(): void;
+}
+//# sourceMappingURL=VelocityTracker.d.ts.map

package/dist/src/core/shared/utils/VelocityTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VelocityTracker.d.ts","sourceRoot":"","sources":["../../../../../src/core/shared/utils/VelocityTracker.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,qBAAa,eAAe;;IAI1B;;OAEG;gBACS,QAAQ,GAAE,MAAY;IAIlC;;;;OAIG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,GAAE,MAA0B,GAAG,IAAI;IAQ/D;;;OAGG;IACH,WAAW,IAAI,MAAM;IASrB,iCAAiC;IACjC,KAAK,IAAI,IAAI;CAGd"}

package/dist/src/core/shared/utils/computeCssSize.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Computes a CSS size expression (var(), %, rem, calc(), etc.) relative to the given host element.
+ * @param {HTMLElement} host - The element whose coordinate system and CSS variables should be used to resolve the expression.
+ * @param {string} expression - The CSS expression to evaluate.
+ * @returns {number} The resolved pixel value.
+ */
+export declare function computeCssSize(host: HTMLElement, expression: string): number;
+//# sourceMappingURL=computeCssSize.d.ts.map

package/dist/src/core/shared/utils/computeCssSize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeCssSize.d.ts","sourceRoot":"","sources":["../../../../../src/core/shared/utils/computeCssSize.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAgB5E"}

package/dist/src/core/shared/utils/computeLineCount.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Determines the number of textual lines presented by an element.
+ * @param {HTMLElement} element The element for which to compute the number of lines.
+ * @returns {number} The number of lines presented by an element.
+ */
+export declare function computeLineCount(element: HTMLElement): number;
+//# sourceMappingURL=computeLineCount.d.ts.map

package/dist/src/core/shared/utils/computeLineCount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeLineCount.d.ts","sourceRoot":"","sources":["../../../../../src/core/shared/utils/computeLineCount.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAG7D"}

package/dist/src/core/shared/utils/focusWhenReady.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Asynchronously attempts to focus an element once it becomes focusable.
+ * @param {HTMLElement} element The element to to focus.
+ * @param {number} [timeout=200] The maximum amount of time to attempt to focus `el`.
+ * @returns {Promise<boolean>} A `Promise` that resolves to whether `el` was focused.
+ */
+export declare function focusWhenReady(element: HTMLElement, timeout?: number): Promise<boolean>;
+//# sourceMappingURL=focusWhenReady.d.ts.map

package/dist/src/core/shared/utils/focusWhenReady.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focusWhenReady.d.ts","sourceRoot":"","sources":["../../../../../src/core/shared/utils/focusWhenReady.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,GAAE,MAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAmBlG"}

package/dist/src/core/shared/utils/forcedColorsActive.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Determines whether forced colors are active.
+ * @returns {boolean} Whether forced colors are active.
+ */
+export declare function forcedColorsActive(): boolean;
+//# sourceMappingURL=forcedColorsActive.d.ts.map

package/dist/src/core/shared/utils/forcedColorsActive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forcedColorsActive.d.ts","sourceRoot":"","sources":["../../../../../src/core/shared/utils/forcedColorsActive.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C"}

package/dist/src/core/shared/utils/generateClipPaths.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generates normalized clip paths from SVG path data.
+ * @param {string[]} paths The SVG path data to convert to normalized clip paths.
+ * @param {number} maxPoints The maximum number of points to which to normalize paths.
+ * @returns {string[]} The normalized clip paths.
+ */
+export declare function generateClipPaths(paths: string[], maxPoints: number): string[];
+//# sourceMappingURL=generateClipPaths.d.ts.map

package/dist/src/core/shared/utils/generateClipPaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateClipPaths.d.ts","sourceRoot":"","sources":["../../../../../src/core/shared/utils/generateClipPaths.ts"],"names":[],"mappings":"AA8OA;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAE9E"}

package/dist/src/core/shared/utils/getTextContent.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Gets the text content of a given node, including slotted content.
+ * @param {Node} node The node for which to get text content.
+ * @param {boolean} [trim = false] A value indicating whether to trim content.
+ * @returns {string} The text content of `node`.
+ */
+export declare function getTextContent(node: Node, trim?: boolean): string;
+//# sourceMappingURL=getTextContent.d.ts.map

package/dist/src/core/shared/utils/getTextContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getTextContent.d.ts","sourceRoot":"","sources":["../../../../../src/core/shared/utils/getTextContent.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,GAAE,OAAe,GAAG,MAAM,CAwBxE"}

package/dist/src/core/shared/utils/guid.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates a new globally unique identifier (GUID).
+ * @returns {string} A new globally unique identifier.
+ */
+export declare function guid(): string;
+//# sourceMappingURL=guid.d.ts.map

package/dist/src/core/shared/utils/guid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guid.d.ts","sourceRoot":"","sources":["../../../../../src/core/shared/utils/guid.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,IAAI,IAAI,MAAM,CAM7B"}

package/dist/src/core/shared/utils/hasAssignedNodes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Determines whether a slot has any assigned nodes.
+ * @param {HTMLSlotElement} slot The slot to test.
+ * @returns {boolean} Whether `slot` has any assigned nodes.
+ */
+export declare function hasAssignedNodes(slot: HTMLSlotElement): boolean;
+//# sourceMappingURL=hasAssignedNodes.d.ts.map

package/dist/src/core/shared/utils/hasAssignedNodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasAssignedNodes.d.ts","sourceRoot":"","sources":["../../../../../src/core/shared/utils/hasAssignedNodes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAE/D"}

package/dist/src/core/shared/utils/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./computeCssSize";
+export * from "./computeLineCount";
+export * from "./focusWhenReady";
+export * from "./forcedColorsActive";
+export * from "./generateClipPaths";
+export * from "./getTextContent";
+export * from "./guid";
+export * from "./hasAssignedNodes";
+export * from "./interceptProperty";
+export * from "./prefersReducedMotion";
+export * from "./resolveElementById";
+export * from "./resolveFragmentUrl";
+export * from "./scrollIntoViewIfNeeded";
+export * from "./VelocityTracker";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/core/shared/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/core/shared/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,QAAQ,CAAC;AACvB,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC"}

package/dist/src/core/shared/utils/interceptProperty.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Intercepts property access and mutations on a target object, allowing custom logic
+ * to run when the property is read or written to.
+ *
+ * @template T - The type of the target object.
+ * @template K - The key of the property being intercepted (must be a valid key of T).
+ * @param target - The object whose property should be intercepted.
+ * @param prop - The property key to intercept.
+ * @param options - Configuration object for interceptor callbacks.
+ * @returns A cleanup function that removes the interceptors and restores the original property descriptor.
+ * @throws {Error} If the property does not exist on the target object or its prototype chain.
+ */
+export declare function interceptProperty<T extends object, K extends keyof T>(target: T, prop: K, options: {
+    get?: (getter: () => T[K]) => T[K];
+    set?: (value: T[K], setter: (v: T[K]) => void) => void;
+}): () => void;
+//# sourceMappingURL=interceptProperty.d.ts.map

package/dist/src/core/shared/utils/interceptProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interceptProperty.d.ts","sourceRoot":"","sources":["../../../../../src/core/shared/utils/interceptProperty.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EACnE,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,CAAC,EACP,OAAO,EAAE;IACP,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACnC,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,KAAK,IAAI,CAAC;CACxD,GACA,MAAM,IAAI,CA4BZ"}

package/dist/src/core/shared/utils/prefersReducedMotion.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Determines whether reduced motion is preferred.
+ * @returns {boolean} Whether reduced motion is preferred.
+ */
+export declare function prefersReducedMotion(): boolean;
+//# sourceMappingURL=prefersReducedMotion.d.ts.map

package/dist/src/core/shared/utils/prefersReducedMotion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefersReducedMotion.d.ts","sourceRoot":"","sources":["../../../../../src/core/shared/utils/prefersReducedMotion.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C"}

package/dist/src/core/shared/utils/resolveElementById.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Resolves an element by ID, waiting for document readiness if needed.
+ * @param {string} id - The element ID to resolve.
+ * @param {ParentNode} root - Optional root node to query from (defaults to document).
+ * @returns {Promise<T | null>} A promise that resolves with the element or `null` if not found.
+ */
+export declare function resolveElementById<T extends Element>(id: string, root?: ParentNode): Promise<T | null>;
+//# sourceMappingURL=resolveElementById.d.ts.map

package/dist/src/core/shared/utils/resolveElementById.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveElementById.d.ts","sourceRoot":"","sources":["../../../../../src/core/shared/utils/resolveElementById.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,GAAE,UAAqB,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAehH"}

package/dist/src/core/shared/utils/resolveFragmentUrl.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Resolves a URL fragment reference (`url(path#id)`) based on the current document location.
+ *
+ * This helper is typically used when constructing fragment-based URLs for SVG
+ * references (e.g., masks, clipPaths, filters) where the browser requires a fully
+ * qualified `url(...)` value that includes the current path.
+ *
+ * How it works:
+ * - Safely reads `document.location` (guarded for SSR environments).
+ * - Extracts the current page's path + query string.
+ * - Removes any existing hash fragment from the URL.
+ * - Appends `#${id}` to produce a stable fragment reference.
+ *
+ * Example:
+ *   // If the current page is /viewer/page?mode=edit#section2
+ *   resolveFragmentUrl("clip") → "url(/viewer/page?mode=edit#clip)"
+ *
+ * @param id - The fragment identifier to append (e.g., an SVG element's ID).
+ * @returns A `url(...)` string pointing to the fragment within the current document.
+ */
+export declare function resolveFragmentUrl(id: string): string;
+//# sourceMappingURL=resolveFragmentUrl.d.ts.map

package/dist/src/core/shared/utils/resolveFragmentUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveFragmentUrl.d.ts","sourceRoot":"","sources":["../../../../../src/core/shared/utils/resolveFragmentUrl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAIrD"}

package/dist/src/core/shared/utils/scrollIntoViewIfNeeded.d.ts

@@ -0,0 +1,8 @@
+/**
+ * If needed, scrolls an element into view within a given scroll container.
+ * @param {HTMLElement} element The element to scroll into view.
+ * @param {HTMLElement} scrollContainer The scrollable container.
+ * @param {ScrollIntoViewOptions} [options=undefined] Options used to scroll into view.
+ */
+export declare function scrollIntoViewIfNeeded(element: HTMLElement, scrollContainer: HTMLElement, options?: ScrollIntoViewOptions): void;
+//# sourceMappingURL=scrollIntoViewIfNeeded.d.ts.map

package/dist/src/core/shared/utils/scrollIntoViewIfNeeded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrollIntoViewIfNeeded.d.ts","sourceRoot":"","sources":["../../../../../src/core/shared/utils/scrollIntoViewIfNeeded.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,WAAW,EACpB,eAAe,EAAE,WAAW,EAC5B,OAAO,CAAC,EAAE,qBAAqB,GAC9B,IAAI,CAON"}

package/dist/src/dialog/DialogActionElement.d.ts

@@ -0,0 +1,24 @@
+import { ActionElementBase } from "@m3e/web/core";
+/**
+ * An element, nested within a clickable element, used to close a parenting dialog.
+ * @tag m3e-dialog-action
+ *
+ * @slot - Renders the content of the action.
+ *
+ * @attr return-value - The value to return from the dialog.
+ */
+export declare class M3eDialogActionElement extends ActionElementBase {
+    /**
+     * The value to return from the dialog.
+     * @default ""
+     */
+    returnValue: string;
+    /** @inheritdoc */
+    protected _onClick(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "m3e-dialog-action": M3eDialogActionElement;
+    }
+}
+//# sourceMappingURL=DialogActionElement.d.ts.map

package/dist/src/dialog/DialogActionElement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DialogActionElement.d.ts","sourceRoot":"","sources":["../../../src/dialog/DialogActionElement.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAElD;;;;;;;GAOG;AACH,qBACa,sBAAuB,SAAQ,iBAAiB;IAC3D;;;OAGG;IACsC,WAAW,SAAM;IAE1D,kBAAkB;cACC,QAAQ,IAAI,IAAI;CAGpC;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,mBAAmB,EAAE,sBAAsB,CAAC;KAC7C;CACF"}

package/dist/src/dialog/DialogElement.d.ts

@@ -0,0 +1,142 @@
+import { CSSResultGroup, LitElement } from "lit";
+import "@m3e/web/core/a11y";
+declare const M3eDialogElement_base: typeof LitElement;
+/**
+ * A dialog that provides important prompts in a user flow.
+ *
+ * @description
+ * The `m3e-dialog` component presents important prompts, alerts, and actions in user flows.
+ * Designed according to Material 3 principles, it supports custom header, content, and
+ * close icon slots, ARIA accessibility, focus management, and theming via CSS custom properties.
+ *
+ * @example
+ * ```html
+ * <m3e-button variant="filled">
+ *   <m3e-dialog-trigger for="dlg">Open Dialog</m3e-dialog-trigger>
+ * </m3e-button>
+ * <m3e-dialog id="dlg" dismissible onclosed="console.log(this.returnValue)">
+ *   <span slot="header">Dialog Title</span>
+ *   Dialog content goes here.
+ *   <div slot="actions" end>
+ *     <m3e-button autofocus><m3e-dialog-action return-value="ok">Close</m3e-dialog-action></m3e-button>
+ *   </div>
+ * </m3e-dialog>
+ * ```
+ *
+ * @tag m3e-dialog
+ *
+ * @slot - Renders the content of the dialog.
+ * @slot header - Renders the header of the dialog.
+ * @slot actions - Renders the actions of the dialog.
+ * @slot close-icon - Renders the icon of the button used to close the dialog.
+ *
+ * @attr alert - Whether the dialog is an alert.
+ * @attr close-label - The accessible label given to the button used to dismiss the dialog.
+ * @attr disable-close -Whether users cannot click the backdrop or press escape to dismiss the dialog.
+ * @attr dismissible - Whether a button is presented that can be used to close the dialog.
+ * @attr no-focus-trap - Whether to disable focus trapping, which keeps keyboard `Tab` navigation within the dialog.
+ * @attr open - Whether the dialog is open.
+ *
+ * @fires opening - Emitted when the dialog begins to open.
+ * @fires opened - Emitted when the dialog has opened.
+ * @fires cancel - Emitted when the dialog is cancelled.
+ * @fires closing - Emitted when the dialog begins to close.
+ * @fires closed - Emitted when the dialog has closed.
+ *
+ * @cssprop --m3e-dialog-shape - Border radius of the dialog container.
+ * @cssprop --m3e-dialog-min-width - Minimum width of the dialog.
+ * @cssprop --m3e-dialog-max-width - Maximum width of the dialog.
+ * @cssprop --m3e-dialog-color - Foreground color of the dialog.
+ * @cssprop --m3e-dialog-container-color - Background color of the dialog container.
+ * @cssprop --m3e-dialog-scrim-color - Color of the scrim (backdrop overlay).
+ * @cssprop --m3e-dialog-scrim-opacity - Opacity of the scrim when open.
+ * @cssprop --m3e-dialog-header-container-color - Background color of the dialog header.
+ * @cssprop --m3e-dialog-header-color - Foreground color of the dialog header.
+ * @cssprop --m3e-dialog-header-font-size - Font size for the dialog header.
+ * @cssprop --m3e-dialog-header-font-weight - Font weight for the dialog header.
+ * @cssprop --m3e-dialog-header-line-height - Line height for the dialog header.
+ * @cssprop --m3e-dialog-header-tracking - Letter spacing for the dialog header.
+ * @cssprop --m3e-dialog-content-color - Foreground color of the dialog content.
+ * @cssprop --m3e-dialog-content-font-size - Font size for the dialog content.
+ * @cssprop --m3e-dialog-content-font-weight - Font weight for the dialog content.
+ * @cssprop --m3e-dialog-content-line-height - Line height for the dialog content.
+ * @cssprop --m3e-dialog-content-tracking - Letter spacing for the dialog content.
+ */
+export declare class M3eDialogElement extends M3eDialogElement_base {
+    #private;
+    /** The styles of the element. */
+    static styles: CSSResultGroup;
+    /** @private */ private static __nextId;
+    /** @private */ private _hasActions;
+    /** @private */ private readonly _base;
+    /** @private */ private readonly _content;
+    /**
+     * Whether the dialog is an alert.
+     * @default false
+     */
+    alert: boolean;
+    /**
+     * Whether the dialog is open.
+     * @default false
+     */
+    get open(): boolean;
+    set open(value: boolean);
+    /**
+     * Whether a button is presented that can be used to close the dialog.
+     * @default false
+     */
+    dismissible: boolean;
+    /**
+     * Whether users cannot click the backdrop or press ESC to dismiss the dialog.
+     * @default false
+     */
+    disableClose: boolean;
+    /**
+     * Whether to disable focus trapping, which keeps keyboard `Tab` navigation within the dialog.
+     * @default false
+     */
+    noFocusTrap: boolean;
+    /**
+     * The accessible label given to the button used to dismiss the dialog.
+     * @default "Close"
+     */
+    closeLabel: string;
+    /**
+     * The return value of the dialog.
+     * @default ""
+     */
+    returnValue: string;
+    /**
+     * Asynchronously opens the dialog.
+     * @returns {Promise<void>} A `Promise` that resolves when the dialog is open.
+     */
+    show(): Promise<void>;
+    /**
+     * Asynchronously closes the dialog.
+     * @param {string} returnValue The value to return.
+     * @returns {Promise<void>} A `Promise` that resolves when the dialog is closed.
+     */
+    hide(returnValue?: string): Promise<void>;
+    /** @inheritdoc */
+    protected render(): unknown;
+}
+interface M3eDialogElementEventMap extends HTMLElementEventMap {
+    opening: Event;
+    opened: Event;
+    closing: Event;
+    closed: Event;
+    cancel: Event;
+}
+export interface M3eDialogElement {
+    addEventListener<K extends keyof M3eDialogElementEventMap>(type: K, listener: (this: M3eDialogElement, ev: M3eDialogElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof M3eDialogElementEventMap>(type: K, listener: (this: M3eDialogElement, ev: M3eDialogElementEventMap[K]) => void, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "m3e-dialog": M3eDialogElement;
+    }
+}
+export {};
+//# sourceMappingURL=DialogElement.d.ts.map