tosijs-ui 1.15.2 → 1.15.3

package/CHANGELOG.md

@@ -1,5 +1,81 @@
 # Changelog
 
+## 1.15.3
+
+### `<tosi-md sanitize="on">`, and a heads-up: it becomes the default in 1.16 (#179)
+
+`<tosi-md>` assigns rendered markdown to the page, and markdown can carry raw HTML. For text you
+did not write (issue bodies, comments, anything from a user or an API), that is a **stored
+XSS**: tosijs-virta's pre-release review demonstrated reading a token out of `localStorage`
+through an issue body with `<img onerror>`.
+
+`sanitize="on"` strips executable content (scripts, event-handler attributes, unsafe URL
+schemes) with [kilpi](https://www.npmjs.com/package/tosijs-kilpi), and drops any link that is
+not safe to navigate to. It **removes some elements together with everything inside them**:
+`script`, `style`, `iframe`, `object`, `embed`, `form`, `link`, `meta`, `base`, `noscript`,
+`template` and SVG animation elements. So markdown that embeds a `<form>` needs `sanitize="off"`.
+Markdown, ordinary links (relative, `#anchor`, `mailto:`), inputs and custom elements survive. A
+bare `<tosi-md sanitize>` also means on.
+
+**If you leave `sanitize` unset, nothing changes in this release** except one console warning
+per page. **In 1.16 the default becomes `on`.** Set `sanitize="on"` or `sanitize="off"` now and
+the upgrade will not affect you; `off` keeps raw HTML and is silent.
+
+`tosijs-kilpi` is a new runtime dependency: +865 bytes gzip on `dist/iife.js`.
+
+### Escape closes a `<tosi-dialog>` properly — `confirm`/`alert`/`prompt` no longer hang (#183)
+
+Escape let the browser close the native `<dialog>` directly, bypassing `close()`. So
+`await TosiDialog.confirm(...)` (and `alert`, `prompt`) **never settled**, the `showModal()`
+promise never resolved, and a `removeOnClose` dialog stayed in the DOM, one leaked element per
+Escape. Escape now closes with `'cancel'` through the same path as the Cancel button. So does
+the browser closing the element on its own (a `<form method="dialog">`, or Chrome refusing a
+repeated Escape), so nothing waits forever.
+
+**New: `dialogWillClose` can refuse a close.** Return `false`, or a Promise of `false`, and the
+dialog stays open, e.g. while an async save is in flight. `close()` now returns whether it
+closed. Reported by snowfox-app, which carried a workaround at nine sites.
+
+The default `dialogWillClose` no longer `console.log`s on every close, and the docs now say that
+the built-in **OK** button sits beside footer buttons rather than being replaced by them.
+
+### Icon types: `IconElement` is importable, and `icons.x()` needs no `!` (#176, #181)
+
+- `IconElement`, `IconName` and `SVGIconMap` are exported from `tosijs-ui/icons`:
+  `import { icons, type IconElement } from 'tosijs-ui/icons'`. 1.15 widened the icon return
+  type from `SVGElement` to `SVGElement | HTMLSpanElement` (a composite icon is a span), and
+  there was no importable name for the new union.
+- Under `noUncheckedIndexedAccess`, every `icons.user()` read as possibly undefined, forcing
+  `icons.user!()` everywhere. Built-in icon names are now explicit keys of the type, so the `!`
+  can go, and a misspelled `IconName` is a type error. Composites and `defineIcons()` names
+  still go through the index signature.
+- `tosijs-make-icons` now generates `satisfies IconData` rather than `as IconData`, which keeps
+  icon names in the type system. **It needs TypeScript 4.9 or later** in the project that runs
+  it.
+
+### `tagList.popSelectMenu` can be replaced after the element is on the page (#172)
+
+The documented "replace this method" hook only worked if you replaced it before the element
+connected, which `tosiTagList({...})` never allows: the button captured the original function.
+It now looks the method up on every click.
+
+### Doc-site sourcemaps no longer expose the build machine's paths
+
+A doc site built with `bundleEntry` published sourcemaps whose sources climbed to the
+filesystem root and into the builder's home directory (`../../../../../../Users/<name>/…`),
+because the hydration bundle was built in the OS temp directory. The deployed site revealed
+the build machine's directory layout, and two machines could not produce the same site. The
+bundle is now built under your project's `node_modules/.cache`, and its maps are rewritten to
+point at the sources from where they are served, so devtools find them and every machine
+builds identical output. Rebuild your site to replace the old maps.
+
+### `/version.json`: what `commit` means (#180)
+
+Documentation only. Since #122, a content-identical rebuild keeps the previous stamp, so `commit`
+is the last commit whose build *changed the site*, and can be older than `HEAD`. To check that
+committed output matches `HEAD`, rebuild and confirm the tree is clean. `doc-site-system.md` now
+says so and shows `contentHash`.
+
 ## 1.15.2
 
 ### The `tjs-lang` peer admits 0.14.x (#182)

package/bin/make-icon-data.js

@@ -414,7 +414,10 @@ let source =
   (typeDeclaration ? typeDeclaration + '\n\n' : '') +
   'export default ' +
   emitObject(iconData) +
-  (isTypescript ? ' as IconData\n' : '\n')
+  // `satisfies`, not `as`: `as IconData` widened the keys to `string`, so the icon NAMES were
+  // lost to the type system and `icons.user` read as possibly-undefined under
+  // noUncheckedIndexedAccess (#181). `satisfies` checks the shape and keeps the names.
+  (isTypescript ? ' satisfies IconData\n' : '\n')
 
 /*
 If prettier is resolvable, let it have the last word — it picks up the CONSUMER's own

package/dist/dialog.d.ts

@@ -51,10 +51,22 @@ export declare class TosiDialog extends Component<DialogParts> {
     removeOnClose: boolean;
     closeOnBackgroundClick: boolean;
     constructor();
-    dialogWillClose: (reason?: string) => void;
+    /**
+    Called before the dialog closes, with the reason (`'confirm'`, `'cancel'`, or whatever was
+    passed to `close()`). Return `false` — or a Promise resolving to `false` — to refuse the
+    close, e.g. while an async save is in flight: a dialog that cannot be cancelled must not
+    look as though it was.
+    */
+    dialogWillClose: (_reason?: string) => void | boolean | Promise<void | boolean>;
     initialFocus(): void;
     showModal: () => Promise<string | null>;
-    close: (reason?: string) => void;
+    /**
+    Close the dialog unless `dialogWillClose` vetoes it. Returns whether it closed — a Promise
+    of that when `dialogWillClose` is async.
+    */
+    close: (reason?: string) => boolean | Promise<boolean>;
+    onCancel: (event: Event) => void;
+    onNativeClose: () => void;
     ok: () => void;
     content: () => HTMLDialogElement;
 }

