material-plus-ui 1.3.0 → 1.4.0

package/dist/internal/i18n.d.ts

@@ -23,22 +23,32 @@
  * gets you a translation, `MPLocaleProvider` gets you one for the whole
  * application at once, and the prop gets you one for anything else.
  *
- * ## Why English is the only table in this file
+ * ## Where the words themselves are
  *
- * The other eighteen live under `src/locales/`, and nothing in the library
- * imports them. They used to be here, and being here is what made them cost
- * something: a component that says one word — `MPButton` says *Loading* — held a
- * static import chain down to a table of every string in every language, and a
- * bundler cannot drop data that something imports. Twenty kilobytes, on every
- * consumer, for a word.
+ * Not here. This file is the shape of the table, the registry a translation
+ * arrives through, and the merge — no strings.
  *
- * So the table arrives from the outside instead. `registerMPMessages` below is
- * how, `material-plus-ui/locales` is where from, and the only thing that changed
- * for a reader is that the application now names the languages it speaks. Once
- * it has, `locale="ko"` resolves through exactly the path it always did.
+ * The eighteen translations live under `src/locales/`, and nothing in the
+ * library imports them. They used to be here, and being here is what made them
+ * cost something: a component that says one word — `MPButton` says *Loading* —
+ * held a static import chain down to a table of every string in every language,
+ * and a bundler cannot drop data that something imports. Twenty kilobytes, on
+ * every consumer, for a word. So the table arrives from the outside instead:
+ * `registerMPMessages` below is how, `material-plus-ui/locales` is where from,
+ * and the only thing that changed for a reader is that the application now names
+ * the languages it speaks. Once it has, `locale="ko"` resolves through exactly
+ * the path it always did.
+ *
+ * English left too, for the same reason one step smaller. It is thirteen modules
+ * under `internal/messages/`, one per namespace, because a bundler that can drop
+ * a module it can also drop an export — and cannot drop a property. Held as one
+ * object, English was 1.75 kB that every component carried whole: `MPButton`
+ * shipped the calendar's eighteen strings to say *Loading*. `resolveNamespace`
+ * is handed the namespace it should merge, so a component pays for the words it
+ * speaks and no others.
  *
  * The public surface is `registerMPMessages`, `MPLocaleProvider` and the
