material-plus-ui 1.3.1 → 1.4.0

package/dist/internal/i18n.d.ts

@@ -39,7 +39,7 @@
  * 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 nine modules
+ * 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`
@@ -151,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. */
@@ -234,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 = {
@@ -269,10 +466,10 @@ export interface MPLocale {
 /**
  * One namespace's English strings, carrying the name they answer to.
  *
- * The nine of them live in `internal/messages/`, one to a module, and a
+ * 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 eight tables a component does not use are eight modules
+ * 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
@@ -313,7 +510,7 @@ export declare function registerMPMessages(...locales: MPLocale[]): void;
  * 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 eight.
+ * 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

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

@@ -42,7 +42,26 @@ export declare function useMPLocale(locale?: string): string | undefined;
  *
  * 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 eight namespaces out of the bundle entirely. The objects
+ * 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<Name extends keyof MPMessages>(namespace: MPNamespace<Name>, locale: string | undefined, overrides?: Partial<MPMessages[Name]>): MPMessages[Name];

package/dist/internal/locale.js

@@ -1,2 +1,2 @@
 "use client";
-import*as e from"react";import{resolveNamespace as t}from"./i18n.js";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(o,n);return r?{...e,...r}:e},[o,n,r])}
+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/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/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/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'>;

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

@@ -0,0 +1 @@
+export const FILE_PICKER={name:"filePicker",en:{prompt:"Drop files here, or click to browse"}};

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

@@ -0,0 +1,3 @@
+import type { MPNamespace } from '../i18n.js';
+/** The words a page's skeleton says on its own behalf — see `MPMessages['layout']`. */
+export declare const LAYOUT: MPNamespace<'layout'>;

package/dist/internal/messages/layout.js

@@ -0,0 +1 @@
+export const LAYOUT={name:"layout",en:{skipToContent:"Skip to content",sidebar:"Sidebar",openSidebar:"Open sidebar",closeSidebar:"Close sidebar",resizeSidebar:"Resize sidebar"}};

package/dist/internal/messages/number-field.d.ts

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

package/dist/internal/messages/number-field.js

@@ -0,0 +1 @@
+export const NUMBER_FIELD={name:"numberField",en:{increase:"Increase",decrease:"Decrease"}};

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

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

package/dist/internal/messages/overlay.js

@@ -0,0 +1 @@
+export const OVERLAY={name:"overlay",en:{label:"Overlay"}};

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

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

package/dist/internal/messages/table.js

@@ -0,0 +1 @@
+export const TABLE={name:"table",en:{empty:"No data"}};

package/dist/internal/messages/text-link.d.ts

@@ -0,0 +1,3 @@
+import type { MPNamespace } from '../i18n.js';
+/** `MPTextLink`'s spoken warning — see `MPMessages['textLink']`. */
+export declare const TEXT_LINK: MPNamespace<'textLink'>;

package/dist/internal/messages/text-link.js

@@ -0,0 +1 @@
+export const TEXT_LINK={name:"textLink",en:{newTab:"Opens in a new tab"}};

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

@@ -0,0 +1,3 @@
+import type { MPNamespace } from '../i18n.js';
+/** `MPTransfer`'s two headings and its arrows — see `MPMessages['transfer']`. */
+export declare const TRANSFER: MPNamespace<'transfer'>;

package/dist/internal/messages/transfer.js

@@ -0,0 +1 @@
+export const TRANSFER={name:"transfer",en:{source:"Available",target:"Selected",toTarget:"Move to selected",toSource:"Move to available",search:"Search",empty:"Nothing here"}};