package/dist/dialog.js

@@ -43,6 +43,32 @@ test('dialog has header slot content', () => {
 })
 ```
 
+The dialog always supplies its own **OK** button (`part="ok"`, which closes with
+`'confirm'`). Buttons you put in the `footer` slot appear **beside** it, not instead of it, so
+add a Cancel button there, not a second OK.
+
+## Closing
+
+Every way a dialog closes — the OK button, `close(reason)`, a background click when
+`closeOnBackgroundClick` is set, **Escape**, or a `<form method="dialog">` — goes through the
+same path: `dialogWillClose(reason)` is called, the `showModal()` promise resolves with the
+reason, and a `removeOnClose` dialog removes itself. Escape closes with `'cancel'`.
+
+`dialogWillClose` can **refuse** a close by returning `false`, or a Promise resolving to
+`false`. Use it for a dialog that must not be dismissed while it is busy, such as an async save
+in flight. `close()` returns whether the dialog closed, or a Promise of that when
+`dialogWillClose` is async.
+
+```typescript
+const editor = tosiDialog({
+  dialogWillClose: () => !saving, // Escape and Cancel do nothing mid-save
+})
+```
+
+The browser can close a `<dialog>` without asking (a `<form method="dialog">` submission, or a
+repeated Escape without fresh user interaction in Chrome). Those cannot be refused; the dialog
+still calls `dialogWillClose` and resolves, so nothing waits forever.
+
 ## Static Functions
 
 `TosiDialog` provides static async functions to replace the built-in dialogs provided by
@@ -232,8 +258,14 @@ export class TosiDialog extends Component {
             }
         });
     }
-    dialogWillClose = (reason = 'cancel') => {
-        console.log('dialog will close with', reason);
+    /**
+    Called before the dialog closes, with the reason (`'confirm'`, `'cancel'`, or whatever was
+    passed to `close()`). Return `false` — or a Promise resolving to `false` — to refuse the
+    close, e.g. while an async save is in flight: a dialog that cannot be cancelled must not
+    look as though it was.
+    */
+    dialogWillClose = (_reason = 'cancel') => {
+        /* override to observe or veto */
     };
     initialFocus() {
         this.parts.ok.focus();
@@ -241,8 +273,16 @@ export class TosiDialog extends Component {
     #modalResolution = (_outcome) => {
         /* noop */
     };
+    /*
+    True once this showing's close side effects have run — resolution, removal — so that no path
+    runs them twice. Every route to "closed" funnels into #finish, and there are three: close()
+    (buttons, background click, callers), Escape (the native `cancel`), and the browser closing
+    the element on its own (the native `close` event, below).
+    */
+    #settled = false;
     showModal = () => {
         this.style.zIndex = String(findHighestZ());
+        this.#settled = false;
         return new Promise((resolve) => {
             this.#modalResolution = resolve;
             this.parts.dialog.showModal();
@@ -251,17 +291,59 @@ export class TosiDialog extends Component {
             });
         });
     };
+    /**
+    Close the dialog unless `dialogWillClose` vetoes it. Returns whether it closed — a Promise
+    of that when `dialogWillClose` is async.
+    */
     close = (reason = 'cancel') => {
-        this.dialogWillClose(reason);
+        if (this.#settled) {
+            return true;
+        }
+        const verdict = this.dialogWillClose(reason);
+        if (verdict instanceof Promise) {
+            return verdict.then((v) => (v === false ? false : this.#finish(reason)));
+        }
+        return verdict === false ? false : this.#finish(reason);
+    };
+    #finish(reason) {
+        if (this.#settled) {
+            return true;
+        }
+        this.#settled = true;
         this.#modalResolution(reason);
-        this.parts.dialog.close();
+        if (this.parts.dialog.open) {
+            this.parts.dialog.close();
+        }
         if (this.removeOnClose) {
             this.remove();
         }
+        return true;
+    }
+    /*
+    Escape (#183). The browser would close the <dialog> itself and bypass close(), so the static
+    helpers never resolved and removeOnClose leaked the element. Take the close over instead,
+    which is also what lets dialogWillClose veto it.
+    */
+    onCancel = (event) => {
+        event.preventDefault();
+        this.close('cancel');
+    };
+    /*
+    The browser can still close the element without asking: Chrome's close-watcher makes a repeat
+    `cancel` non-cancelable without fresh user activation, and `<form method="dialog">` closes it
+    directly. Too late to veto, so tell dialogWillClose and settle, rather than hang the caller.
+    */
+    onNativeClose = () => {
+        if (this.#settled) {
+            return;
+        }
+        const reason = this.parts.dialog.returnValue || 'cancel';
+        this.dialogWillClose(reason);
+        this.#finish(reason);
     };
     ok = () => {
         this.close('confirm');
     };
-    content = () => dialog({ part: 'dialog' }, header(tosiSlot({ name: 'header' })), tosiSlot(), footer(tosiSlot({ name: 'footer' }), button({ part: 'ok', onClick: this.ok }, 'OK')));
+    content = () => dialog({ part: 'dialog', onCancel: this.onCancel, onClose: this.onNativeClose }, header(tosiSlot({ name: 'header' })), tosiSlot(), footer(tosiSlot({ name: 'footer' }), button({ part: 'ok', onClick: this.ok }, 'OK')));
 }
 export const tosiDialog = TosiDialog.elementCreator();

package/dist/doc-system/site/build-stamp.d.ts

@@ -3,7 +3,12 @@ export interface BuildStamp {
     generator: string;
     /** the project's name, from site config */
     site?: string;
-    /** short commit hash the site was built from, when available */
+    /**
+     * Short hash of the last commit whose build CHANGED the site's content, when available.
+     * A content-identical rebuild keeps the previous value (see `stampToWrite`, #122), so this
+     * can be older than HEAD — to check committed output matches HEAD, rebuild and check the
+     * tree is clean instead (#180).
+     */
     commit?: string;
     /** ISO-8601 commit timestamp, when available */
     commitTime?: string;

package/dist/doc-system/site/orchestrator.js

@@ -20,6 +20,7 @@ import { existsSync, mkdirSync, unlinkSync } from 'fs';
 import { tmpdir } from 'os';
 import { $, spawn } from 'bun';
 import { extractDocs } from './docs.js';
+import { relocateSourcemaps } from './sourcemap-relocate.js';
 import { checkExamples, formatExampleProblems, } from './check-examples.js';
 import { ensureSections } from './sections.js';
 import { generateLlmsTxt } from './make-llms-txt.js';
@@ -951,8 +952,17 @@ export async function buildSite(config, opts = {}) {
               Build it in a temp dir instead. The only consumer is the copy into PUBLIC on the
               next line, so nothing needs it to persist — and a temp dir cannot be swept into a
               published tarball by a broad `files` entry.
+        
+              Not the OS temp dir, though. `bun build` writes each sourcemap `sources` entry relative
+              to the OUTPUT dir, so from /tmp every path climbed to `/` and back down into the builder's
+              home — `../../../../../../Users/<name>/<project>/node_modules/…`. That published the
+              build machine's layout in every chunk map, and made docs/ differ between any two
+              machines, which failed the publish workflow's rebuild check (#178). Under the project's
+              own node_modules/.cache the paths are project-relative, so identical everywhere, and it
+              is equally out of reach of a `files` entry.
               */
-                const HYDRATE_DIR = `${tmpdir()}/tosijs-hydrate-${process.pid}`;
+                const HYDRATE_DIR = path.resolve(PROJECT_ROOT, 'node_modules/.cache', `tosijs-hydrate-${process.pid}`);
+                mkdirSync(path.dirname(HYDRATE_DIR), { recursive: true });
                 await $ `rm -rf ${HYDRATE_DIR}`.text().catch(() => { });
                 const esm = spawn([
                     'bun',
@@ -998,6 +1008,8 @@ export async function buildSite(config, opts = {}) {
                 // Copy the whole ESM output (entry + hashed chunks) to the served root — the entry
                 // imports its chunks by RELATIVE path, so they must sit right beside it.
                 await $ `cp -R ${HYDRATE_DIR}/. ${PUBLIC}/`.text();
+                // The copy moved every map; re-point their sources from where they now sit (#178).
+                relocateSourcemaps(HYDRATE_DIR, PUBLIC);
                 hydrateName = 'hydrate.js';
                 /*
                 `bundleEntry` REPLACES our bundle rather than extending it, and an entry that forgets

package/dist/doc-system/site/sourcemap-relocate.d.ts

@@ -0,0 +1,7 @@
+/** Re-express one map's sources, as if the map moved from `fromDir` to `toDir`. */
+export declare function relocateSources(sources: string[], fromDir: string, toDir: string): string[];
+/**
+ * For every `.map` under `builtDir`, write a copy at the same relative path under
+ * `servedDir` with its `sources` rewritten for that location.
+ */
+export declare function relocateSourcemaps(builtDir: string, servedDir: string): void;

package/dist/doc-system/site/sourcemap-relocate.js

@@ -0,0 +1,50 @@
+/*
+Rewrite sourcemaps for a bundle that is BUILT in one directory and SERVED from another.
+
+`bun build` writes each `sources` entry relative to the output directory. The hydration bundle
+is built outside the served tree (so it can never be swept into a published `dist/`, #31) and
+then copied into it, which leaves every relative path pointing somewhere else. Built in the OS
+temp dir, those paths climbed to `/` and into the builder's home directory — publishing the
+machine's layout and making the site differ between machines (#178).
+
+For each `.map` under `builtDir`, this re-expresses every source relative to the map's place
+under `servedDir`. The result is correct for devtools, identical on every machine, and
+names no home directory. Virtual sources (`bun:…`, `data:…`) are left alone.
+*/
+import { readdirSync, readFileSync, statSync, writeFileSync } from 'fs';
+import * as path from 'path';
+function mapsUnder(dir) {
+    const out = [];
+    for (const name of readdirSync(dir)) {
+        const full = path.join(dir, name);
+        if (statSync(full).isDirectory())
+            out.push(...mapsUnder(full));
+        else if (name.endsWith('.map'))
+            out.push(full);
+    }
+    return out;
+}
+/** Re-express one map's sources, as if the map moved from `fromDir` to `toDir`. */
+export function relocateSources(sources, fromDir, toDir) {
+    return sources.map((source) => /^[a-z][a-z0-9+.-]*:/i.test(source)
+        ? source
+        : path
+            .relative(toDir, path.resolve(fromDir, source))
+            .split(path.sep)
+            .join('/'));
+}
+/**
+ * For every `.map` under `builtDir`, write a copy at the same relative path under
+ * `servedDir` with its `sources` rewritten for that location.
+ */
+export function relocateSourcemaps(builtDir, servedDir) {
+    for (const map of mapsUnder(builtDir)) {
+        const rel = path.relative(builtDir, map);
+        const target = path.join(servedDir, rel);
+        const json = JSON.parse(readFileSync(map, 'utf8'));
+        if (Array.isArray(json.sources)) {
+            json.sources = relocateSources(json.sources, path.dirname(map), path.dirname(target));
+        }
+        writeFileSync(target, JSON.stringify(json));
+    }
+}

package/dist/icon-data.d.ts

@@ -1,5 +1,326 @@
 export interface IconData {
     [key: string]: string;
 }
-declare const _default: IconData;
+declare const _default: {
+    blueprint: string;
+    earth: string;
+    cmy: string;
+    rgb: string;
+    xrColor: string;
+    tosiFavicon: string;
+    tosiPlatform: string;
+    tosiUi: string;
+    tosiXr: string;
+    tosi: string;
+    discord: string;
+    facebook: string;
+    game: string;
+    google: string;
+    npm: string;
+    youtube: string;
+    blog: string;
+    bug: string;
+    activity: string;
+    airplay: string;
+    alertCircle: string;
+    alertOctagon: string;
+    alertTriangle: string;
+    alignCenter: string;
+    alignJustify: string;
+    alignLeft: string;
+    alignRight: string;
+    anchor: string;
+    aperture: string;
+    archive: string;
+    arrowUpRight: string;
+    atSign: string;
+    award: string;
+    barChart2: string;
+    barChart: string;
+    batteryCharging: string;
+    battery: string;
+    bellOff: string;
+    bell: string;
+    bluetooth: string;
+    bold: string;
+    bookOpen: string;
+    book: string;
+    bookmark: string;
+    box: string;
+    briefcase: string;
+    calendar: string;
+    cameraOff: string;
+    camera: string;
+    cast: string;
+    checkCircle: string;
+    checkSquare: string;
+    check: string;
+    chrome: string;
+    circle: string;
+    clipboard: string;
+    clock: string;
+    cloudDrizzle: string;
+    cloudLightning: string;
+    cloudOff: string;
+    cloudRain: string;
+    cloudSnow: string;
+    cloud: string;
+    code: string;
+    codepen: string;
+    codesandbox: string;
+    coffee: string;
+    columns: string;
+    command: string;
+    compass: string;
+    copy: string;
+    cpu: string;
+    creditCard: string;
+    crop: string;
+    crosshair: string;
+    database: string;
+    delete: string;
+    disc: string;
+    divideCircle: string;
+    divideSquare: string;
+    divide: string;
+    dollarSign: string;
+    downloadCloud: string;
+    download: string;
+    dribbble: string;
+    droplet: string;
+    edit2: string;
+    edit3: string;
+    edit: string;
+    externalLink: string;
+    eyeOff: string;
+    eye: string;
+    fastForward: string;
+    feather: string;
+    figma: string;
+    fileMinus: string;
+    filePlus: string;
+    fileText: string;
+    file: string;
+    film: string;
+    filter: string;
+    flag: string;
+    folderMinus: string;
+    folderPlus: string;
+    folder: string;
+    framer: string;
+    frown: string;
+    gift: string;
+    gitBranch: string;
+    gitCommit: string;
+    gitMerge: string;
+    gitPullRequest: string;
+    github: string;
+    gitlab: string;
+    globe: string;
+    grid: string;
+    hardDrive: string;
+    hash: string;
+    headphones: string;
+    heart: string;
+    helpCircle: string;
+    hexagon: string;
+    home: string;
+    image: string;
+    inbox: string;
+    info: string;
+    instagram: string;
+    italic: string;
+    key: string;
+    layers: string;
+    layout: string;
+    lifeBuoy: string;
+    link2: string;
+    link: string;
+    linkedin: string;
+    list: string;
+    loader: string;
+    lock: string;
+    logIn: string;
+    logOut: string;
+    mail: string;
+    mapPin: string;
+    map: string;
+    maximize2: string;
+    maximize: string;
+    meh: string;
+    menu: string;
+    messageCircle: string;
+    messageSquare: string;
+    micOff: string;
+    mic: string;
+    minimize2: string;
+    minimize: string;
+    minusCircle: string;
+    minusSquare: string;
+    minus: string;
+    monitor: string;
+    moon: string;
+    moreHorizontal: string;
+    moreVertical: string;
+    mousePointer: string;
+    move: string;
+    music: string;
+    navigation2: string;
+    navigation: string;
+    octagon: string;
+    package: string;
+    paperclip: string;
+    pauseCircle: string;
+    pause: string;
+    penTool: string;
+    percent: string;
+    phoneCall: string;
+    phoneForwarded: string;
+    phoneIncoming: string;
+    phoneMissed: string;
+    phoneOff: string;
+    phoneOutgoing: string;
+    phone: string;
+    pieChart: string;
+    playCircle: string;
+    play: string;
+    plusCircle: string;
+    plusSquare: string;
+    plus: string;
+    pocket: string;
+    power: string;
+    printer: string;
+    radio: string;
+    repeat: string;
+    rewind: string;
+    cornerDownRight: string;
+    cornerRightDown: string;
+    cornerRightUp: string;
+    cornerUpRight: string;
+    refreshCw: string;
+    rotateCw: string;
+    skipForward: string;
+    toggleRight: string;
+    rss: string;
+    save: string;
+    scissors: string;
+    search: string;
+    send: string;
+    server: string;
+    settings: string;
+    share2: string;
+    share: string;
+    shieldOff: string;
+    shield: string;
+    shoppingBag: string;
+    shoppingCart: string;
+    shuffle: string;
+    sidebar: string;
+    slack: string;
+    slash: string;
+    sliders: string;
+    smartphone: string;
+    smile: string;
+    speaker: string;
+    square: string;
+    star: string;
+    stopCircle: string;
+    sun: string;
+    sunrise: string;
+    sunset: string;
+    table: string;
+    tablet: string;
+    tag: string;
+    target: string;
+    terminal: string;
+    thermometer: string;
+    tool: string;
+    trash2: string;
+    trash: string;
+    trello: string;
+    trendingDown: string;
+    trendingUp: string;
+    triangle: string;
+    truck: string;
+    tv: string;
+    twitch: string;
+    twitter: string;
+    type: string;
+    umbrella: string;
+    underline: string;
+    unlock: string;
+    thumbsUp: string;
+    arrowRightCircle: string;
+    arrowRight: string;
+    chevronRight: string;
+    chevronsRight: string;
+    uploadCloud: string;
+    upload: string;
+    userCheck: string;
+    userMinus: string;
+    userPlus: string;
+    userX: string;
+    user: string;
+    users: string;
+    videoOff: string;
+    video: string;
+    voicemail: string;
+    volume1: string;
+    volume2: string;
+    volumeX: string;
+    volume: string;
+    watch: string;
+    wifiOff: string;
+    wifi: string;
+    wind: string;
+    xCircle: string;
+    xOctagon: string;
+    xSquare: string;
+    x: string;
+    zapOff: string;
+    zap: string;
+    zoomIn: string;
+    zoomOut: string;
+    fontBold: string;
+    fontItalic: string;
+    fontUnderline: string;
+    indent: string;
+    listBullet: string;
+    listNumber: string;
+    outdent: string;
+    pin: string;
+    resize: string;
+    shift: string;
+    sortAscending: string;
+    sortDescending: string;
+    tab: string;
+    cornerDownLeft: string;
+    cornerLeftDown: string;
+    cornerLeftUp: string;
+    cornerUpLeft: string;
+    refreshCcw: string;
+    rotateCcw: string;
+    skipBack: string;
+    toggleLeft: string;
+    thumbsDown: string;
+    arrowDownCircle: string;
+    arrowLeftCircle: string;
+    arrowUpCircle: string;
+    arrowDown: string;
+    arrowLeft: string;
+    arrowUp: string;
+    chevronDown: string;
+    chevronLeft: string;
+    chevronUp: string;
+    chevronsDown: string;
+    chevronsLeft: string;
+    chevronsUp: string;
+    arrowDownRight: string;
+    arrowDownLeft: string;
+    arrowUpLeft: string;
+    fatArrowUp: string;
+    fatArrowRight: string;
+    fatArrowDown: string;
+    fatArrowLeft: string;
+};
 export default _default;