- * per-component `labels` props; `resolveMessages` and `fillMessage` stay
+ * per-component `labels` props; `resolveNamespace` and `fillMessage` stay
  * internal.
  */
 /**
@@ -141,6 +151,101 @@ export interface MPMessages {
         start: string;
         end: string;
     };
+    /**
+     * MPNumberField.
+     *
+     * The two steppers, which are a plus and a minus and have no words of their
+     * own — the same case the pagination's chevrons and the chat's delivery marks
+     * are in. They are read out and never drawn.
+     */
+    numberField: {
+        increase: string;
+        decrease: string;
+    };
+    /**
+     * MPCarousel.
+     *
+     * Every string here is read out and never drawn: the strip is pictures, the
+     * arrows are chevrons and the marks under it are dots. `{index}` and
+     * `{total}` are filled in by `fillMessage`, and they are named rather than
+     * positional for the reason the pagination's are — a language that counts the
+     * total first is not a language this table can serve with an argument order.
+     */
+    carousel: {
+        /** The name of the `region` the strip is inside. */
+        label: string;
+        /** The two arrows. */
+        previous: string;
+        next: string;
+        /** One slide, and its own position mark. `Slide 2 of 5`. */
+        slide: string;
+    };
+    /**
+     * MPBreadcrumb.
+     *
+     * Both read out and never drawn: a trail's steps are the caller's words, and
+     * these are the two things around them that are not.
+     */
+    breadcrumb: {
+        /** The name of the `<nav>` the trail is inside. */
+        label: string;
+        /** The `…` that puts the folded middle back. */
+        expand: string;
+    };
+    /**
+     * MPCombobox.
+     *
+     * Both **drawn**, which is what makes them belong here rather than in a prop:
+     * a Korean page whose search box says *No matches* has answered in a language
+     * the reader did not ask a question in. `{label}` is the text they typed, and
+     * is filled in by `fillMessage`.
+     */
+    combobox: {
+        /** The line where the rows would be, when nothing matched. */
+        empty: string;
+        /** The row that offers what was typed as a value of its own. */
+        add: string;
+    };
+    /**
+     * MPTable.
+     *
+     * One string, drawn across the whole width where the rows would be. A table
+     * that says *No data* in the middle of a translated page is the one part of it
+     * that was not translated.
+     */
+    table: {
+        empty: string;
+    };
+    /**
+     * MPFilePicker.
+     *
+     * The line inside the box, and the largest piece of text this table holds. It
+     * is drawn, it is an instruction, and it is the whole of what the component
+     * tells a reader to do.
+     */
+    filePicker: {
+        prompt: string;
+    };
+    /**
+     * MPTextLink.
+     *
+     * The sentence after a link that takes over the window. Read out and never
+     * drawn — the arrow says it to a reader who can see it, and this says it to
+     * everybody else.
+     */
+    textLink: {
+        newTab: string;
+    };
+    /**
+     * MPOverlay.
+     *
+     * The name of a modal region that may hold nothing readable at all — a bare
+     * spinner, a `clear` sheet. Without it a screen reader announces the region as
+     * nothing, which is why the component defaults it rather than requiring it.
+     */
+    overlay: {
+        label: string;
+    };
     /** MPAlert. */
     alert: {
         /** The × in the corner, which has no text of its own. */
@@ -224,6 +329,108 @@ export interface MPMessages {
         /** The line above the button, saying why the content is covered. */
         notice: string;
     };
+    /**
+     * MPPageLayout, and the parts of a page it arranges.
+     *
+     * One namespace for the skeleton rather than one per component, for the reason
+     * the pickers share theirs: they are one vocabulary, written by whoever
+     * translates a page's chrome, and a caller who has translated the word for a
+     * sidebar has translated the button that opens it in the same breath.
+     */
+    layout: {
+        /**
+         * The link that jumps past the navigation, drawn only while it holds the
+         * focus.
+         *
+         * Drawn rather than only announced, which makes it one of the few strings
+         * here that a sighted keyboard reader actually sees — and the one it would
+         * be least forgivable to leave in English, because the readers it exists for
+         * are the ones who cannot skip it.
+         */
+        skipToContent: string;
+        /**
+         * What an `MPSidebar` is called when nothing named it.
+         *
+         * Read out and never drawn. Every `<aside>` needs a name and a page with two
+         * of them *must* have one each, or a screen reader offers two regions called
+         * "complementary" — which is exactly why this is a default rather than a
+         * required prop.
+         */
+        sidebar: string;
+        /** The hamburger, which is a drawing and has no word of its own. */
+        openSidebar: string;
+        /** The same button once the drawer is open. */
+        closeSidebar: string;
+        /** The handle on a resizable column's inner edge. */
+        resizeSidebar: string;
+    };
+    /**
+     * MPTransfer.
+     *
+     * Every string here is **drawn**, which is unusual in this table and is what
+     * makes the namespace necessary: the two headings, the filter's placeholder
+     * and the line an empty list shows are all read off the screen, and a Korean
+     * page with a column headed *Available* is a page the component broke.
+     *
+     * The two arrows are the exception and are read out rather than drawn, for the
+     * reason the pagination's steppers are.
+     */
+    transfer: {
+        /** The heading over the list of things that have not been chosen. */
+        source: string;
+        /** And over the list of things that have. */
+        target: string;
+        /** The arrow that sends the ticked rows across. */
+        toTarget: string;
+        /** And the one that brings them back. */
+        toSource: string;
+        /** The filter above each list. */
+        search: string;
+        /** What a list with nothing in it says. */
+        empty: string;
+    };
+    /**
+     * MPCommandPalette.
+     *
+     * Three strings, two of them drawn: a palette that says *Type a command or
+     * search…* to a Korean reader is a palette that has told them, in the first
+     * thing they see, that it is not for them.
+     */
+    command: {
+        /** The dialog's accessible name. It has no visible title to take one from. */
+        label: string;
+        /** The placeholder in the field. */
+        search: string;
+        /** The line where the rows would be, when nothing matched. */
+        empty: string;
+    };
+    /**
+     * MPColorPicker.
+     *
+     * The one control in the library whose parts have **nowhere to take a name
+     * from**: a saturation square, a hue rail and an opacity rail are three
+     * draggable rectangles, and without these they are three draggable rectangles
+     * to a screen reader too.
+     *
+     * `empty` is the exception and is drawn — it is what the trigger reads before
+     * a colour has been chosen.
+     */
+    colorPicker: {
+        /** The saturation/brightness square. */
+        area: string;
+        /** The hue rail beside it. */
+        hue: string;
+        /** The opacity rail, when `alpha` is on. */
+        alpha: string;
+        /** The field the value can be typed into. */
+        value: string;
+        /** The grid of ready-made colours. */
+        swatches: string;
+        /** The × that empties the control. */
+        clear: string;
+        /** What the trigger reads before anything has been chosen. */
+        empty: string;
+    };
 }
 /** A translation may fill in as much or as little of the table as it has. */
 export type MPPartialMessages = {
@@ -256,6 +463,25 @@ export interface MPLocale {
     /** The strings. Anything left out falls back to English, a namespace at a time. */
     messages: MPPartialMessages;
 }
+/**
+ * One namespace's English strings, carrying the name they answer to.
+ *
+ * The thirteen of them live in `internal/messages/`, one to a module, and a
+ * component imports the one it speaks. That is the whole reason this type
+ * exists: `resolveNamespace` below is handed the English table rather than
+ * looking it up, so the twelve tables a component does not use are twelve modules
+ * nothing imports.
+ *
+ * The name travels with the strings rather than beside them, so a call site is
+ * `useMPMessages(PICKER, locale)` and cannot name one namespace while passing
+ * another's words.
+ */
+export interface MPNamespace<Name extends keyof MPMessages> {
+    /** The key this namespace occupies in `MPMessages` and in a translation. */
+    readonly name: Name;
+    /** English, which every other language is merged over. */
+    readonly en: MPMessages[Name];
+}
 /**
  * Teaches the library a language.
  *
@@ -272,7 +498,7 @@ export interface MPLocale {
  */
 export declare function registerMPMessages(...locales: MPLocale[]): void;
 /**
- * The strings for a locale, merged over English.
+ * One namespace's strings for a locale, merged over English.
  *
  * `undefined` is English rather than the runtime's own locale, and that is
  * deliberate: `navigator.language` differs between the server that renders the
@@ -281,11 +507,16 @@ export declare function registerMPMessages(...locales: MPLocale[]): void;
  * at. A component that should follow the reader is *told* which language to
  * follow — by its own `locale` prop, or by an `MPLocaleProvider` above it.
  *
+ * A namespace at a time, so a language that has one and not another keeps
+ * English for the rest rather than losing both. That was already how the merge
+ * worked; what changed is that the namespaces are no longer merged all at once,
+ * because a component that reads one of them should not carry the other twelve.
+ *
  * Note that this is only about the words in the table. The dates themselves are
  * formatted by `Intl` against the same tag, and `Intl` speaks every language the
  * platform does whether or not there is an entry here.
  */
-export declare function resolveMessages(locale?: string): MPMessages;
+export declare function resolveNamespace<Name extends keyof MPMessages>(namespace: MPNamespace<Name>, locale?: string): MPMessages[Name];
 /**
  * A message with its placeholders filled in.
  *

package/dist/internal/i18n.js

@@ -1 +1 @@
-const e={common:{close:"Close",clear:"Clear",open:"Open",remove:"Remove",removeNamed:"Remove {label}",loading:"Loading"},textField:{showPassword:"Show the password",hidePassword:"Hide the password"},empty:{title:"Nothing here"},picker:{previousMonth:"Previous month",nextMonth:"Next month",previousYear:"Previous year",nextYear:"Next year",previousYears:"Previous years",nextYears:"Next years",chooseMonth:"Choose a month",chooseYear:"Choose a year",today:"Today",now:"Now",clear:"Clear",done:"Done",hour:"Hour",minute:"Minute",second:"Second",meridiem:"AM/PM",start:"Start",end:"End"},alert:{dismiss:"Dismiss"},chat:{sending:"Sending",sent:"Sent",delivered:"Delivered",read:"Read",failed:"Not sent",typing:"Typing"},spoiler:{reveal:"Reveal",hide:"Hide",notice:"Hidden so it is not read by accident"},pagination:{label:"Pagination",page:"Page {page}",status:"Page {page} of {total}",previous:"Previous page",next:"Next page",first:"First page",last:"Last page"},rating:{label:"Rating",value:"{value} out of {max}",empty:"Not rated"}},t=new Map;export function registerMPMessages(...a){for(const e of a){t.set(e.locale.toLowerCase(),e.messages);for(const o of e.aliases??[])t.set(o.toLowerCase(),e.messages)}o.clear(),o.set("",e)}const o=new Map([["",e]]);export function resolveMessages(a){const s=a?.trim()??"",n=o.get(s);if(n)return n;const r=function(e){const t=e.toLowerCase().split(/[-_]/).filter(Boolean),o=t[0];if(!o)return[];const a=t.slice(1),s=a.find(e=>/^[a-z]{4}$/.test(e)),n=a.find(e=>/^([a-z]{2}|\d{3})$/.test(e));return[s?`${o}-${s}`:"",n?`${o}-${n}`:"",o].filter(Boolean)}(s).map(e=>t.get(e)).find(Boolean),i=r?{common:{...e.common,...r.common},textField:{...e.textField,...r.textField},empty:{...e.empty,...r.empty},picker:{...e.picker,...r.picker},alert:{...e.alert,...r.alert},chat:{...e.chat,...r.chat},pagination:{...e.pagination,...r.pagination},rating:{...e.rating,...r.rating},spoiler:{...e.spoiler,...r.spoiler}}:e;return o.set(s,i),i}export function fillMessage(e,t){return e.replace(/\{(\w+)\}/g,(e,o)=>t[o]??e)}
+const e=new Map;export function registerMPMessages(...s){for(const t of s){e.set(t.locale.toLowerCase(),t.messages);for(const s of t.aliases??[])e.set(s.toLowerCase(),t.messages)}t.clear()}const t=new Map;export function resolveNamespace(s,n){const o=n?.trim()??"",r=`${s.name}\0${o}`,a=t.get(r);if(a)return a;const c=function(e){const t=e.toLowerCase().split(/[-_]/).filter(Boolean),s=t[0];if(!s)return[];const n=t.slice(1),o=n.find(e=>/^[a-z]{4}$/.test(e)),r=n.find(e=>/^([a-z]{2}|\d{3})$/.test(e));return[o?`${s}-${o}`:"",r?`${s}-${r}`:"",s].filter(Boolean)}(o).map(t=>e.get(t)).find(Boolean),i=c?.[s.name],f=i?{...s.en,...i}:s.en;return t.set(r,f),f}export function fillMessage(e,t){return e.replace(/\{(\w+)\}/g,(e,s)=>t[s]??e)}

package/dist/internal/keys.d.ts

@@ -0,0 +1,72 @@
+/**
+ * What keyboard the reader is on, and how a shortcut is spelled.
+ *
+ * Two components speak this vocabulary and they speak it in opposite
+ * directions: [MPShortcut](../components/shortcut/MPShortcut.tsx) *writes* a
+ * shortcut down, and [MPCommandPalette](../components/command-palette/MPCommandPalette.tsx)
+ * *reads* one off a real keyboard event. Both files already said that the two
+ * had to agree — "a shortcut a component displays and one it binds have to be
+ * spelled the same way, or the label on the screen is a claim nobody checked" —
+ * and both then answered the question separately.
+ *
+ * They disagreed. The palette tested `navigator.userAgent` alone, which is the
+ * one of the three sources a browser is most willing to freeze or lie about, so
+ * a page could draw `⌘K` and bind Ctrl+K. Written once, they cannot.
+ *
+ * Nothing here is exported from `src/index.ts`. It is the library talking to
+ * itself, in the sense `internal/` always means.
+ */
+/** The three real platforms a shortcut is spelled for. */
+export type MPResolvedOS = 'mac' | 'windows' | 'linux';
+/**
+ * What the browser says it is running on.
+ *
+ * `userAgentData.platform` is the modern spelling and `navigator.platform` the
+ * deprecated one that every browser still answers; the user agent string is the
+ * last resort. All three are matched at once because the question is coarse —
+ * which of three key caps to print — and getting it slightly wrong is a label,
+ * not a bug.
+ */
+export declare function detectOS(): MPResolvedOS;
+/**
+ * `useSyncExternalStore` rather than `useEffect` plus state, and rather than
+ * reading `navigator` during render.
+ *
+ * Reading it during render is a hydration mismatch waiting to happen: the server
+ * has no `navigator`, so it would render `Ctrl` and the client would render `⌘`
+ * into the same markup. This hook is the one API that tells React the two are
+ * *meant* to differ — it hydrates with the server's answer and re-renders with
+ * the browser's, which is exactly the sequence a Mac reader sees.
+ */
+export declare function useDetectedOS(): MPResolvedOS;
+/**
+ * Splits the string form. Empty segments are what `'Ctrl++'` leaves behind, and
+ * dropping them is why the array form exists for that case.
+ */
+export declare function tokenizeShortcut(keys: string | string[]): string[];
+/**
+ * Whether a keyboard event is the shortcut this string names.
+ *
+ * The same vocabulary `MPShortcut` draws, read rather than written — and the
+ * same tokenizer, so a shortcut that can be displayed is a shortcut that can be
+ * matched.
+ *
+ * ## `Mod` is a name for a key, not a fifth modifier
+ *
+ * It resolves to Command on a Mac and Control everywhere else, so `Mod+K` and
+ * `Ctrl+K` are the *same combination* on Windows — and the check has to say so.
+ * Tested as a modifier of its own, they contradicted each other: `Ctrl+K` on
+ * Windows held Control, `Mod` was not named, and "is Control down without Mod
+ * being asked for" answered no. `Ctrl+K` simply never matched anywhere except a
+ * Mac, on the component whose whole job is to answer a shortcut.
+ *
+ * So `Mod` is folded into whichever real key it stands for, and the four
+ * modifiers are then compared as themselves.
+ *
+ * Each is checked in **both** directions. A shortcut that fired with extra
+ * modifiers held would take a combination the page had given to something else.
+ *
+ * The platform is passed rather than sniffed, so a caller reads it through the
+ * same hook the label does and the two cannot end up on different answers.
+ */
+export declare function matchesShortcut(event: KeyboardEvent, shortcut: string | string[], os: MPResolvedOS): boolean;

package/dist/internal/keys.js

@@ -0,0 +1,2 @@
+"use client";
+import*as t from"react";export function detectOS(){if("undefined"==typeof navigator)return"windows";const t=navigator.userAgentData,e=`${t?.platform??""} ${navigator.platform??""} ${navigator.userAgent??""}`;return/mac|iphone|ipad|ipod/i.test(e)?"mac":/win/i.test(e)?"windows":"linux"}function e(){return()=>{}}function r(){return"windows"}export function useDetectedOS(){return t.useSyncExternalStore(e,detectOS,r)}export function tokenizeShortcut(t){return Array.isArray(t)?t.map(t=>t.trim()).filter(Boolean):t.split("+").map(t=>t.trim()).filter(Boolean)}export function matchesShortcut(t,e,r){const n=tokenizeShortcut(e).map(t=>t.toLowerCase()),o=n[n.length-1];if(void 0===o)return!1;const a=new Set(n.slice(0,-1)),i=a.has("mod"),s=a.has("ctrl")||i&&"mac"!==r,c=a.has("meta")||i&&"mac"===r;return s===t.ctrlKey&&c===t.metaKey&&(a.has("shift")===t.shiftKey&&a.has("alt")===t.altKey&&t.key.toLowerCase()===o)}

package/dist/internal/length.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A length, said the way this library says lengths.
+ *
+ * One rule, everywhere: **a number is CSS pixels and a string is already a CSS
+ * length.** Twelve components had written it out inline and four more had a
+ * private `toLength` of their own, which is sixteen copies of a sentence that is
+ * either true of the whole library or true of nothing.
+ *
+ * They all happened to agree. That is the argument for collecting them rather
+ * than against it — sixteen agreeing copies are sixteen chances for the
+ * seventeenth to be written slightly differently, and the difference would be a
+ * prop that quietly took a number to mean something else.
+ *
+ * Nothing here is exported from `src/index.ts`. It is the library talking to
+ * itself, in the sense `internal/` always means.
+ */
+/** A number is pixels; a string is whatever it says; nothing is nothing. */
+export declare function cssLength(value: number | string): string;
+export declare function cssLength(value: number | string | undefined | null): string | undefined;
+/**
+ * A CSS length string, in pixels, or `undefined` for one this cannot resolve.
+ *
+ * The two components that let a reader *drag* a size — `MPSidebar` and
+ * `MPPanes` — both have to turn a written bound into a number to clamp against,
+ * and both had the same regex and the same unit arithmetic. This is that,
+ * once.
+ *
+ * `undefined` rather than a fallback, so each caller decides what an
+ * unresolvable bound means. They do not agree, and should not: a pane with an
+ * unreadable `minSize` is a pane with no minimum, and a sidebar with an
+ * unreadable one still has a default to fall back to. A parser that picked for
+ * them would have to pick wrongly for one of them.
+ *
+ * ## What the units are measured against
+ *
+ * `%` is a share of `extent`, which is whatever the caller is dividing up — the
+ * split's own width, the window's. `rem` is the document's font size and `em` is
+ * `root`'s, which is the distinction that makes `em` worth accepting at all: a
+ * bound written in `em` is a bound in the *component's* text, and a component
+ * inside a scaled-down panel means something different by it than the page does.
+ */
+export declare function pixelsIn(value: string, extent?: number, root?: Element | null): number | undefined;

package/dist/internal/length.js

@@ -0,0 +1 @@
+export function cssLength(e){if(null!=e)return"number"==typeof e?`${e}px`:e}const e=/^\s*(-?[\d.]+)\s*(px|rem|em|%)\s*$/;export function pixelsIn(t,n,o){const r=e.exec(t);if(!r)return;const u=Number(r[1]);if(!Number.isNaN(u))switch(r[2]){case"px":return u;case"%":return void 0===n?void 0:n*u/100;case"rem":return"undefined"==typeof document?void 0:u*(Number.parseFloat(getComputedStyle(document.documentElement).fontSize)||16);default:return"undefined"!=typeof document&&o?u*(Number.parseFloat(getComputedStyle(o).fontSize)||16):void 0}}

package/dist/internal/link.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The two questions a component has to ask about a URL it did not write.
+ *
+ * Four components render an `<a>` whose `target` a caller can set, and three of
+ * them had worked out the same `rel` independently — which is three chances for
+ * the fourth to forget, and the fourth did. One of them also renders a URL that
+ * arrives from somewhere else entirely, which is a different question with a
+ * worse failure.
+ *
+ * Nothing here is exported from `src/index.ts`. It is the library talking to
+ * itself, in the sense `internal/` always means.
+ */
+/**
+ * The `rel` a link opening in a new tab needs, unless the caller named one.
+ *
+ * `target="_blank"` hands the opened page a `window.opener` back into this one
+ * unless it is told not to. Modern browsers imply `noopener` and older ones do
+ * not; `noreferrer` is never implied by anything, and is what stops the address
+ * of the page the reader was on travelling to wherever they just went.
+ *
+ * A caller's own `rel` **replaces** this rather than extending it, which is the
+ * bargain these components already documented: a row that also needs `nofollow`
+ * says `rel="noopener noreferrer nofollow"` and means it. The alternative —
+ * merging — is a component quietly adding tokens to an attribute the caller
+ * wrote out in full.
+ */
+export declare function linkRel(target: string | undefined, rel: string | undefined): string | undefined;
+/**
+ * A URL if it is one a reader can safely be sent to, and nothing if it is not.
+ *
+ * This is for the URLs that arrive from **somewhere else** — the link preview on
+ * a message somebody else sent — rather than for the ones an application writes
+ * into its own navigation. React renders a `javascript:` href with a development
+ * warning and no more, so on a page built out of user-generated content a
+ * hostile preview URL is a one-click script execution.
+ *
+ * A URL with no scheme at all is relative, and a relative URL cannot escalate to
+ * anything: it resolves against the page it is already on. Those pass.
+ *
+ * Rejected means `undefined`, so the element renders with no `href` — visibly
+ * not a link, rather than a link that quietly goes nowhere. Half-sanitising a
+ * URL into something that still navigates is how a filter becomes a bypass.
+ */
+export declare function safeHref(href: string | undefined): string | undefined;

package/dist/internal/link.js

@@ -0,0 +1 @@
+export function linkRel(e,t){return void 0!==t?t:"_blank"===e?"noopener noreferrer":void 0}const e=/[\u0000-\u0020\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]/g,t=/^([a-z][a-z0-9+.-]*):/i,u=new Set(["http:","https:","mailto:","tel:"]);export function safeHref(r){if(!r)return;const n=t.exec(r.replace(e,""));return n?u.has(`${n[1].toLowerCase()}:`)?r:void 0:r}

package/dist/internal/locale.d.ts

@@ -12,14 +12,14 @@
  *
  * There is deliberately no third source. `navigator.language` is *not* consulted
  * as a fallback, and that is not an oversight — see the note on
- * `resolveMessages` in `internal/i18n.ts`. The runtime's own locale differs
+ * `resolveNamespace` in `internal/i18n.ts`. The runtime's own locale differs
  * between the server that renders the markup and the browser that hydrates it,
  * so reading it would put a hydration mismatch in the one part of the page a
  * reader is looking at. `undefined` therefore means "the platform's default",
  * which `Intl` resolves consistently in both places.
  */
 import * as React from 'react';
-import { type MPMessages } from './i18n';
+import { type MPMessages, type MPNamespace } from './i18n.js';
 /**
  * `undefined` rather than `'en'`, and the distinction matters.
  *
@@ -39,5 +39,29 @@ export declare function useMPLocale(locale?: string): string | undefined;
  * what makes an unsupported language a partial answer rather than a dead end: a
  * caller supplies the handful of words they care about and everything else is
  * still translated, or still English, rather than blank.
+ *
+ * The namespace is passed as the object from `internal/messages/`, not as its
+ * name: it carries English with it, which is what lets a component that says one
+ * word leave the other twelve namespaces out of the bundle entirely. The objects
+ * are module constants, so the identity `useMemo` compares is stable.
+ *
+ * ## Why the overrides are keyed on what they say
+ *
+ * Because of how they are written. `labels={{ clear: 'Leeren' }}` is an object
+ * literal in JSX, which is a *new object every render* — so keyed on identity
+ * the memo missed every single time, and every component with a `labels` prop
+ * rebuilt its merged table on every render of its parent.
+ *
+ * That was not expensive on its own; what made it worth fixing is what the table
+ * is used for. It is handed straight back out of this hook, so a fresh object
+ * per render is a fresh prop for everything downstream — and the calendar keeps
+ * `labels` in a `useMemo` dependency of its own, where a new object per render
+ * of the page above meant re-deriving a month's worth of `Intl` names for a
+ * table that had not changed a word.
+ *
+ * `internal/Picker.ts` keys its display samples on `JSON.stringify` for exactly
+ * this reason, with the same trade written out there: two objects whose keys are
+ * in a different order read as two tables. That costs one extra miss and never a
+ * wrong answer.
  */
-export declare function useMPMessages<Namespace extends keyof MPMessages>(namespace: Namespace, locale: string | undefined, overrides?: Partial<MPMessages[Namespace]>): MPMessages[Namespace];
+export declare function useMPMessages<Name extends keyof MPMessages>(namespace: MPNamespace<Name>, locale: string | undefined, overrides?: Partial<MPMessages[Name]>): MPMessages[Name];

package/dist/internal/locale.js

@@ -1 +1,2 @@
-import*as e from"react";import{resolveMessages as t}from"./i18n";export const MPLocaleContext=/*@__PURE__*/e.createContext(void 0);export function useMPLocale(t){const o=e.useContext(MPLocaleContext);return t??o}export function useMPMessages(o,n,r){return e.useMemo(()=>{const e=t(n)[o];return r?{...e,...r}:e},[o,n,r])}
+"use client";
+import*as t from"react";import{resolveNamespace as e}from"./i18n.js";export const MPLocaleContext=/*@__PURE__*/t.createContext(void 0);export function useMPLocale(e){const o=t.useContext(MPLocaleContext);return e??o}export function useMPMessages(o,n,r){const s=void 0===r?"":JSON.stringify(r);return t.useMemo(()=>{const t=e(o,n);return r?{...t,...r}:t},[o,n,s])}

package/dist/internal/menu.d.ts

@@ -15,7 +15,7 @@
  * every row from having to answer "what if there is no menu".
  */
 import * as React from 'react';
-import type { MPColor, MPSize } from '../types';
+import type { MPColor, MPSize } from '../types.js';
 export interface MPMenuContextValue {
     size: MPSize;
     color: MPColor;

package/dist/internal/menu.js

@@ -1 +1,2 @@
+"use client";
 import*as t from"react";export const MPMenuContext=/*@__PURE__*/t.createContext({size:"md",color:"primary"});

package/dist/internal/messages/alert.d.ts

@@ -0,0 +1,3 @@
+import type { MPNamespace } from '../i18n.js';
+/** `MPAlert`'s dismiss button — see `MPMessages['alert']`. */
+export declare const ALERT: MPNamespace<'alert'>;

package/dist/internal/messages/alert.js

@@ -0,0 +1 @@
+export const ALERT={name:"alert",en:{dismiss:"Dismiss"}};

package/dist/internal/messages/breadcrumb.d.ts

@@ -0,0 +1,3 @@
+import type { MPNamespace } from '../i18n.js';
+/** `MPBreadcrumb`'s two names — see `MPMessages['breadcrumb']`. */
+export declare const BREADCRUMB: MPNamespace<'breadcrumb'>;

package/dist/internal/messages/breadcrumb.js

@@ -0,0 +1 @@
+export const BREADCRUMB={name:"breadcrumb",en:{label:"Breadcrumb",expand:"Show hidden steps"}};

package/dist/internal/messages/carousel.d.ts

@@ -0,0 +1,3 @@
+import type { MPNamespace } from '../i18n.js';
+/** `MPCarousel`'s own names — see `MPMessages['carousel']`. */
+export declare const CAROUSEL: MPNamespace<'carousel'>;

package/dist/internal/messages/carousel.js

@@ -0,0 +1 @@
+export const CAROUSEL={name:"carousel",en:{label:"Carousel",previous:"Previous slide",next:"Next slide",slide:"Slide {index} of {total}"}};

package/dist/internal/messages/chat.d.ts

@@ -0,0 +1,3 @@
+import type { MPNamespace } from '../i18n.js';
+/** `MPChatBubble`'s delivery states — see `MPMessages['chat']`. */
+export declare const CHAT: MPNamespace<'chat'>;

package/dist/internal/messages/chat.js

@@ -0,0 +1 @@
+export const CHAT={name:"chat",en:{sending:"Sending",sent:"Sent",delivered:"Delivered",read:"Read",failed:"Not sent",typing:"Typing"}};

package/dist/internal/messages/color-picker.d.ts

@@ -0,0 +1,3 @@
+import type { MPNamespace } from '../i18n.js';
+/** The names for the parts of the picker that have no text on them. */
+export declare const COLOR_PICKER: MPNamespace<'colorPicker'>;

package/dist/internal/messages/color-picker.js

@@ -0,0 +1 @@
+export const COLOR_PICKER={name:"colorPicker",en:{area:"Saturation and brightness",hue:"Hue",alpha:"Opacity",value:"Colour value",swatches:"Swatches",clear:"Clear",empty:"No colour"}};

package/dist/internal/messages/combobox.d.ts

@@ -0,0 +1,3 @@
+import type { MPNamespace } from '../i18n.js';
+/** `MPCombobox`'s two drawn lines — see `MPMessages['combobox']`. */
+export declare const COMBOBOX: MPNamespace<'combobox'>;

package/dist/internal/messages/combobox.js

@@ -0,0 +1 @@
+export const COMBOBOX={name:"combobox",en:{empty:"No matches",add:"Add “{label}”"}};

package/dist/internal/messages/command.d.ts

@@ -0,0 +1,3 @@
+import type { MPNamespace } from '../i18n.js';
+/** `MPCommandPalette`'s three strings — see `MPMessages['command']`. */
+export declare const COMMAND: MPNamespace<'command'>;

package/dist/internal/messages/command.js

@@ -0,0 +1 @@
+export const COMMAND={name:"command",en:{label:"Command palette",search:"Type a command or search…",empty:"No commands found"}};

package/dist/internal/messages/common.d.ts

@@ -0,0 +1,3 @@
+import type { MPNamespace } from '../i18n.js';
+/** The words that are not any one component's — see `MPMessages['common']`. */
+export declare const COMMON: MPNamespace<'common'>;

package/dist/internal/messages/common.js

@@ -0,0 +1 @@
+export const COMMON={name:"common",en:{close:"Close",clear:"Clear",open:"Open",remove:"Remove",removeNamed:"Remove {label}",loading:"Loading"}};

package/dist/internal/messages/empty.d.ts

@@ -0,0 +1,3 @@
+import type { MPNamespace } from '../i18n.js';
+/** `MPEmpty`'s heading — see `MPMessages['empty']`. */
+export declare const EMPTY: MPNamespace<'empty'>;

package/dist/internal/messages/empty.js

@@ -0,0 +1 @@
+export const EMPTY={name:"empty",en:{title:"Nothing here"}};

package/dist/internal/messages/file-picker.d.ts

@@ -0,0 +1,3 @@
+import type { MPNamespace } from '../i18n.js';
+/** `MPFilePicker`'s prompt — see `MPMessages['filePicker']`. */
+export declare const FILE_PICKER: MPNamespace<'filePicker'>;