@ionic/core 9.0.9 → 9.0.10-dev.11793383958.19a7d413

package/dist/collection/components/input-otp/input-otp.md.css

@@ -111,6 +111,7 @@
    * different selectors for different fill variants.
    */
   --highlight-color: var(--highlight-color-focused);
+  --border-color: initial;
   display: block;
   position: relative;
   font-size: 0.875rem;
@@ -148,7 +149,7 @@
   height: var(--height);
   border-width: var(--border-width);
   border-style: solid;
-  border-color: var(--border-color);
+  border-color: var(--border-color, var(--internal-border-color));
   background: var(--background);
   color: var(--color);
   font-size: inherit;
@@ -171,6 +172,30 @@
   display: none;
 }
 
+.input-otp-bottom {
+  font-size: 0.75rem;
+  line-height: 1.25rem;
+  text-align: center;
+}
+
+.input-otp-bottom .error-text {
+  display: none;
+  color: var(--highlight-color-invalid);
+}
+
+.input-otp-bottom .helper-text {
+  display: block;
+  color: var(--ion-color-step-700, var(--ion-text-color-step-300, #4d4d4d));
+}
+
+:host(.ion-touched.ion-invalid) .input-otp-bottom .error-text {
+  display: block;
+}
+
+:host(.ion-touched.ion-invalid) .input-otp-bottom .helper-text {
+  display: none;
+}
+
 .input-otp-separator {
   border-radius: var(--separator-border-radius);
   flex-shrink: 0;
@@ -220,7 +245,7 @@
 }
 
 :host(.input-otp-fill-solid) {
-  --border-color: var(--ion-color-step-50, var(--ion-background-color-step-50, #f2f2f2));
+  --internal-border-color: var(--ion-color-step-50, var(--ion-background-color-step-50, #f2f2f2));
   --background: var(--ion-color-step-50, var(--ion-background-color-step-50, #f2f2f2));
 }
 
@@ -230,7 +255,7 @@
 
 :host(.input-otp-fill-outline.input-otp-disabled) {
   --background: var(--ion-color-step-50, var(--ion-background-color-step-50, #f2f2f2));
-  --border-color: var(--ion-color-step-100, var(--ion-background-color-step-100, #e6e6e6));
+  --internal-border-color: var(--ion-color-step-100, var(--ion-background-color-step-100, #e6e6e6));
 }
 
 :host(.input-otp-disabled),
@@ -249,7 +274,7 @@
 
 :host(.input-otp-fill-solid.input-otp-disabled),
 :host(.input-otp-fill-solid.input-otp-readonly) {
-  --border-color: var(--ion-color-step-100, var(--ion-background-color-step-100, #e6e6e6));
+  --internal-border-color: var(--ion-color-step-100, var(--ion-background-color-step-100, #e6e6e6));
   --background: var(--ion-color-step-100, var(--ion-background-color-step-100, #e6e6e6));
 }
 
@@ -377,5 +402,5 @@
 }
 
 :host(.input-otp-fill-outline) {
-  --border-color: var(--ion-color-step-300, var(--ion-background-color-step-300, #b3b3b3));
+  --internal-border-color: var(--ion-color-step-300, var(--ion-background-color-step-300, #b3b3b3));
 }

package/dist/collection/components/menu/menu.js

@@ -11,7 +11,6 @@ import { printIonError } from "../../utils/logging/index";
 import { menuController } from "../../utils/menu-controller/index";
 import { BACKDROP, GESTURE, getPresentedOverlay } from "../../utils/overlays";
 import { isPlatform } from "../../utils/platform";
-import { hostContext } from "../../utils/theme";
 import { config } from "../../global/config";
 import { getIonMode } from "../../global/ionic-global";
 const iosEasing = 'cubic-bezier(0.32,0.72,0,1)';
@@ -169,7 +168,7 @@ export class Menu {
          * of the split pane. If the split pane is
          * hidden then the menu should be too.
          */
-        const splitPane = this.el.closest('ion-split-pane');
+        const splitPane = this.getSplitPane();
         if (splitPane !== null) {
             this.isPaneVisible = await splitPane.isVisible();
         }
@@ -208,8 +207,8 @@ export class Menu {
         this.contentEl = undefined;
     }
     onSplitPaneChanged(ev) {
-        const closestSplitPane = this.el.closest('ion-split-pane');
-        if (closestSplitPane !== null && closestSplitPane === ev.target) {
+        const splitPane = this.getSplitPane();
+        if (splitPane !== null && splitPane === ev.target) {
             this.isPaneVisible = ev.detail.visible;
             this.updateState();
         }
@@ -407,6 +406,24 @@ export class Menu {
     _isActive() {
         return !this.disabled && !this.isPaneVisible;
     }
+    /**
+     * Returns the split pane this menu is a side pane of.
+     * A menu inside the split pane's main content, such as one
+     * in a page, is a regular menu. The menu doesn't need to be
+     * a direct child, since it can be wrapped in a component.
+     */
+    getSplitPane() {
+        const splitPane = this.el.closest('ion-split-pane');
+        const main = this.el.closest('.split-pane-main');
+        /**
+         * A split pane can be the main content of an outer split
+         * pane, so only this split pane's main content counts.
+         */
+        if (splitPane === null || (main !== null && main !== splitPane && splitPane.contains(main))) {
+            return null;
+        }
+        return splitPane;
+    }
     canSwipe() {
         return this.swipeGesture && !this.isAnimating && this._isActive();
     }
@@ -650,21 +667,21 @@ export class Menu {
         }
     }
     render() {
-        const { type, disabled, el, isPaneVisible, inheritedAttributes, side } = this;
+        const { type, disabled, isPaneVisible, inheritedAttributes, side } = this;
         const mode = getIonMode(this);
         /**
          * If the Close Watcher is enabled then
          * the ionBackButton listener in the menu controller
          * will handle closing the menu when Escape is pressed.
          */
-        return (h(Host, { key: '5cf26df26d4e539860cbeaea98ec621b98c3fcfc', onKeyDown: shouldUseCloseWatcher() ? null : this.onKeydown, role: "navigation", "aria-label": inheritedAttributes['aria-label'] || 'menu', class: {
+        return (h(Host, { key: '7481c8a32a135fb0fd6d5591eecbf3fb0a8e8dde', onKeyDown: shouldUseCloseWatcher() ? null : this.onKeydown, role: "navigation", "aria-label": inheritedAttributes['aria-label'] || 'menu', class: {
                 [mode]: true,
                 [`menu-type-${type}`]: true,
                 'menu-enabled': !disabled,
                 [`menu-side-${side}`]: true,
                 'menu-pane-visible': isPaneVisible,
-                'split-pane-side': hostContext('ion-split-pane', el),
-            } }, h("div", { key: 'f337016e293bb8665c99762e0c389dd6c372bb33', class: "menu-inner", part: "container", ref: (el) => (this.menuInnerEl = el) }, h("slot", { key: '4c3fe331aa42cd57d7ad9bd1f5910f8eeb62d7da' })), h("ion-backdrop", { key: '61af7ea876d81574841e1dd3e81e2352e555d096', ref: (el) => (this.backdropEl = el), class: "menu-backdrop", tappable: false, stopPropagation: false, part: "backdrop" })));
+                'split-pane-side': this.getSplitPane() !== null,
+            } }, h("div", { key: '8ac2f0f531db944a46e5fef016d0b18bd7b804cc', class: "menu-inner", part: "container", ref: (el) => (this.menuInnerEl = el) }, h("slot", { key: '1ac3e13ccccf1adb7915b739fc794f2889b626ce' })), h("ion-backdrop", { key: 'f8becbf4de1a13feb57fb87973befecb88510bab', ref: (el) => (this.backdropEl = el), class: "menu-backdrop", tappable: false, stopPropagation: false, part: "backdrop" })));
     }
     static get is() { return "ion-menu"; }
     static get encapsulation() { return "shadow"; }

package/dist/collection/components/route/route.js

@@ -6,6 +6,14 @@ export class Route {
          *
          * Accepts paths similar to expressjs so that you can define parameters
          * in the url /foo/:bar where bar would be available in incoming props.
+         *
+         * A url ending in `*`, such as `*` or `/admin/*`, matches any remaining path,
+         * including none, so `/admin/*` also matches `/admin`. It only wins over a
+         * route that matches the whole path when it has more fixed segments, so
+         * `/admin/*` wins over `/:section/:id` but not over `/admin/:id`. It always
+         * wins over a route that matches by ignoring trailing segments, such as
+         * `/admin` for `/admin/users`. The matched path is passed in the `pathMatch`
+         * prop without a leading `/`. A `*` on a route with child routes is ignored.
          */
         this.url = '';
     }
@@ -47,7 +55,7 @@ export class Route {
                 "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "Relative path that needs to match in order for this route to apply.\n\nAccepts paths similar to expressjs so that you can define parameters\nin the url /foo/:bar where bar would be available in incoming props."
+                    "text": "Relative path that needs to match in order for this route to apply.\n\nAccepts paths similar to expressjs so that you can define parameters\nin the url /foo/:bar where bar would be available in incoming props.\n\nA url ending in `*`, such as `*` or `/admin/*`, matches any remaining path,\nincluding none, so `/admin/*` also matches `/admin`. It only wins over a\nroute that matches the whole path when it has more fixed segments, so\n`/admin/*` wins over `/:section/:id` but not over `/admin/:id`. It always\nwins over a route that matches by ignoring trailing segments, such as\n`/admin` for `/admin/users`. The matched path is passed in the `pathMatch`\nprop without a leading `/`. A `*` on a route with child routes is ignored."
                 },
                 "getter": false,
                 "setter": false,

package/dist/collection/components/route-redirect/route-redirect.js

@@ -20,7 +20,7 @@ export class RouteRedirect {
                 "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "A redirect route, redirects \"from\" a URL \"to\" another URL. This property is that \"from\" URL.\nIt needs to be an exact match of the navigated URL in order to apply.\n\nThe path specified in this value is always an absolute path, even if the initial `/` slash\nis not specified."
+                    "text": "A redirect route, redirects \"from\" a URL \"to\" another URL. This property is that \"from\" URL.\nIt needs to be an exact match of the navigated URL in order to apply, unless it contains a `*`.\nA `*` matches the rest of the path from that segment on, as long as the path has at least as\nmany segments as `from`, so `/admin/*` matches `/admin/posts` but not `/admin`.\n\nThe path specified in this value is always an absolute path, even if the initial `/` slash\nis not specified."
                 },
                 "getter": false,
                 "setter": false,

package/dist/collection/components/router/utils/constants.js

@@ -4,3 +4,5 @@
 export const ROUTER_INTENT_NONE = 'root';
 export const ROUTER_INTENT_FORWARD = 'forward';
 export const ROUTER_INTENT_BACK = 'back';
+/** Param that holds the path matched by a trailing `*` in an `ion-route` url. */
+export const WILDCARD_PARAM = 'pathMatch';

package/dist/collection/components/router/utils/matching.js

@@ -1,6 +1,8 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
+import { WILDCARD_PARAM } from "./constants";
+import { chainToSegments, endsWithWildcard, withoutWildcard } from "./path";
 /**
  * Returns whether the given redirect matches the given path segments.
  *
@@ -41,6 +43,10 @@ export const matchesIDs = (ids, chain) => {
         if (routeId.id.toLowerCase() !== routeChain.id) {
             break;
         }
+        // Weight a wildcard route when the outlet reports its `pathMatch`
+        if (routeId.params?.[WILDCARD_PARAM] !== undefined && endsWithWildcard(routeChain.segments)) {
+            score++;
+        }
         if (routeId.params) {
             const routeIdParams = Object.keys(routeId.params);
             // Only compare routes with the chain that have the same number of parameters.
@@ -96,21 +102,28 @@ export const matchesSegments = (segments, chain) => {
             matchesDefault = true;
         }
         else {
-            for (const segment of chainSegments) {
+            const params = {};
+            for (const segment of withoutWildcard(chainSegments)) {
                 const data = inputSegments.next();
                 // data param
                 if (segment[0] === ':') {
                     if (data === '') {
                         return null;
                     }
-                    allparams = allparams || [];
-                    const params = allparams[i] || (allparams[i] = {});
                     params[segment.slice(1)] = data;
                 }
                 else if (data !== segment) {
                     return null;
                 }
             }
+            // A trailing `*` on a parent route has no effect. Its children match the rest of the path.
+            if (i === chain.length - 1 && endsWithWildcard(chainSegments)) {
+                params[WILDCARD_PARAM] = inputSegments.rest().join('/');
+            }
+            if (Object.keys(params).length > 0) {
+                allparams = allparams || [];
+                allparams[i] = params;
+            }
             matchesDefault = false;
         }
     }
@@ -142,25 +155,38 @@ export const mergeParams = (a, b) => {
  * Returns the best match or null when no match is found.
  * When a chain is returned the parameters are updated from the RouteIDs.
  * That is they contain both the componentProps of the <ion-route> and the parameter segment.
+ *
+ * When a wildcard route ties with other routes, a route without a wildcard that can build a url wins,
+ * then the wildcard route. Otherwise the first route declared wins a tie.
  */
 export const findChainForIDs = (ids, chains) => {
-    let match = null;
     let maxMatches = 0;
+    let tied = [];
     for (const chain of chains) {
         const score = matchesIDs(ids, chain);
         if (score > maxMatches) {
-            match = chain;
             maxMatches = score;
+            tied = [chain];
+        }
+        else if (score > 0 && score === maxMatches) {
+            tied.push(chain);
         }
     }
-    if (match) {
-        return match.map((route, i) => ({
-            id: route.id,
-            segments: route.segments,
-            params: mergeParams(route.params, ids[i]?.params),
-        }));
+    const matches = tied.map((chain) => chain.map((route, i) => ({
+        id: route.id,
+        segments: route.segments,
+        params: mergeParams(route.params, ids[i]?.params),
+    })));
+    if (!matches.some(chainEndsWithWildcard)) {
+        return matches.length > 0 ? matches[0] : null;
+    }
+    return matches.reduce((best, chain) => (tieRank(chain) > tieRank(best) ? chain : best));
+};
+const tieRank = (chain) => {
+    if (chainEndsWithWildcard(chain)) {
+        return 1;
     }
-    return null;
+    return chainToSegments(chain) !== null ? 2 : 0;
 };
 /**
  * Finds the best match for the segments in the chains.
@@ -168,10 +194,17 @@ export const findChainForIDs = (ids, chains) => {
  * Returns the best match or null when no match is found.
  * When a chain is returned the parameters are updated from the segments.
  * That is they contain both the componentProps of the <ion-route> and the parameter segments.
+ *
+ * When wildcard routes match, the one with the most fixed segments wins if it has more fixed segments than every
+ * route that matched the whole path. Routes that only matched by ignoring trailing segments don't count.
  */
 export const findChainForSegments = (segments, chains) => {
     let match = null;
     let bestScore = 0;
+    let fullMatch = null;
+    let bestFullScore = 0;
+    let maxFullFixed = -1;
+    let wildcard = null;
     for (const chain of chains) {
         const matchedChain = matchesSegments(segments, chain);
         if (matchedChain !== null) {
@@ -180,9 +213,51 @@ export const findChainForSegments = (segments, chains) => {
                 bestScore = score;
                 match = matchedChain;
             }
+            if (chainEndsWithWildcard(matchedChain)) {
+                if (wildcard === null || winsWildcard(matchedChain, wildcard)) {
+                    wildcard = matchedChain;
+                }
+            }
+            else if (!isPartialMatch(segments, matchedChain)) {
+                if (score > bestFullScore) {
+                    bestFullScore = score;
+                    fullMatch = matchedChain;
+                }
+                maxFullFixed = Math.max(maxFullFixed, countFixedSegments(matchedChain));
+            }
         }
     }
-    return match;
+    // Without a wildcard to match the rest of the path, routes can still ignore trailing segments.
+    if (wildcard === null) {
+        return match;
+    }
+    // Compare fixed segments rather than priority, since nesting under default routes raises the priority
+    return countFixedSegments(wildcard) > maxFullFixed ? wildcard : fullMatch;
+};
+/** Returns whether the chain matched the path segments only by ignoring some trailing segments. */
+const isPartialMatch = (segments, chain) => {
+    const matched = chainToSegments(chain);
+    return matched !== null && matched.length < segments.filter((s) => s !== '').length;
+};
+const chainEndsWithWildcard = (chain) => {
+    return endsWithWildcard(chain[chain.length - 1].segments);
+};
+/** Returns whether the wildcard chain beats `best` by fixed segments, then by priority. */
+const winsWildcard = (chain, best) => {
+    const chainFixed = countFixedSegments(chain);
+    const bestFixed = countFixedSegments(best);
+    return chainFixed > bestFixed || (chainFixed === bestFixed && computePriority(chain) > computePriority(best));
+};
+const countFixedSegments = (chain) => {
+    let count = 0;
+    for (const route of chain) {
+        for (const segment of withoutWildcard(route.segments)) {
+            if (segment !== '' && segment[0] !== ':') {
+                count++;
+            }
+        }
+    }
+    return count;
 };
 /**
  * Computes the priority of a chain.
@@ -194,12 +269,14 @@ export const findChainForSegments = (segments, chains) => {
  * - /path/to/page
  *
  * The second one will be given a higher priority because "page" is a fixed segment (vs ":where", a parameter segment).
+ *
+ * A trailing wildcard is not counted.
  */
 export const computePriority = (chain) => {
     let score = 1;
     let level = 1;
     for (const route of chain) {
-        for (const segment of route.segments) {
+        for (const segment of withoutWildcard(route.segments)) {
             if (segment[0] === ':') {
                 score += Math.pow(1, level);
             }
@@ -221,4 +298,10 @@ export class RouterSegments {
         }
         return '';
     }
+    /** Consumes and returns the remaining non empty segments. */
+    rest() {
+        const rest = this.segments.filter((s) => s !== '');
+        this.segments = [];
+        return rest;
+    }
 }

package/dist/collection/components/router/utils/path.js

@@ -1,7 +1,7 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { ROUTER_INTENT_FORWARD } from "./constants";
+import { ROUTER_INTENT_FORWARD, WILDCARD_PARAM } from "./constants";
 /** Join the non empty segments with "/". */
 export const generatePath = (segments) => {
     const path = segments.filter((s) => s.length > 0).join('/');
@@ -34,12 +34,13 @@ export const writeSegments = (history, root, useHash, segments, direction, state
  *
  * Notes:
  * - parameter segments of the form :param are replaced with their value,
- * - null is returned when a value is missing for any parameter segment.
+ * - null is returned when a value is missing for any parameter segment,
+ * - a trailing wildcard is replaced with the path it matched.
  */
 export const chainToSegments = (chain) => {
     const segments = [];
     for (const route of chain) {
-        for (const segment of route.segments) {
+        for (const segment of withoutWildcard(route.segments)) {
             if (segment[0] === ':') {
                 const param = route.params && route.params[segment.slice(1)];
                 if (!param) {
@@ -51,9 +52,22 @@ export const chainToSegments = (chain) => {
                 segments.push(segment);
             }
         }
+        segments.push(...wildcardSegments(route));
     }
     return segments;
 };
+/** Only a `*` in the last segment of a route url is a wildcard. Elsewhere it's matched literally. */
+export const endsWithWildcard = (segments) => {
+    return segments[segments.length - 1] === '*';
+};
+/** Returns the path segments matched by the trailing wildcard of the route. */
+const wildcardSegments = (route) => {
+    const pathMatch = endsWithWildcard(route.segments) ? route.params?.[WILDCARD_PARAM] : undefined;
+    return pathMatch ? pathMatch.split('/').filter((s) => s.length > 0) : [];
+};
+export const withoutWildcard = (segments) => {
+    return endsWithWildcard(segments) ? segments.slice(0, -1) : segments;
+};
 /**
  * Removes the prefix segments from the path segments.
  *

package/dist/docs.json

@@ -1,5 +1,5 @@
 {
-  "timestamp": "2026-10-21T18:13:17",
+  "timestamp": "2026-10-30T18:14:29",
   "compiler": {
     "name": "@stencil/core",
     "version": "4.45.2",
@@ -14038,6 +14038,32 @@
           "getter": false,
           "setter": false
         },
+        {
+          "name": "errorText",
+          "type": "string | undefined",
+          "complexType": {
+            "original": "string",
+            "resolved": "string | undefined",
+            "references": {}
+          },
+          "mutable": false,
+          "attr": "error-text",
+          "reflectToAttr": false,
+          "docs": "Text that is placed under the input boxes and displayed when an error is detected.",
+          "docsTags": [],
+          "values": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "undefined"
+            }
+          ],
+          "optional": true,
+          "required": false,
+          "getter": false,
+          "setter": false
+        },
         {
           "name": "fill",
           "type": "\"outline\" | \"solid\" | undefined",
@@ -14075,6 +14101,64 @@
           "getter": false,
           "setter": false
         },
+        {
+          "name": "helperText",
+          "type": "string | undefined",
+          "complexType": {
+            "original": "string",
+            "resolved": "string | undefined",
+            "references": {}
+          },
+          "mutable": false,
+          "attr": "helper-text",
+          "reflectToAttr": false,
+          "docs": "Text that is placed under the input boxes and displayed when no error is detected.",
+          "docsTags": [],
+          "values": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "undefined"
+            }
+          ],
+          "optional": true,
+          "required": false,
+          "getter": false,
+          "setter": false
+        },
+        {
+          "name": "inputLabelFormatter",
+          "type": "((index: number, length: number) => string) | undefined",
+          "complexType": {
+            "original": "InputOtpLabelFormatter",
+            "resolved": "((index: number, length: number) => string) | undefined",
+            "references": {
+              "InputOtpLabelFormatter": {
+                "location": "import",
+                "path": "./input-otp-interface",
+                "id": "src/components/input-otp/input-otp-interface.ts::InputOtpLabelFormatter",
+                "referenceLocation": "InputOtpLabelFormatter"
+              }
+            }
+          },
+          "mutable": false,
+          "reflectToAttr": false,
+          "docs": "A callback used to format the accessible name of each input box. It\nreceives the 0-based `index` of the box and the total `length`. By default\nthe name is \"Input 1 of 4\", or \"PIN, 1 of 4\" with an `aria-label` of \"PIN\".\n\nSee https://ionicframework.com/docs/troubleshooting/runtime#accessing-this\nif you need to access `this` from within the callback.",
+          "docsTags": [],
+          "values": [
+            {
+              "type": "((index: number, length: number) => string)"
+            },
+            {
+              "type": "undefined"
+            }
+          ],
+          "optional": true,
+          "required": false,
+          "getter": false,
+          "setter": false
+        },
         {
           "name": "inputmode",
           "type": "\"decimal\" | \"email\" | \"none\" | \"numeric\" | \"search\" | \"tel\" | \"text\" | \"url\" | undefined",
@@ -27325,7 +27409,7 @@
           "mutable": false,
           "attr": "url",
           "reflectToAttr": false,
-          "docs": "Relative path that needs to match in order for this route to apply.\n\nAccepts paths similar to expressjs so that you can define parameters\nin the url /foo/:bar where bar would be available in incoming props.",
+          "docs": "Relative path that needs to match in order for this route to apply.\n\nAccepts paths similar to expressjs so that you can define parameters\nin the url /foo/:bar where bar would be available in incoming props.\n\nA url ending in `*`, such as `*` or `/admin/*`, matches any remaining path,\nincluding none, so `/admin/*` also matches `/admin`. It only wins over a\nroute that matches the whole path when it has more fixed segments, so\n`/admin/*` wins over `/:section/:id` but not over `/admin/:id`. It always\nwins over a route that matches by ignoring trailing segments, such as\n`/admin` for `/admin/users`. The matched path is passed in the `pathMatch`\nprop without a leading `/`. A `*` on a route with child routes is ignored.",
           "docsTags": [
             {
               "name": "default",
@@ -27389,7 +27473,7 @@
           "mutable": false,
           "attr": "from",
           "reflectToAttr": false,
-          "docs": "A redirect route, redirects \"from\" a URL \"to\" another URL. This property is that \"from\" URL.\nIt needs to be an exact match of the navigated URL in order to apply.\n\nThe path specified in this value is always an absolute path, even if the initial `/` slash\nis not specified.",
+          "docs": "A redirect route, redirects \"from\" a URL \"to\" another URL. This property is that \"from\" URL.\nIt needs to be an exact match of the navigated URL in order to apply, unless it contains a `*`.\nA `*` matches the rest of the path from that segment on, as long as the path has at least as\nmany segments as `from`, so `/admin/*` matches `/admin/posts` but not `/admin`.\n\nThe path specified in this value is always an absolute path, even if the initial `/` slash\nis not specified.",
           "docsTags": [],
           "values": [
             {
@@ -37770,6 +37854,11 @@
       "docstring": "Values are converted to strings when emitted which is\nwhy we do not have a `number` type here even though the\n`value` prop accepts a `number` type.",
       "path": "src/components/input/input-interface.ts"
     },
+    "src/components/input-otp/input-otp-interface.ts::InputOtpLabelFormatter": {
+      "declaration": "(index: number, length: number) => string",
+      "docstring": "",
+      "path": "src/components/input-otp/input-otp-interface.ts"
+    },
     "src/components/input-otp/input-otp-interface.ts::InputOtpInputEventDetail": {
       "declaration": "export interface InputOtpInputEventDetail {\n  value?: string | null;\n  event?: Event;\n}",
       "docstring": "Values are converted to strings when emitted which is\nwhy we do not have a `number` type here even though the\n`value` prop accepts a `number` type.",