@nibapp/ui 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Changelog
+
+Every change to Nib UI (`@nibapp/ui`) that you can see or build against. The kit follows semantic
+versioning. Before 1.0 a minor version may break, and its entry says how to move. Entries and components
+marked preview may still change.
+
+## 0.1.0 — 2026-11-05
+
+The first release.
+
+- **Requirements.** React 19 and Tailwind CSS 4, which your app brings as peer dependencies. Browsers that
+  support `light-dark()` and OKLCH colours.
+- **Server rendering.** Every module that needs the browser starts with `"use client"`, so an app on React
+  Server Components imports the kit from its server components. The formatters, `cn` and the strings have no
+  directive and run on the server too.
+- **Foundations.** The tokens as CSS: OKLCH ramps and semantic tokens, type, radii, elevation and motion.
+  Two themes, Paper (light) and Graphite (dark), which any part of a page can switch with `data-theme`. The
+  motion presets and `MotionProvider`; an animated component loads its animation code the first time one
+  renders and needs no provider. Self-hosted fonts: Inter, Source Serif 4 and Geist Mono.
+- **Components.** Actions, inputs, overlays, navigation, feedback, data and code, on Base UI, each with a
+  live example in both themes at https://ui.nib.gg. Preview: DiffView, Markdown, DataTable, BlockStack,
+  CommandPalette and CodeBlock.
+- **Keyboard and overlays.** Off a Mac, Ctrl+K pressed in the CommandPalette reaches your toggle, so it closes
+  the palette, or opens it while it's closing; Ctrl+J, Ctrl+K, Ctrl+N and Ctrl+P don't move its list, and the
+  arrow keys, Home and End do. A closing backdrop (Dialog, AlertDialog, CommandPalette, ImageViewer and Sheet)
+  lets clicks through to the page while it fades. ThemeProvider pauses transitions only while a theme swaps,
+  under React's Strict Mode too, with or without `themeInitScript`.
+- **Words.** The kit's own words in English, and in Russian from `@nibapp/ui/locales/ru`. Formatting takes
+  any BCP 47 tag, and layout follows the provider's writing direction. There is no right-to-left
+  language's table yet.
+- **Utilities.** Keys and shortcuts, number and money formatting, grapheme-aware text, unified diffs, tree
+  keys, ANSI text and URLs, and the clock every countdown reads. Preview: `@nibapp/ui/path`,
+  `@nibapp/ui/keyed` and `@nibapp/ui/shiki`.
+- **Licence.** The code is under the MIT licence. Nib™ and Nib UI™, the Nib logo, wordmark, app icon and
+  mascot are trade marks of Wex Labs Limited and aren't in the package: see TRADEMARKS.md.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wex Labs Limited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,125 @@
-# Temporary Holding Version
+# Nib UI
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Nib UI is the design system of Nib, by Wex Labs Limited.
+
+`@nibapp/ui` is the tokens as CSS, two themes (Paper, light, and Graphite, dark), motion, and accessible
+components on Base UI, with the kit's own words in English and Russian. The docs, with every component
+live in both themes, are at https://ui.nib.gg.
+
+## Use it in an app
+
+```css
+/* app.css */
+@import "tailwindcss";
+@import "@nibapp/ui/styles.css";
+```
+
+```tsx
+import "@nibapp/ui/fonts.css";
+import "./app.css";
+import { MotionProvider, ThemeProvider, TooltipProvider, themeInitScript } from "@nibapp/ui";
+import { Toaster } from "@nibapp/ui/components/toast";
+
+// In <head>: <script dangerouslySetInnerHTML={{ __html: themeInitScript() }} /> (no theme flash)
+export function Root({ children }: { children: React.ReactNode }) {
+  return (
+    <ThemeProvider>
+      <MotionProvider>
+        <TooltipProvider>
+          {children}
+          <Toaster />
+        </TooltipProvider>
+      </MotionProvider>
+    </ThemeProvider>
+  );
+}
+```
+
+The package ships TypeScript source (no build step); Vite/TanStack Start consume it directly, Next.js
+needs `transpilePackages: ["@nibapp/ui"]`. The stylesheet's `@source` makes Tailwind scan this package
+wherever it lives. Import components by their own entry point (`@nibapp/ui/components/button`); the
+root barrel is there for convenience.
+
+## Entry points
+
+Entries marked preview may still change before 1.0.
+
+| import | contents |
+|---|---|
+| `@nibapp/ui` | everything below as a barrel, and the root-only `ClockProvider` / `useNow` / `useCountdown` / `createManualClock` (the one clock every countdown and relative time reads), `useFilePicker`, and `ThemeScope` (a part of the page in one theme, its popups included: they mount inside it, `usePortalContainer`) |
+| `@nibapp/ui/components/<name>` | one component family, e.g. `button`, `dialog`, `command-palette`, `markdown` |
+| `@nibapp/ui/keys` | the key machinery the kit's components use, by keys only: `matchesShortcut()` and `shortcutKeys()` (a key event as the keys a chord names, on any layout), `ariaKeyShortcuts()` / `keyShortcutsProps()` for controls, `isComposing()` (the IME guard every Enter handler uses), `isMacPlatform()`. Without a `ShortcutProvider`, tooltips and menus know only the kit's own actions (`KIT_SHORTCUTS`) |
+| `@nibapp/ui/keycaps` | keys as text with no React and no DOM, the platform passed in: `keyGlyph` (`mod` → ⌘ or Ctrl), `shortcutText` (a chord as plain text), `acceleratorKeys` (a desktop accelerator such as "CommandOrControl+Shift+Space" as logical keys) |
+| `@nibapp/ui/number-format` | `createNumberFormatters(locale, currency)`, `formatCount` and `formatMoney` ("58.7k", "$0.21" in en-GB; "58,7 тыс.", "0,21 $" in ru), `parseAmount`: the one count/money formatter; the locale is required, and a plain number needs the currency it's in (`Money` carries its own) |
+| `@nibapp/ui/i18n` | `UiI18nProvider`, `useUiStrings`, `useUiLocale`, `useFormatters`, `EN_UI_STRINGS` / `UiStrings` (the kit's words), `plural`, `richText` — see [Localization](#localization) |
+| `@nibapp/ui/locales/ru` | `RU_UI_STRINGS`: the kit's words in Russian, a complete `UiStrings`; for writing a Russian table, `ru()` (the plural form), `NBSP` and the formatter words `RU_TIME` and `RU_MONEY` |
+| `@nibapp/ui/i18n/format`, `@nibapp/ui/i18n/plural`, `@nibapp/ui/i18n/strings`, `@nibapp/ui/i18n/time-zones` | the same i18n, one module each and no React: `createFormatters` / `englishFormatters`, `plural`, `EN_UI_STRINGS` / `UiStrings`, the time-zone helpers — for code outside a React tree (a CLI, an extension host) |
+| `@nibapp/ui/ansi` | `parseAnsi` (ANSI SGR → styled segments, never HTML), `stripAnsi`, `ansiStyleToCss`, `ansiColorToCss` |
+| `@nibapp/ui/path` | preview: `splitPath`, `basename`, `dirname`, `joinPath`, `normalizePath`, `pathUnder`, `isAbsolutePath` for paths from any machine (either separator kept) |
+| `@nibapp/ui/keyed` | preview: `keyed(items, keyOf)`, stable React keys for a list without ids |
+| `@nibapp/ui/shiki` | preview, like CodeBlock: the shared lazy Shiki highlighter (`loadLanguage`, `tokenize`, `languageForPath`, `StreamingTokenizer`, …) |
+| `@nibapp/ui/motion` | `spring`, `tween`, `ease`, `duration`, `fade` / `rise` / `pop` / `stagger` |
+| `@nibapp/ui/motion-provider`, `@nibapp/ui/cn`, `@nibapp/ui/clock`, `@nibapp/ui/theme` | what the root also exports, one module each: `MotionProvider`; `cn` / `tv`; `ClockProvider`, `useNow`, `useCountdown`, `createManualClock`; `ThemeProvider`, `useTheme`, `themeInitScript`, `useResolvedTheme` |
+| `@nibapp/ui/styles.css`, `@nibapp/ui/fonts.css` | Tailwind theme + base layer, self-hosted fonts (Inter, Source Serif 4 and Geist Mono, OFL-1.1) |
+| `@nibapp/ui/styles/tokens.css`, `@nibapp/ui/styles/base.css`, `@nibapp/ui/styles/code.css` | the generated token variables, the base layer and the code highlighting alone, for a host that builds its own stylesheet |
+| `@nibapp/ui/text` | `truncateText` and other text helpers that count graphemes (`Intl.Segmenter`) |
+| `@nibapp/ui/patch` | unified diffs, read one way everywhere (CRLF, ``, C-quoted paths, renames, new and deleted files): `splitPatch` (a patch's files with path, change and `+`/`-` counts), `parseHunks`, `patchStats`, `lineText`, `isUnifiedDiff`, `unquoteGitPath`, `normalizePatch`; `buildFilePatch` and `newFilePatch` write one; `getDiffStats` and `getHunkExcerpt` read a parsed `@pierre/diffs` diff |
+| `@nibapp/ui/direction` | `useInlineSign()`: +1 left to right, -1 right to left, for horizontal motion and keys |
+| `@nibapp/ui/tree-keys` | `useTreeKeys()`: the WAI-ARIA tree's keys for any tree (arrows in the reading direction, Home/End, parent and child, `*`, locale-aware type-ahead), with the pure `treeKeyMove` and `treeTypeAhead` |
+| `@nibapp/ui/use-latest` | `useLatest(value)`: a ref holding the last committed value, for effects and stable callbacks |
+| `@nibapp/ui/use-hydrated` | `useHydrated()`: false on the server and while hydrating, so a client-only difference doesn't break the first render |
+| `@nibapp/ui/url` | `urlHost` (a URL's host, or undefined), `exactHostOf` (the host as it is, `www.` kept, for what a site may do), `hostOf` (the site as people say it), `webUrl` (a remote party's link when it's http(s), else undefined) |
+| `@nibapp/ui/image-size` | `imageSize(bytes)` and `base64ImageSize(base64)`: an image's own size in pixels, from its file header |
+| `@nibapp/ui/search`, `@nibapp/ui/clipboard` | search terms and normalization; copy to the clipboard through the host |
+| `@nibapp/ui/vite-deps` | `KIT_PREBUNDLE`: the kit's own dependencies a host's Vite dev server pre-bundles (`optimizeDeps.include`) |
+
+## Localization
+
+The kit's components render English with "en-GB" formatting, left to right, until a host wraps them
+in `UiI18nProvider`. The provider takes any BCP 47 tag as it is, the kit's words in that language, the
+currency a plain number is money in, the time zone and the writing direction:
+
+```tsx
+import { UiI18nProvider } from "@nibapp/ui/i18n";
+import { RU_UI_STRINGS } from "@nibapp/ui/locales/ru";
+
+<UiI18nProvider locale="ru-RU" strings={RU_UI_STRINGS} currency="EUR" timeZone={zone}>
+  {children}
+</UiI18nProvider>;
+```
+
+- **Strings.** `EN_UI_STRINGS` (type `UiStrings`, deep-readonly) holds every word the kit's components
+  show, aria-labels and tooltips included, namespaced per component in camelCase (`combobox.empty`,
+  `diffView.*`) plus the shared formatter words (`time.*`, `money.*`). `RU_UI_STRINGS` is the same table
+  in Russian, typed complete. Another language is a table typed as `UiStrings`.
+- **Parameters.** Anything parameterised is a function of ONE params object —
+  `(p: { count: number }) => string`. Plurals use
+  `plural(locale, n, { one, few, many, other })` (CLDR via `Intl.PluralRules`, `#` = the number), which
+  also serves hand-written tables: `plural("ru", 5, { one: "# файл", few: "# файла", many: "# файлов", other: "# файла" })`.
+  Components put elements (a `<Money>`, a `<code>`) into string messages with `richText(message, params)`.
+- **Formatting.** `useFormatters()` gives `count`, `money`, `wholeMoney`, `exactMoney`, `moneyRange`,
+  `unitPrice`, `currencySymbol`, `number`, `percent`, `bytes`, `memory`, `duration`, `elapsed` (a live
+  counter), `span`, `future` and `past` (a relative time as a phrase), `relativeTime` (a column label),
+  `shortDate`, `clockTime` and `spokenMoney` in the provider's locale. `Money` is shown in its own
+  currency; a plain number in the provider's `currency`, and without one showing it fails (the kit
+  never assumes a currency). Every language, English included, formats through `Intl` ("58.7k" and
+  "$1,204" in en-GB, "58,7 тыс." and "12,30 $" in ru) with exactly the tag the app passed
+  (`useUiLocale()` returns it unchanged). Nothing locale-bound is shared between locales (one SSR
+  process may render several): the provider keeps one set of formatters per locale, and the text
+  helpers keep each `Intl` object keyed by its locale.
+- **Writing direction.** The provider gives Base UI its `direction`, so arrow keys, sliders and popup
+  sides follow it. Layout uses logical classes (`ps-*`, `start-*`, `text-end`), sheets open from `start`
+  or `end`, `EdgeResizer` sits on a `start` or `end` edge, and horizontal motion multiplies its offset by
+  `useInlineSign()`.
+- **Props win.** A label passed as a prop (`placeholder`, `title`, `label`, …) always beats the table.
+
+## Feedback
+
+Pull requests aren't accepted yet, and there's no public issue tracker before the public launch. To report
+a problem or ask for help, use the support page: https://nib.gg/support.
+
+## Licence and trade marks
+
+The code is under the MIT licence: see [LICENSE](./LICENSE). The licence covers the code only. Nib™ and
+Nib UI™, the Nib logo, wordmark, app icon and mascot are trade marks of Wex Labs Limited and aren't in
+this package: see [TRADEMARKS.md](./TRADEMARKS.md) and the policy at https://nib.gg/legal/trademarks.

package/TRADEMARKS.md

@@ -0,0 +1,22 @@
+# Trade marks
+
+Nib UI's code is licensed under the MIT licence (see LICENSE). The licence covers the code only. It
+doesn't give you any right to use Wex Labs Limited's names, logos or other brand assets.
+
+**Our marks.** Nib™ and Nib UI™ are trade marks of Wex Labs Limited, as are the Nib logo, the Nib
+wordmark, the Nib app icon and Nib the mascot. None of them is included in this package.
+
+**You can, without asking:**
+- say in plain text that your project uses Nib UI or `@nibapp/ui`, for example "Built with Nib UI";
+- list `@nibapp/ui` as a dependency;
+- link to Nib's website and docs.
+
+**Please don't:**
+- use "Nib", or a name confusingly similar to it, in the name of your product, company, app, domain or
+  package (for example `nib-ui-pro` or `@acme/nib-ui`);
+- use our logo, wordmark, app icon or mascot;
+- suggest that Wex Labs Limited made, endorses, sponsors or partners with your project;
+- present a modified version of the kit as Nib UI. If you fork it, give the fork its own name. You may
+  say in plain text that it's "based on Nib UI".
+
+The full policy is at https://nib.gg/legal/trademarks. Questions and reports: legal@nib.gg.

package/dist/_bundled/money/index.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Money, in code: an integer count of micro-units (millionths of the currency's major unit, because
+ * usage costs are fractions of a cent) and its ISO 4217 currency. Never a float, so sums and
+ * comparisons are exact. Arithmetic rounds half to even at the micro; people see amounts through
+ * `formatMoney` and `moneyFormat` (`Intl.NumberFormat` with their locale and the amount's currency),
+ * so no code assumes a currency, a symbol or a number format. A host's wire schemas may hold this same
+ * shape.
+ */
+/** Micro-units in one major unit of any currency: 1 USD is 1 000 000 micros. */
+export declare const MICROS_PER_UNIT = 1000000;
+/** An ISO 4217 currency code (`USD`, `EUR`, `JPY`). */
+export type CurrencyCode = string;
+/** An amount: `micros` of `currency`, negative for a refund or a credit. */
+export type Money = {
+    micros: number;
+    currency: CurrencyCode;
+};
+/**
+ * Where a host registers the amounts a person may see as they are, when some may not, by declaration
+ * merging on this module (`interface MoneyRegister { readonly showable: MyShowableMoney }`): every
+ * formatter below then refuses any other amount at compile time. Without a registration, any `Money` is
+ * showable.
+ */
+export interface MoneyRegister {
+}
+/** Money a person may see as it is: the host's registered type (`MoneyRegister`), else any `Money`. */
+export type ShowableMoney = MoneyRegister extends {
+    readonly showable: infer Showable extends Money;
+} ? Showable : Money;
+/** Two amounts in different currencies were added, subtracted or compared. */
+export declare class CurrencyMismatchError extends Error {
+    readonly left: CurrencyCode;
+    readonly right: CurrencyCode;
+    constructor(left: CurrencyCode, right: CurrencyCode);
+}
+export declare function money(micros: number, currency: CurrencyCode): Money;
+/**
+ * A decimal amount in major units (`"12.34"`, `"-0.000001"`, `"1e-3"`), exactly. More than six
+ * decimal places is refused: say how to round with `moneyFromUnits` instead.
+ */
+export declare function parseMoney(amount: string, currency: CurrencyCode): Money;
+/**
+ * A number in major units (a stored double, a price read from a provider), rounded half to even at
+ * the micro. The number's shortest decimal form is what's rounded, so `0.1` is exactly 100 000 micros.
+ */
+export declare function moneyFromUnits(units: number, currency: CurrencyCode): Money;
+/**
+ * The amount as a number of major units, the nearest double to the exact decimal, for a reader that
+ * still takes a number: a slider, totals, an export's cost field, a number formatter.
+ */
+export declare function moneyToUnits(amount: ShowableMoney): number;
+/**
+ * Any amount as a number of major units, for accounting that takes plain numbers: a chart's scale,
+ * a sort, metrics, an external format. Never for what a person reads.
+ */
+export declare function accountingUnits(amount: Money): number;
+/** The amount in major units as an exact decimal (`"12.34"`, `"-0.000001"`, `"0"`). */
+export declare function moneyToDecimal(amount: ShowableMoney): `${number}`;
+/**
+ * An amount in text a program reads (tool results, diagnostics): the exact decimal and its currency
+ * code, `0.012345 USD`. People see amounts through `formatMoney` in their locale, never this.
+ */
+export declare function moneyText(amount: ShowableMoney): string;
+export declare function addMoney(left: Money, right: Money): Money;
+export declare function subtractMoney(left: Money, right: Money): Money;
+/** The total of `amounts`, all in `currency` (zero when there are none). */
+export declare function sumMoney(amounts: readonly Money[], currency: CurrencyCode): Money;
+/**
+ * The amount times `factor` (a fee rate, a share, a token count over a per-million price), rounded
+ * half to even at the micro. The factor's shortest decimal form is multiplied exactly.
+ */
+export declare function scaleMoney(amount: Money, factor: number): Money;
+/** -1, 0 or 1 as `left` is less than, equal to or more than `right`. */
+export declare function compareMoney(left: Money, right: Money): -1 | 0 | 1;
+/** Digits in the currency's minor unit (USD 2, JPY 0, KWD 3), as `Intl` knows the currency. */
+export declare function currencyExponent(currency: CurrencyCode): number;
+/**
+ * The amount in its currency's minor unit (cents, for a payment provider), exactly: an amount that
+ * isn't a whole number of minor units is refused, never rounded, so a charge is never silently changed.
+ */
+export declare function toMinorUnits(amount: ShowableMoney): number;
+/** An amount given in its currency's minor unit (a payment provider's cents). */
+export declare function fromMinorUnits(minor: number, currency: CurrencyCode): Money;
+/**
+ * The amount for people, in `locale` (a BCP 47 tag) with its currency's symbol and digits. Usage
+ * costs below the currency's smallest unit need more digits: pass `maximumFractionDigits`.
+ */
+export declare function formatMoney(amount: ShowableMoney, locale: string, options?: Intl.NumberFormatOptions): string;
+/**
+ * `currency` in `locale`'s pattern with its narrow symbol: "$5.50" in every English region (en-GB's
+ * own symbol would be "US$5.50"), "5,50 $" in ru. Exactly `fraction` decimals when given, else the
+ * currency's own (2 for USD, 0 for JPY).
+ */
+export declare function moneyFormat(locale: string, currency: string, fraction?: number): Intl.NumberFormat;
+/** Decimals of `currency`'s minor unit (ISO 4217, from `Intl`): 2 for USD, 0 for JPY, 3 for KWD. */
+export declare function currencyDigits(currency: string, locale: string): number;
+/** The smallest amount `currency` writes: 0.01 for USD, 1 for JPY. */
+export declare function minorUnit(currency: string, locale: string): number;

package/dist/_bundled/money/index.js

@@ -0,0 +1,152 @@
+export const MICROS_PER_UNIT = 1e6;
+const MICRO_DIGITS = 6;
+
+export class CurrencyMismatchError extends Error {
+  left;
+  right;
+  constructor(left, right) {
+    super(`can't combine ${left} with ${right}`);
+    this.name = "CurrencyMismatchError";
+    this.left = left;
+    this.right = right;
+  }
+}
+export function money(micros, currency) {
+  if (!Number.isSafeInteger(micros))
+    throw new RangeError(`${micros} is not a whole number of micros`);
+  return { micros, currency };
+}
+export function parseMoney(amount, currency) {
+  return money(scaledInteger(amount, MICRO_DIGITS, "exact"), currency);
+}
+export function moneyFromUnits(units, currency) {
+  if (!Number.isFinite(units))
+    throw new RangeError(`${units} is not an amount`);
+  return money(scaledInteger(String(units), MICRO_DIGITS, "half-even"), currency);
+}
+export function moneyToUnits(amount) {
+  return Number(moneyToDecimal(amount));
+}
+export function accountingUnits(amount) {
+  return Number(decimalOf(amount));
+}
+export function moneyToDecimal(amount) {
+  return decimalOf(amount);
+}
+export function moneyText(amount) {
+  return `${moneyToDecimal(amount)} ${amount.currency}`;
+}
+export function addMoney(left, right) {
+  sameCurrency(left, right);
+  return money(left.micros + right.micros, left.currency);
+}
+export function subtractMoney(left, right) {
+  sameCurrency(left, right);
+  return money(left.micros - right.micros, left.currency);
+}
+export function sumMoney(amounts, currency) {
+  return amounts.reduce((total, amount) => addMoney(total, amount), money(0, currency));
+}
+export function scaleMoney(amount, factor) {
+  if (!Number.isFinite(factor))
+    throw new RangeError(`${factor} is not a factor`);
+  const { digits, scale } = decimalParts(String(factor));
+  const product = BigInt(amount.micros) * digits;
+  return money(Number(roundScaled(product, scale, "half-even")), amount.currency);
+}
+export function compareMoney(left, right) {
+  sameCurrency(left, right);
+  return left.micros < right.micros ? -1 : left.micros > right.micros ? 1 : 0;
+}
+export function currencyExponent(currency) {
+  const digits = new Intl.NumberFormat(undefined, { style: "currency", currency }).resolvedOptions().maximumFractionDigits;
+  if (digits === undefined || digits > MICRO_DIGITS)
+    throw new RangeError(`${currency} has no minor unit we can hold`);
+  return digits;
+}
+export function toMinorUnits(amount) {
+  const divisor = 10 ** (MICRO_DIGITS - currencyExponent(amount.currency));
+  if (amount.micros % divisor !== 0) {
+    throw new RangeError(`${moneyText(amount)} isn't a whole number of minor units`);
+  }
+  return amount.micros / divisor;
+}
+export function fromMinorUnits(minor, currency) {
+  if (!Number.isSafeInteger(minor))
+    throw new RangeError(`${minor} is not a whole number of minor units`);
+  return money(minor * 10 ** (MICRO_DIGITS - currencyExponent(currency)), currency);
+}
+export function formatMoney(amount, locale, options = {}) {
+  return new Intl.NumberFormat(locale, { ...options, style: "currency", currency: amount.currency }).format(moneyToDecimal(amount));
+}
+const moneyFormats = new Map;
+export function moneyFormat(locale, currency, fraction) {
+  const key = `${locale} ${currency} ${fraction ?? ""}`;
+  let format = moneyFormats.get(key);
+  if (format === undefined) {
+    format = new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency,
+      currencyDisplay: "narrowSymbol",
+      ...fraction === undefined ? {} : { minimumFractionDigits: fraction, maximumFractionDigits: fraction }
+    });
+    moneyFormats.set(key, format);
+  }
+  return format;
+}
+export function currencyDigits(currency, locale) {
+  return moneyFormat(locale, currency).resolvedOptions().maximumFractionDigits ?? 0;
+}
+export function minorUnit(currency, locale) {
+  return 10 ** -currencyDigits(currency, locale);
+}
+function sameCurrency(left, right) {
+  if (left.currency !== right.currency)
+    throw new CurrencyMismatchError(left.currency, right.currency);
+}
+function decimalOf(amount) {
+  const sign = amount.micros < 0 ? "-" : "";
+  const digits = String(Math.abs(amount.micros)).padStart(MICRO_DIGITS + 1, "0");
+  const whole = digits.slice(0, -MICRO_DIGITS);
+  const fraction = digits.slice(-MICRO_DIGITS).replace(/0+$/u, "");
+  const text = fraction === "" ? `${sign}${whole}` : `${sign}${whole}.${fraction}`;
+  if (!isDecimal(text))
+    throw new RangeError(`${amount.micros} micros has no decimal form`);
+  return text;
+}
+const DECIMAL = /^([+-])?(\d+)(?:\.(\d*))?(?:e([+-]?\d+))?$/iu;
+function isDecimal(text) {
+  return DECIMAL.test(text);
+}
+function decimalParts(text) {
+  const match = DECIMAL.exec(text.trim());
+  if (match === null)
+    throw new RangeError(`${text} is not a decimal amount`);
+  const [, sign = "", whole = "", fraction = "", exponent = "0"] = match;
+  const scale = fraction.length - Number(exponent);
+  const magnitude = BigInt(`${whole}${fraction}`);
+  const digits = sign === "-" ? -magnitude : magnitude;
+  return scale >= 0 ? { digits, scale } : { digits: digits * 10n ** BigInt(-scale), scale: 0 };
+}
+function scaledInteger(text, places, mode) {
+  const { digits, scale } = decimalParts(text);
+  const value = scale <= places ? digits * 10n ** BigInt(places - scale) : roundScaled(digits, scale - places, mode, text);
+  return Number(value);
+}
+function roundScaled(value, scale, mode, text = String(value)) {
+  if (scale === 0)
+    return value;
+  const divisor = 10n ** BigInt(scale);
+  const negative = value < 0n;
+  const magnitude = negative ? -value : value;
+  let quotient = magnitude / divisor;
+  const remainder = magnitude % divisor;
+  if (remainder !== 0n) {
+    if (mode === "exact")
+      throw new RangeError(`${text} has more than ${MICRO_DIGITS} decimal places`);
+    const twice = remainder * 2n;
+    if (twice > divisor || twice === divisor && quotient % 2n === 1n)
+      quotient += 1n;
+  }
+  return negative ? -quotient : quotient;
+}

package/dist/_bundled/tokens/index.d.ts

@@ -0,0 +1,2 @@
+export { palette, syntax } from "./palette.gen.js";
+export * from "./spec.js";

package/dist/_bundled/tokens/index.js

@@ -0,0 +1,2 @@
+export { palette, syntax } from "./palette.gen.js";
+export * from "./spec.js";

package/dist/_bundled/tokens/palette.gen.d.ts

@@ -0,0 +1,51 @@
+export declare const palette: {
+    readonly light: {
+        readonly gray: readonly ["#fdfcf9", "#f9f8f5", "#f4f2ee", "#eeece8", "#e9e6e1", "#e1ded9", "#d5d3cd", "#c2bfb9", "#82807b", "#676460", "#514e4a", "#1b1a17"];
+        readonly blue: readonly ["#fafcff", "#f4f8ff", "#ebf3ff", "#e2edff", "#d9e8ff", "#cde0ff", "#bad4ff", "#9bc0ff", "#0169ff", "#005de5", "#125bd1", "#001643"];
+        readonly green: readonly ["#f9fefa", "#f1fbf3", "#e6f8e9", "#daf5e0", "#cef1d6", "#c1ebca", "#ade2ba", "#8cd39f", "#008743", "#00773b", "#097038", "#00210c"];
+        readonly amber: readonly ["#fffbf7", "#fff7ed", "#fef0de", "#fee9d0", "#fde2c1", "#fad8b0", "#f4cb98", "#eab470", "#f3a52b", "#e29721", "#905c00", "#271600"];
+        readonly red: readonly ["#fffbfb", "#fff6f5", "#ffeeec", "#ffe6e3", "#ffdeda", "#ffd2ce", "#ffc1bb", "#ffa39b", "#d2393a", "#bf2d30", "#ac3434", "#370406"];
+        readonly violet: readonly ["#fcfbff", "#f8f7ff", "#f3f0ff", "#ede9ff", "#e8e2ff", "#e1d8ff", "#d6caff", "#c4b2fb", "#8264c8", "#7558b7", "#6952a1", "#1d1234"];
+    };
+    readonly dark: {
+        readonly gray: readonly ["#191917", "#1f1e1c", "#252422", "#2c2b28", "#32312e", "#3b3936", "#484643", "#5e5c58", "#767470", "#a19f9a", "#bfbdb9", "#f1f0ed"];
+        readonly blue: readonly ["#16191d", "#191e27", "#1b2535", "#1d2b43", "#1e3151", "#213961", "#27457a", "#2f59a2", "#4c8eff", "#669eff", "#8eb8ff", "#e8f1ff"];
+        readonly green: readonly ["#171a17", "#1a201b", "#1d281f", "#1f2f23", "#213727", "#25412d", "#2c5036", "#366945", "#36ac62", "#4db972", "#7dd596", "#d2fddc"];
+        readonly amber: readonly ["#1b1816", "#221d18", "#2b2319", "#352819", "#3e2e19", "#4a351a", "#5b411d", "#785421", "#faab35", "#ffbe6a", "#febc67", "#ffedd8"];
+        readonly red: readonly ["#1c1717", "#251b1b", "#301f1e", "#3c2321", "#482724", "#552c29", "#6a3531", "#8c433e", "#e9504d", "#f6625e", "#ff958d", "#ffebe9"];
+        readonly violet: readonly ["#19181b", "#1e1d23", "#25232e", "#2c2839", "#332d44", "#3b3450", "#494064", "#5f5284", "#9477dd", "#a186e9", "#c3afff", "#f1edff"];
+    };
+};
+/** Syntax colours (the kit's src/lib/shiki-themes.ts), each held to 4.5:1 on every background code sits on. */
+export declare const syntax: {
+    readonly light: {
+        readonly fg: "#1b1a17";
+        readonly muted: "#514e4a";
+        readonly comment: "#56534f";
+        readonly keyword: "#5e4694";
+        readonly string: "#00622f";
+        readonly number: "#764a00";
+        readonly fn: "#004cbd";
+        readonly type: "#005c78";
+        readonly tag: "#933333";
+        readonly attribute: "#764a00";
+        readonly regex: "#9e2629";
+        readonly inserted: "#00622f";
+        readonly deleted: "#9e2629";
+    };
+    readonly dark: {
+        readonly fg: "#e6e5e2";
+        readonly muted: "#bfbdb9";
+        readonly comment: "#bcbab4";
+        readonly keyword: "#c2b2f2";
+        readonly string: "#89d19c";
+        readonly number: "#f3bc76";
+        readonly fn: "#99bbf4";
+        readonly type: "#90c5c8";
+        readonly tag: "#faa29b";
+        readonly attribute: "#f3bc76";
+        readonly regex: "#faa29b";
+        readonly inserted: "#89d19c";
+        readonly deleted: "#faa29b";
+    };
+};