@d0nj/dsh-ui-custom 0.0.0-stage → 0.2.0

package/dist/client/panel.js

@@ -0,0 +1,488 @@
+/**
+ * Theme Studio: the settings page.
+ *
+ * Live preview is computed from the same resolver the stored document goes
+ * through, so what the panel shows and what the plugin applies cannot drift.
+ * Writes go through `configForms.get('ui-custom').set/unset`, which means the
+ * panel never touches YAML, never races a revision, and is reversible field by
+ * field.
+ *
+ * Styling follows the plugin rules: theme tokens only (`--dsw-alias-*`, plus the
+ * `--d0nj-*` geometry tokens this plugin derives), no literal colours for
+ * chrome. The swatches themselves are the one place a literal colour is correct,
+ * because they *are* the colour being chosen.
+ *
+ * @module @d0nj/dsh-ui-custom/panel
+ */
+import { findHostedFont, hostedFamilies, loadHostedFont } from './hosted-fonts.js';
+/** Shared inline styles, computed from theme tokens. */
+function styles() {
+    return {
+        root: {
+            display: 'flex',
+            flexDirection: 'column',
+            gap: 24,
+            padding: '4px 0 32px',
+            color: 'var(--dsw-alias-label-primary)',
+            fontFamily: 'inherit',
+        },
+        section: { display: 'flex', flexDirection: 'column', gap: 10 },
+        heading: { fontSize: 13, fontWeight: 600, color: 'var(--dsw-alias-label-primary)' },
+        hint: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)', lineHeight: 1.5 },
+        grid: {
+            display: 'grid',
+            gridTemplateColumns: 'repeat(auto-fill, minmax(180px, 1fr))',
+            gap: 10,
+        },
+        card: {
+            display: 'flex',
+            flexDirection: 'column',
+            gap: 8,
+            padding: 10,
+            borderRadius: 'var(--d0nj-radius-md, 8px)',
+            border: '1px solid var(--dsw-alias-border-l1)',
+            // No background and no colour token here: a card represents a theme, so it
+            // paints that theme's own surface (set per card, below). Using a token made
+            // every card show the live theme instead, which read as banding.
+            background: 'transparent',
+            cursor: 'pointer',
+            textAlign: 'left',
+            color: 'var(--dsw-alias-label-primary)',
+            font: 'inherit',
+            // The UA focus ring lingers on whichever card was last clicked; a
+            // focus-visible ring keeps keyboard affordance without that trail.
+            outline: 'none',
+        },
+        cardActive: {
+            borderColor: 'var(--dsw-alias-brand-primary)',
+            borderWidth: 2,
+            padding: 9,
+        },
+        swatches: { display: 'flex', gap: 4 },
+        swatch: {
+            width: 22,
+            height: 22,
+            borderRadius: 'var(--d0nj-radius-sm, 4px)',
+            border: '1px solid var(--dsw-alias-border-l1)',
+        },
+        row: {
+            display: 'grid',
+            gridTemplateColumns: 'minmax(120px, 1fr) auto auto',
+            gap: 8,
+            alignItems: 'center',
+            padding: '6px 0',
+            borderBottom: '1px solid var(--dsw-alias-border-l1)',
+        },
+        rowLabel: { display: 'flex', flexDirection: 'column', gap: 2 },
+        input: {
+            width: 92,
+            padding: '4px 6px',
+            borderRadius: 'var(--d0nj-radius-sm, 4px)',
+            border: '1px solid var(--dsw-alias-border-l1)',
+            background: 'var(--dsw-alias-bg-base)',
+            color: 'var(--dsw-alias-label-primary)',
+            font: 'inherit',
+            fontSize: 12,
+        },
+        select: {
+            width: 260,
+            padding: '4px 6px',
+            borderRadius: 'var(--d0nj-radius-sm, 4px)',
+            border: '1px solid var(--dsw-alias-border-l1)',
+            background: 'var(--dsw-alias-bg-base)',
+            color: 'var(--dsw-alias-label-primary)',
+            font: 'inherit',
+            fontSize: 12,
+        },
+        fontStack: { display: 'flex', flexDirection: 'column', gap: 4, width: 260 },
+        fontRow: { gap: 18 },
+        combo: { position: 'relative', width: 260 },
+        listbox: {
+            position: 'absolute',
+            zIndex: 10,
+            top: '100%',
+            left: 0,
+            right: 0,
+            marginTop: 4,
+            maxHeight: 240,
+            overflowY: 'auto',
+            padding: 4,
+            borderRadius: 'var(--d0nj-radius-sm, 4px)',
+            border: '1px solid var(--dsw-alias-border-l2)',
+            // A popup over arbitrary content cannot inherit the surface behind it, so
+            // it paints the module fill; only the element's own list uses this literal.
+            background: 'var(--dsw-alias-bg-module-platform, var(--dsw-alias-bg-layer-1))',
+            boxShadow: 'var(--dsw-elevation-lv2, 0 4px 12px rgba(0, 0, 0, 0.2))',
+        },
+        option: {
+            padding: '4px 6px',
+            borderRadius: 'var(--d0nj-radius-sm, 4px)',
+            fontSize: 12,
+            color: 'var(--dsw-alias-label-primary)',
+            cursor: 'pointer',
+            whiteSpace: 'nowrap',
+            overflow: 'hidden',
+            textOverflow: 'ellipsis',
+        },
+        optionActive: { background: 'var(--dsw-alias-interactive-bg-hover, var(--dsw-alias-bg-layer-2))' },
+        colorInput: {
+            width: 34,
+            height: 26,
+            padding: 0,
+            border: '1px solid var(--dsw-alias-border-l1)',
+            borderRadius: 'var(--d0nj-radius-sm, 4px)',
+            background: 'transparent',
+            cursor: 'pointer',
+        },
+        button: {
+            padding: '5px 10px',
+            borderRadius: 'var(--d0nj-radius-md, 8px)',
+            border: '1px solid var(--dsw-alias-border-l2)',
+            background: 'var(--dsw-alias-bg-layer-2)',
+            color: 'var(--dsw-alias-label-primary)',
+            font: 'inherit',
+            fontSize: 12,
+            cursor: 'pointer',
+        },
+        warning: {
+            padding: '8px 10px',
+            borderRadius: 'var(--d0nj-radius-md, 8px)',
+            border: '1px solid var(--dsw-alias-state-warn-primary)',
+            color: 'var(--dsw-alias-state-warn-primary)',
+            fontSize: 12,
+        },
+        preview: {
+            display: 'flex',
+            flexDirection: 'column',
+            gap: 8,
+            padding: 14,
+            borderRadius: 'var(--d0nj-radius-lg, 12px)',
+            border: '1px solid var(--dsw-alias-border-l1)',
+            background: 'var(--dsw-alias-bg-base)',
+        },
+        row2: { display: 'flex', gap: 8, alignItems: 'center', flexWrap: 'wrap' },
+    };
+}
+/**
+ * Combobox state per role.
+ *
+ * Kept at module scope because the panel re-renders on every settings echo, and
+ * state created inside the render would reset to closed each pass.
+ */
+const combos = new Map();
+/** Exported so tests do not inherit an open list between cases. */
+export function resetCombos() {
+    combos.clear();
+}
+/**
+ * @param key - the role's accessible label.
+ * @returns the state for that role, created on first use.
+ */
+function comboState(key) {
+    const existing = combos.get(key);
+    if (existing !== undefined)
+        return existing;
+    const created = { open: false, query: '', active: 0 };
+    combos.set(key, created);
+    return created;
+}
+/**
+ * Fonts offered by the picker.
+ *
+ * Hosted rather than local: a browser cannot enumerate installed fonts without a
+ * permission-gated API most lack, and a local family looks different elsewhere.
+ */
+let fontChoiceCache;
+/** @returns the families the picker offers. */
+function fontChoices() {
+    fontChoiceCache ??= hostedFamilies();
+    return fontChoiceCache;
+}
+/**
+ * Render the Theme Studio page.
+ *
+ * Written against a minimal `React.createElement` shim rather than JSX so the
+ * module needs no transform at build time; the client bundle supplies React.
+ *
+ * @param React - the React namespace from the module table.
+ * @param props - current state and the actions to invoke.
+ * @returns the section element.
+ */
+export function ThemeStudio(React, props) {
+    const h = React.createElement;
+    const s = styles();
+    const { state, actions, presets } = props;
+    // Local mirrors. The panel must react to a click immediately: a settings write
+    // is a round-trip through the Host, and waiting for the echo makes every
+    // control feel dead when the write is slow, refused, or not mirrored at all.
+    // Local state is the source of truth for rendering; the action is the command.
+    const [localPreset, setLocalPreset] = React.useState(state.basePreset);
+    const [localTokens, setLocalTokens] = React.useState({});
+    const [localGeometry, setLocalGeometry] = React.useState(state.geometry);
+    const [localTypography, setLocalTypography] = React.useState(state.typography);
+    // The counter must keep changing: writing the same number makes React bail out.
+    const [renderTick, setRender] = React.useState(0);
+    const choices = fontChoices();
+    const rerender = () => setRender(renderTick + 1);
+    /**
+     * @param role - font role being changed.
+     * @param value - CSS stack to apply.
+     */
+    const applyFont = (role, value) => {
+        const hosted = findHostedFont(value);
+        if (hosted === undefined) {
+            actions.setFont(role, value);
+            return;
+        }
+        void loadHostedFont(hosted).then(() => actions.setFont(role, value));
+    };
+    /**
+     * @param ariaLabel - accessible name for the input.
+     * @param family - current stack.
+     * @param onChange - writes the chosen stack.
+     * @returns the combobox element.
+     */
+    const fontCombo = (ariaLabel, family, onChange) => {
+        const combo = comboState(ariaLabel);
+        // Not the word "Default", which could collide with a family of that name.
+        const DEFAULT_CHOICE = '\u0000default';
+        const isDefault = (choice) => choice === DEFAULT_CHOICE;
+        const matches = () => {
+            const query = combo.query.trim().toLowerCase();
+            if (query === '')
+                return [DEFAULT_CHOICE, ...choices.slice(0, 39)];
+            const filtered = choices.filter((choice) => choice.toLowerCase().includes(query));
+            const keepDefault = 'default (built-in)'.includes(query) || 'built-in'.includes(query);
+            return (keepDefault ? [DEFAULT_CHOICE, ...filtered] : filtered).slice(0, 40);
+        };
+        const commit = (value) => {
+            combo.open = false;
+            combo.query = '';
+            combo.active = 0;
+            const next = isDefault(value) ? '' : value;
+            if (next !== combo.written)
+                onChange(next);
+            combo.written = undefined;
+            rerender();
+        };
+        const visible = combo.open ? matches() : [];
+        return h('div', { style: s.combo }, h('input', {
+            type: 'text',
+            role: 'combobox',
+            style: s.select,
+            'aria-label': ariaLabel,
+            'aria-expanded': combo.open,
+            'aria-autocomplete': 'list',
+            placeholder: 'Default (built-in stack)',
+            value: family,
+            onFocus: (event) => {
+                combo.open = true;
+                combo.query = '';
+                combo.active = 0;
+                event.target.select?.();
+                rerender();
+            },
+            onInput: (event) => {
+                combo.open = true;
+                combo.query = event.target.value;
+                combo.active = 0;
+                combo.written = event.target.value;
+                onChange(event.target.value);
+                rerender();
+            },
+            onKeyDown: (event) => {
+                const list = visible;
+                if (event.key === 'Escape') {
+                    combo.open = false;
+                    combo.query = '';
+                    rerender();
+                    return;
+                }
+                if (event.key === 'ArrowDown' && list.length > 0) {
+                    event.preventDefault();
+                    combo.active = (combo.active + 1) % list.length;
+                    rerender();
+                    return;
+                }
+                if (event.key === 'ArrowUp' && list.length > 0) {
+                    event.preventDefault();
+                    combo.active = (combo.active - 1 + list.length) % list.length;
+                    rerender();
+                    return;
+                }
+                if (event.key === 'Enter') {
+                    const picked = list[combo.active];
+                    if (combo.open && picked !== undefined)
+                        commit(picked);
+                    else if (combo.open && combo.query.trim() !== '')
+                        commit(combo.query.trim());
+                }
+            },
+            onBlur: () => {
+                combo.open = false;
+                combo.query = '';
+                rerender();
+            },
+        }), combo.open && visible.length > 0
+            ? h('div', { style: s.listbox, role: 'listbox' }, ...visible.map((choice, index) => h('div', {
+                key: choice,
+                role: 'option',
+                'aria-selected': index === combo.active,
+                style: {
+                    ...s.option,
+                    ...(isDefault(choice) ? {} : { fontFamily: `"${choice}"` }),
+                    ...(index === combo.active ? s.optionActive : {}),
+                },
+                // Fires before the input's blur, which would close the list first.
+                onMouseDown: (event) => {
+                    event.preventDefault();
+                    commit(choice);
+                },
+            }, isDefault(choice) ? 'Default (built-in stack)' : choice)))
+            : null);
+    };
+    /** The preset currently selected, for filling a missing mode from its colours. */
+    const basePreset = presets.find((preset) => preset.id === (localPreset ?? state.basePreset));
+    /**
+     * The effective value of one token: the local edit, else the stored override,
+     * else the base preset's own value for that mode.
+     */
+    const effective = (name) => {
+        const local = localTokens[name];
+        if (local !== undefined)
+            return local;
+        const stored = state.tokens.find((row) => row.name === name)?.override;
+        if (stored !== undefined)
+            return stored;
+        const presetValue = basePreset === undefined ? undefined : basePreset.tokens[name];
+        return presetValue ?? { light: '', dark: '' };
+    };
+    const presetCards = [
+        { id: 'none', label: 'No preset', description: 'Start from the built-in palette.', colorScheme: 'dark', tokens: {} },
+        ...presets,
+    ].map((preset) => {
+        const base = preset.tokens['--dsw-alias-bg-base'];
+        const accent = preset.tokens['--dsw-alias-brand-primary'];
+        const label = preset.tokens['--dsw-alias-label-primary'];
+        const active = (localPreset ?? state.basePreset) === preset.id;
+        return h('button', {
+            key: preset.id,
+            type: 'button',
+            style: {
+                ...s.card,
+                // Paint the preset's own surface and text colour, so the grid shows what
+                // each theme looks like rather than the one currently applied.
+                background: base?.light ?? 'transparent',
+                color: label?.light ?? 'var(--dsw-alias-label-primary)',
+                ...(active ? s.cardActive : {}),
+            },
+            'aria-pressed': active,
+            onClick: () => {
+                setLocalPreset(preset.id);
+                setLocalTokens({});
+                actions.setPreset(preset.id);
+            },
+        }, h('div', { style: s.swatches }, h('span', { style: { ...s.swatch, background: base?.light ?? 'transparent' } }), h('span', { style: { ...s.swatch, background: base?.dark ?? 'transparent' } }), h('span', { style: { ...s.swatch, background: accent?.dark ?? 'transparent' } }), h('span', { style: { ...s.swatch, background: label?.dark ?? 'transparent' } })), h('span', { style: { fontSize: 13, fontWeight: 600 } }, preset.label), h('span', { style: s.hint }, preset.description));
+    });
+    const tokenRows = state.tokens.map((row) => {
+        const current = effective(row.name);
+        /**
+         * Apply one mode's edit and write both modes.
+         *
+         * The theme runtime needs a value for each scheme, so a half-typed row is
+         * completed from the preset rather than withheld: withholding was why typing
+         * appeared to do nothing until both fields happened to be filled.
+         */
+        const edit = (mode, value) => {
+            const next = { ...current, [mode]: value };
+            setLocalTokens({ ...localTokens, [row.name]: next });
+            if (next.light.length > 0 && next.dark.length > 0)
+                actions.setToken(row.name, next.light, next.dark);
+        };
+        return h('div', { key: row.name, style: s.row }, h('div', { style: s.rowLabel }, h('span', { style: { fontSize: 12, fontWeight: 600 } }, row.label), h('span', { style: s.hint }, row.description)), h('div', { style: s.row2 }, h('input', {
+            style: s.colorInput,
+            type: 'color',
+            'aria-label': `${row.label} light`,
+            value: /^#[0-9a-f]{6}$/iu.test(current.light) ? current.light : '#000000',
+            onChange: (event) => edit('light', event.target.value),
+        }), h('input', {
+            style: s.input,
+            type: 'text',
+            'aria-label': `${row.label} light value`,
+            placeholder: 'light',
+            value: current.light,
+            onChange: (event) => edit('light', event.target.value),
+        })), h('div', { style: s.row2 }, h('input', {
+            style: s.colorInput,
+            type: 'color',
+            'aria-label': `${row.label} dark`,
+            value: /^#[0-9a-f]{6}$/iu.test(current.dark) ? current.dark : '#000000',
+            onChange: (event) => edit('dark', event.target.value),
+        }), h('input', {
+            style: s.input,
+            type: 'text',
+            'aria-label': `${row.label} dark value`,
+            placeholder: 'dark',
+            value: current.dark,
+            onChange: (event) => edit('dark', event.target.value),
+        }), h('button', {
+            type: 'button',
+            style: s.button,
+            onClick: () => {
+                const next = { ...localTokens };
+                delete next[row.name];
+                setLocalTokens(next);
+                actions.clearToken(row.name);
+            },
+        }, 'Reset')));
+    });
+    const fontRow = (role, label, family, size) => {
+        const edit = (value) => {
+            const key = role === 'text' ? 'textFontFamily' : role === 'code' ? 'codeFontFamily' : 'terminalFontFamily';
+            setLocalTypography({ ...(localTypography ?? state.typography), [key]: value });
+            applyFont(role, value);
+        };
+        return h('div', { style: { ...s.row, ...s.fontRow } }, h('div', { style: s.rowLabel }, h('span', { style: { fontSize: 12, fontWeight: 600 } }, label)), fontCombo(`${label} font family`, family, edit), h('div', { style: s.row2 }, h('input', {
+            style: s.input,
+            type: 'number',
+            min: 8,
+            max: 24,
+            'aria-label': `${label} size`,
+            value: size,
+            onChange: (event) => {
+                const px = Number(event.target.value);
+                const key = role === 'text' ? 'fontSize' : role === 'code' ? 'codeFontSize' : 'terminalFontSize';
+                setLocalTypography({ ...(localTypography ?? state.typography), [key]: px });
+                actions.setFontSize(role, px);
+            },
+        }), h('span', { style: s.hint }, 'px')));
+    };
+    return h('div', { style: s.root }, state.writable
+        ? null
+        : h('div', { style: s.warning }, 'This profile does not accept settings writes; changes will not persist.'), h('section', { style: s.section }, h('h3', { style: s.heading }, 'Base theme'), h('p', { style: s.hint }, 'A preset supplies a complete token set. Tune individual values below it.'), h('div', { style: s.grid }, presetCards)), h('section', { style: s.section }, h('h3', { style: s.heading }, 'Live preview'), h('div', { style: s.preview }, h('span', { style: { fontSize: 15, fontWeight: 600 } }, 'The quick brown fox'), h('span', { style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)' } }, 'Secondary text sits one step down.'), h('div', { style: s.row2 }, h('span', { style: { ...s.button, background: 'var(--dsw-alias-brand-primary)', color: 'var(--dsw-alias-bg-base)' } }, 'Accent'), h('span', { style: { ...s.button, borderColor: 'var(--dsw-alias-state-error-primary)' } }, 'Error'), h('span', { style: { ...s.button, borderColor: 'var(--dsw-alias-state-success-primary)' } }, 'Success'), h('span', { style: { ...s.button, borderColor: 'var(--dsw-alias-state-warn-primary)' } }, 'Warning')))), h('section', { style: s.section }, h('h3', { style: s.heading }, 'Typography'), fontRow('text', 'Interface text', (localTypography ?? state.typography).textFontFamily, (localTypography ?? state.typography).fontSize), fontRow('code', 'Code', (localTypography ?? state.typography).codeFontFamily, (localTypography ?? state.typography).codeFontSize), fontRow('terminal', 'Terminal', (localTypography ?? state.typography).terminalFontFamily, (localTypography ?? state.typography).terminalFontSize)), h('section', { style: s.section }, h('h3', { style: s.heading }, 'Geometry'), h('div', { style: s.row }, h('div', { style: s.rowLabel }, h('span', { style: { fontSize: 12, fontWeight: 600 } }, 'Corner radius')), h('input', {
+        type: 'range',
+        min: 0,
+        max: 24,
+        value: (localGeometry ?? state.geometry).radius,
+        'aria-label': 'Corner radius',
+        onChange: (event) => {
+            const radius = Number(event.target.value);
+            setLocalGeometry({ ...(localGeometry ?? state.geometry), radius });
+            actions.setRadius(radius);
+        },
+    }), h('span', { style: s.hint }, `${String((localGeometry ?? state.geometry).radius)}px`)), h('div', { style: s.row }, h('div', { style: s.rowLabel }, h('span', { style: { fontSize: 12, fontWeight: 600 } }, 'Density')), h('div', { style: s.row2 }, ...['compact', 'comfortable', 'spacious'].map((density) => h('button', {
+        key: density,
+        type: 'button',
+        style: (localGeometry ?? state.geometry).density === density
+            ? { ...s.button, borderColor: 'var(--dsw-alias-brand-primary)' }
+            : s.button,
+        'aria-pressed': (localGeometry ?? state.geometry).density === density,
+        onClick: () => {
+            setLocalGeometry({ ...(localGeometry ?? state.geometry), density });
+            actions.setDensity(density);
+        },
+    }, density))), h('span', {}))), h('section', { style: s.section }, h('h3', { style: s.heading }, 'Colour tokens'), h('p', { style: s.hint }, 'Both values are required: one per palette mode, so switching scheme stays legible.'), ...tokenRows), state.warnings.length > 0
+        ? h('section', { style: s.section }, ...state.warnings.map((warning, index) => h('div', { key: String(index), style: s.warning }, warning)))
+        : null, h('section', { style: s.section }, h('button', { type: 'button', style: s.button, onClick: () => actions.resetAll() }, 'Reset all customization')));
+}
+//# sourceMappingURL=panel.js.map

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Host half: the customization document and its validation.
+ *
+ * The plugin does no rendering and holds no state of its own on the Host. It
+ * contributes one Config schema, which the profile stores and the browser half
+ * reads through its settings namespace, so a choice made in the panel survives a
+ * reload and a machine switch without this process tracking anything.
+ *
+ * `Config` is the contract; `resolve.ts` is the meaning. Keeping them apart means
+ * the panel can preview a change with the same resolver the stored document
+ * goes through, instead of reimplementing the merge rules in the browser.
+ *
+ * @module @d0nj/dsh-ui-custom
+ */
+import z from '@deepseek-ai/schemastery';
+import type { CustomizationDocument } from './resolve.js';
+/** Cordis plugin name used by Loader diagnostics. */
+export declare const name = "ui-custom";
+/** No services are required: this plugin only contributes configuration. */
+export declare const inject: readonly [];
+/**
+ * The plugin's config: one customization document.
+ *
+ * `basePreset` accepts any preset id or `none`. The resolver reports an unknown
+ * id as a warning rather than failing validation, because a stored document
+ * naming a preset from a newer version must not stop the plugin mounting.
+ */
+export declare const Config: ReturnType<typeof z.object>;
+/**
+ * The parsed shape of this plugin's config.
+ *
+ * Each field is volatile in the schema, so the Host hands `apply` a Volatile
+ * reference rather than a plain value; {@link toDocument} unwraps either form.
+ */
+export interface PluginConfig {
+    basePreset?: string;
+    tokens?: Record<string, {
+        light: string;
+        dark: string;
+    }>;
+    typography?: {
+        textFontFamily?: string;
+        codeFontFamily?: string;
+        terminalFontFamily?: string;
+        fontSize?: number;
+        codeFontSize?: number;
+        terminalFontSize?: number;
+    };
+    geometry?: {
+        radius?: number;
+        density?: 'compact' | 'comfortable' | 'spacious';
+    };
+}
+/**
+ * Project a stored config into a complete customization document.
+ *
+ * The schema defaults every field, but a config read back from a partially
+ * written document may still be missing sections, so this fills them once here
+ * rather than at each use site.
+ * @param config - the config handed to `apply`.
+ * @returns a complete document.
+ */
+export declare function toDocument(input: unknown): CustomizationDocument;
+/**
+ * Host plugin body.
+ *
+ * The Host contributes nothing at runtime: the browser half owns the theme
+ * layer and fonts, and the settings service owns persistence.
+ */
+export declare function apply(): void;
+export { PRESETS, TOKEN_SPECS, TOKEN_GROUPS, PRESET_IDS } from './spec.js';
+export { resolveCustomization } from './resolve.js';
+export type { CustomizationDocument, ResolvedCustomization } from './resolve.js';
+//# sourceMappingURL=index.d.ts.map