@twip/web 0.0.0-canary-f16fa12

package/dist/fonts/library.d.ts

@@ -0,0 +1,65 @@
+import { type Transport } from '../transport/protocol.js';
+/** A font the engine needs. */
+export interface FontRequest {
+    /** The family. */
+    family: string;
+    /** Bold. */
+    bold: boolean;
+    /** Italic. */
+    italic: boolean;
+}
+/** A face a library holds. */
+export interface FaceInfo {
+    /** The family. */
+    family: string;
+    /** Bold. */
+    bold: boolean;
+    /** Italic. */
+    italic: boolean;
+}
+/** Draws one family (optionally one style of it) with another. */
+export interface SubstitutionRule {
+    /** The family the document asks for. */
+    from: string;
+    /** Only the bold faces (or only the regular ones). */
+    bold?: boolean;
+    /** Only the italic faces (or only the upright ones). */
+    italic?: boolean;
+    /** The family to draw instead. */
+    to: string;
+}
+/** Where fonts come from for a request: adds the faces it finds, and resolves whether it found the family. */
+export type FontSource = (request: FontRequest, signal: AbortSignal) => Promise<boolean>;
+/**
+ * An engine an editor started, and the font requests it sends. Internal: the library's changes so far are replayed
+ * into it, and calls made after this keep their order with the editors'.
+ */
+export declare function useEngine(transport: Transport): Transport;
+/**
+ * Answers the engine's request for a font: the application's resolver first, then Google Fonts. When neither adds
+ * the family, the engine marks it unresolved. Internal.
+ */
+export declare function answerFontRequest(request: FontRequest): Promise<void>;
+/**
+ * The fonts editors draw with. Share one per page: every editor on the page uses {@link FontLibrary.default}, and a
+ * font added there reaches every editor, including ones already open.
+ */
+export declare class FontLibrary {
+    private constructor();
+    /** The page's library. */
+    static default(): FontLibrary;
+    /** Adds font files: TTF, OTF and TTC bytes, or a URL to fetch them from. */
+    add(source: Uint8Array | URL | string): Promise<FaceInfo[]>;
+    /** Fetches fonts the engine asks for: resolve with the bytes, a URL, or null when there is none. */
+    setResolver(resolver: (request: FontRequest, signal: AbortSignal) => Promise<Uint8Array | URL | null>): void;
+    /** Resolves missing fonts from Google Fonts, optionally only some families. */
+    useGoogleFonts(options?: {
+        families?: string[];
+    }): void;
+    /** Draws families with others: `{ 'Times New Roman': 'Tinos' }`, or rules per style. */
+    substitute(rules: Record<string, string> | SubstitutionRule[]): void;
+    /** The family for text whose font can't be found. */
+    setDefault(family: string): void;
+    /** Every family the library can draw now, for a font box. */
+    families(): Promise<string[]>;
+}

package/dist/fonts/library.js

@@ -0,0 +1,130 @@
+import { EditorError } from '../errors.js';
+import { directTransport } from '../transport/direct.js';
+import { Kind, Method } from '../transport/protocol.js';
+import { googleFonts } from './google.js';
+let page;
+let appResolver;
+let google;
+/** The page's engines, first started first: this thread's and the engine worker's, once editors started them. */
+const engines = [];
+/** The library's changes so far, replayed into an engine that starts later. */
+const changes = [];
+/**
+ * An engine an editor started, and the font requests it sends. Internal: the library's changes so far are replayed
+ * into it, and calls made after this keep their order with the editors'.
+ */
+export function useEngine(transport) {
+    if (!engines.includes(transport)) {
+        engines.push(transport);
+        for (const apply of changes)
+            report(apply(transport));
+        // The library is the engine's, so its requests name no session.
+        transport.listen(0, (m) => {
+            if (m.kind === Kind.FontRequest)
+                void answerFontRequest(m.payload);
+        });
+    }
+    return transport;
+}
+/** Runs `use` on the page's first engine, loading the engine on this thread when no editor has started one. */
+function withEngine(use) {
+    return engines[0] ? use(engines[0]) : directTransport().then((t) => use(engines[0] ?? useEngine(t)));
+}
+/** Applies a change to every engine and to the ones that start later; resolves with the first engine's answer. */
+function change(apply) {
+    return withEngine((first) => {
+        changes.push(apply);
+        for (const e of engines)
+            if (e !== first)
+                report(apply(e));
+        return apply(first);
+    });
+}
+/** A library call: the font library is the engine's, so no session is named. Only `FontFamilies` changes nothing. */
+function libraryCall(method, request) {
+    const call = (e) => e.call(0, method, request);
+    return method === Method.FontFamilies ? withEngine(call) : change(call);
+}
+/** The failure of a call a synchronous method started: reported, as there is no promise to reject. */
+function report(call) {
+    call.catch((e) => console.error(e));
+}
+/** Fetches a font file. */
+async function fetchFont(url, signal) {
+    const response = await fetch(url, { signal });
+    if (!response.ok)
+        throw new EditorError('unavailable', `${String(url)}: HTTP ${response.status}`);
+    return new Uint8Array(await response.arrayBuffer());
+}
+/** Adds font bytes, or the file at a URL, to the page's library. */
+async function addFont(source, signal) {
+    const bytes = source instanceof Uint8Array ? source : await fetchFont(source, signal);
+    return change((e) => e.addFont(bytes));
+}
+/** With a source to ask, the engine requests missing faces instead of calling them unresolved at once. */
+function askEngine() {
+    report(libraryCall(Method.FontSetResolver, true));
+}
+const sameFamily = (a, b) => a.localeCompare(b, undefined, { sensitivity: 'accent' }) === 0;
+/**
+ * Answers the engine's request for a font: the application's resolver first, then Google Fonts. When neither adds
+ * the family, the engine marks it unresolved. Internal.
+ */
+export async function answerFontRequest(request) {
+    // shortcut: the signal never fires; abort it when every session that asked for the font is destroyed.
+    const signal = new AbortController().signal;
+    const resolver = appResolver;
+    const fromResolver = resolver &&
+        (async (r, sig) => {
+            const found = await resolver(r, sig);
+            return found !== null && (await addFont(found, sig)).some((face) => sameFamily(face.family, r.family));
+        });
+    for (const source of [fromResolver, google]) {
+        try {
+            if (source && (await source(request, signal)))
+                return;
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    report(libraryCall(Method.FontMarkUnresolved, request));
+}
+/**
+ * The fonts editors draw with. Share one per page: every editor on the page uses {@link FontLibrary.default}, and a
+ * font added there reaches every editor, including ones already open.
+ */
+export class FontLibrary {
+    constructor() { }
+    /** The page's library. */
+    static default() {
+        return (page ??= new FontLibrary());
+    }
+    /** Adds font files: TTF, OTF and TTC bytes, or a URL to fetch them from. */
+    add(source) {
+        return addFont(source);
+    }
+    /** Fetches fonts the engine asks for: resolve with the bytes, a URL, or null when there is none. */
+    setResolver(resolver) {
+        appResolver = resolver;
+        askEngine();
+    }
+    /** Resolves missing fonts from Google Fonts, optionally only some families. */
+    useGoogleFonts(options) {
+        google = googleFonts(addFont, options?.families);
+        askEngine();
+    }
+    /** Draws families with others: `{ 'Times New Roman': 'Tinos' }`, or rules per style. */
+    substitute(rules) {
+        const list = Array.isArray(rules) ? rules : Object.entries(rules).map(([from, to]) => ({ from, to }));
+        report(libraryCall(Method.FontSetSubstitutions, list));
+    }
+    /** The family for text whose font can't be found. */
+    setDefault(family) {
+        report(libraryCall(Method.FontSetDefault, family));
+    }
+    /** Every family the library can draw now, for a font box. */
+    families() {
+        return libraryCall(Method.FontFamilies);
+    }
+}

package/dist/host/a11y.d.ts

@@ -0,0 +1,3 @@
+import type { Session } from '../editor.js';
+import type { Dom, Ledger } from './dom.js';
+export declare function startA11y(s: Session, dom: Dom, ledger: Ledger): void;

package/dist/host/a11y.js

@@ -0,0 +1,62 @@
+import { Kind } from '../transport/protocol.js';
+const roles = {
+    document: 'document',
+    page: 'region',
+    paragraph: 'paragraph',
+    heading: 'heading',
+    list: 'list',
+    listItem: 'listitem',
+    table: 'table',
+    row: 'row',
+    cell: 'cell',
+    image: 'img',
+    link: 'link',
+    textBox: 'group',
+    note: 'note',
+    header: 'region',
+    footer: 'region',
+};
+const hidden = 'position:absolute;left:0;top:0;width:1px;height:1px;overflow:hidden;clip-path:inset(50%);white-space:nowrap;';
+function build(node) {
+    const e = document.createElement('div');
+    e.setAttribute('role', roles[node.role] ?? 'group');
+    if (node.name)
+        e.setAttribute('aria-label', node.name);
+    if (node.level !== undefined)
+        e.setAttribute('aria-level', String(node.level));
+    const marks = node.marks ?? [];
+    if (marks.includes('misspelling'))
+        e.setAttribute('aria-invalid', 'spelling');
+    const review = marks.filter((m) => m !== 'misspelling');
+    if (review.length)
+        e.setAttribute('aria-description', review.join(' '));
+    if (node.text)
+        e.append(node.text);
+    for (const child of node.children)
+        e.append(build(child));
+    return e;
+}
+export function startA11y(s, dom, ledger) {
+    const tree = ledger.node(dom.layer, document.createElement('div'));
+    tree.dataset.twip = 'a11y';
+    tree.style.cssText = hidden;
+    const live = ledger.node(dom.layer, document.createElement('div'));
+    live.dataset.twip = 'live';
+    live.setAttribute('aria-live', 'polite');
+    live.setAttribute('role', 'status');
+    live.style.cssText = hidden;
+    const onMessage = (m) => {
+        const r = m.payload;
+        if (m.kind === Kind.HostRequest && r.type === 'a11y')
+            tree.replaceChildren(build(r.tree));
+    };
+    s.hostListeners.add(onMessage);
+    s.disposers.push(() => s.hostListeners.delete(onMessage));
+    // A repeated announcement is read again: the region empties first.
+    let cancel;
+    s.disposers.push(s.on('announcement', ({ text }) => {
+        live.textContent = '';
+        cancel?.();
+        cancel = ledger.timeout(() => (live.textContent = text), 50);
+    }));
+}

package/dist/host/chrome.d.ts

@@ -0,0 +1,28 @@
+import type { Op } from '../commands.js';
+import type { Session } from '../editor.js';
+import type { View } from '../services/view.js';
+import { type FrameInfo } from '../transport/protocol.js';
+import type { ClientPoint, CommentId, ElementId } from '../types.js';
+import type { Dom, Ledger } from './dom.js';
+import type { Frames } from './frames.js';
+export interface Chrome {
+    view: View;
+    balloonLayer: HTMLElement;
+    attachBalloon(thread: CommentId, card: HTMLElement): () => void;
+    setMarkupPaneWidth(width: number): Promise<void>;
+    hitTest(at: ClientPoint): Promise<{
+        element: ElementId | null;
+        editable: boolean;
+    }>;
+    dragOver(at: ClientPoint): void;
+    dragLeave(): void;
+    drop(at: ClientPoint, op: Op): Promise<void>;
+    /** After each frame: the visible pages, and the balloons for the anchors it reported. */
+    framed(info: FrameInfo): void;
+    /** The engine draws the balloons' leader lines (the `drawLeaders` mount option). */
+    drawLeaders(on: boolean): void;
+}
+export declare function startChrome(s: Session, dom: Dom, ledger: Ledger, frames: Frames, report: (e: unknown) => void, toViewport: (at: ClientPoint) => {
+    x: number;
+    y: number;
+}): Chrome;

package/dist/host/chrome.js

@@ -0,0 +1,144 @@
+import { stackBalloons } from '../review.js';
+import { Method } from '../transport/protocol.js';
+/** The space between a page and its balloons, and between balloons, CSS px. */
+const GAP = 8;
+export function startChrome(s, dom, ledger, frames, report, toViewport) {
+    const layer = ledger.node(dom.content, document.createElement('div'));
+    layer.dataset.twip = 'balloons';
+    layer.style.cssText = 'position:absolute;inset:0;pointer-events:none;';
+    // Balloons: each attached card beside its thread's anchor, stacked, and placed again after every anchors change.
+    const cards = new Map();
+    let anchors = [];
+    let pane = 0;
+    let leaders = false;
+    const place = () => {
+        const shown = anchors.filter((a) => cards.has(a.thread));
+        for (const [thread, card] of cards)
+            card.style.display = shown.some((a) => a.thread === thread) ? '' : 'none';
+        if (!shown.length && !cards.size)
+            return;
+        const heights = shown.map((a) => cards.get(a.thread).offsetHeight);
+        const tops = stackBalloons(shown, heights, GAP);
+        const placements = shown.map((a, i) => {
+            const left = pane > 0 ? frames.info.contentWidth - pane + GAP : a.pageEdge + GAP;
+            const top = tops[i];
+            const card = cards.get(a.thread);
+            card.style.left = `${left}px`;
+            card.style.top = `${top}px`;
+            return { thread: a.thread, top, left, leader: [a.start, { x: a.pageEdge, y: a.start.y }, { x: left, y: top + Math.min(heights[i], a.lineBottom - a.lineTop) / 2 }] };
+        });
+        s.emit('balloonsLaidOut', placements);
+        if (leaders)
+            s.call(Method.HostSetLeaders, placements.map((p) => p.leader)).then(() => frames.request(), report);
+    };
+    s.disposers.push(s.on('commentAnchors', (a) => {
+        anchors = a;
+        place();
+    }));
+    // The pages on screen, viewport px from the engine after each frame; client px when read.
+    let pages = [];
+    const framed = () => {
+        if (s.destroyed)
+            return;
+        s.call(Method.HostVisiblePages).then((p) => (pages = p), report);
+    };
+    // The caret's blink follows the platform's reduced-motion setting until the application sets it.
+    const blink = async (ms, stopAfterMs) => {
+        await s.call(Method.HostSetCaretBlink, { intervalMs: ms > 0 ? ms : null, stopAfterMs: stopAfterMs ?? null });
+    };
+    let motion = globalThis.matchMedia?.('(prefers-reduced-motion: reduce)');
+    if (motion) {
+        const follow = () => {
+            if (motion)
+                blink(motion.matches ? 0 : 530).catch(report);
+        };
+        ledger.listen(motion, 'change', follow);
+        if (motion.matches)
+            follow();
+    }
+    // The overlay colours: the engine's, or the system's in forced-colours mode until the application sets them.
+    const defaults = { caret: '#000000', selection: '#B3D7FF', object: '#606060', drop: '#404040', marks: '#2F6FB5', leaders: '#767676' };
+    let overlay = defaults;
+    const system = (css) => {
+        const probe = Object.assign(document.createElement('span'), { hidden: true });
+        probe.style.color = css;
+        document.body.append(probe);
+        const [r, g, b] = (getComputedStyle(probe).color.match(/\d+/g) ?? ['0', '0', '0']).map(Number);
+        probe.remove();
+        return `#${[r, g, b].map((v) => (v ?? 0).toString(16).padStart(2, '0')).join('').toUpperCase()}`;
+    };
+    const paint = (colors) => s.call(Method.HostSetOverlayPalette, colors).then(() => frames.request());
+    let forced = globalThis.matchMedia?.('(forced-colors: active)');
+    if (forced) {
+        const follow = () => {
+            if (!forced)
+                return;
+            const text = system('CanvasText');
+            overlay = forced.matches ? { caret: text, selection: system('Highlight'), object: text, drop: text, marks: system('GrayText'), leaders: system('GrayText') } : defaults;
+            paint(overlay).catch(report);
+        };
+        ledger.listen(forced, 'change', follow);
+        if (forced.matches)
+            follow();
+    }
+    const set = async (method, value) => {
+        await s.call(method, value);
+        frames.request();
+    };
+    const view = {
+        revealSelection: () => s.call(Method.HostRevealSelection),
+        setBackground: async (color) => {
+            await set(Method.HostSetBackground, color);
+            dom.scroller.style.background = color;
+        },
+        visiblePages: () => {
+            const r = dom.canvas.getBoundingClientRect();
+            return pages.map(({ page, rect }) => ({ page, rect: { ...rect, left: rect.left + r.left, top: rect.top + r.top } }));
+        },
+        frameStats: () => s.call(Method.HostFrameStats),
+        setOverlayColors: (colors) => {
+            forced = undefined;
+            overlay = { ...overlay, ...colors };
+            return paint(overlay);
+        },
+        setCaretBlink: (ms, stopAfterMs) => {
+            motion = undefined;
+            return blink(ms, stopAfterMs);
+        },
+    };
+    return {
+        view,
+        balloonLayer: layer,
+        drawLeaders: (on) => {
+            leaders = on;
+            if (on)
+                place();
+            else
+                s.call(Method.HostSetLeaders, []).then(() => frames.request(), report);
+        },
+        attachBalloon: (thread, card) => {
+            cards.get(thread)?.remove();
+            card.style.position = 'absolute';
+            card.style.pointerEvents = 'auto';
+            cards.set(thread, card);
+            layer.append(card);
+            place();
+            return () => {
+                if (cards.get(thread) !== card)
+                    return;
+                cards.delete(thread);
+                card.remove();
+                place();
+            };
+        },
+        setMarkupPaneWidth: async (width) => {
+            await set(Method.HostSetMarkupPaneWidth, width);
+            pane = Number.isFinite(width) ? Math.max(0, width) : 0;
+        },
+        hitTest: (at) => s.call(Method.HostHitTest, toViewport(at)),
+        dragOver: (at) => void s.call(Method.HostDragOver, toViewport(at)).then(frames.request, report),
+        dragLeave: () => void s.call(Method.HostDragLeave).then(frames.request, report),
+        drop: (at, op) => s.commit(Method.HostDrop, { at: toViewport(at), command: op }),
+        framed,
+    };
+}

package/dist/host/clipboard.d.ts

@@ -0,0 +1,16 @@
+import type { Session } from '../editor.js';
+import type { Dom, Ledger } from './dom.js';
+/** The clipboard of a mounted editor. */
+export interface Clipboard {
+    /** `commands.paste`: reads the system clipboard (`not-allowed` when the browser refuses), then pastes. */
+    paste(options?: {
+        as?: 'formatted' | 'text';
+    }): Promise<void>;
+}
+export declare function startClipboard(s: Session, dom: Dom, input: HTMLTextAreaElement, ledger: Ledger, report: (e: unknown) => void, toViewport: (e: {
+    clientX: number;
+    clientY: number;
+}) => {
+    x: number;
+    y: number;
+}): Clipboard;

package/dist/host/clipboard.js

@@ -0,0 +1,128 @@
+import { EditorError } from '../errors.js';
+import { Kind, Method } from '../transport/protocol.js';
+/** The last copy on the page: the system clipboard has no place for its token, so a paste brings it back (the engine
+ * pastes the copy it names only while the text is still that copy's). */
+let lastCopy;
+function escapeHtml(text) {
+    return text.replace(/[&<>]/g, (c) => `&${{ '&': 'amp', '<': 'lt', '>': 'gt' }[c]};`).replace(/\n/g, '<br>');
+}
+export function startClipboard(s, dom, input, ledger, report, toViewport) {
+    const write = (data) => {
+        // Without `ClipboardItem` (older Firefox) the event's synchronous text is the copy.
+        if (typeof ClipboardItem === 'undefined' || !navigator.clipboard?.write)
+            return;
+        const blob = (type, pick) => data.then((d) => {
+            if (!d)
+                throw new Error('nothing was copied');
+            return new Blob([pick(d)], { type });
+        });
+        let item;
+        try {
+            item = new ClipboardItem({
+                'text/plain': blob('text/plain', (d) => d.text),
+                'text/html': blob('text/html', (d) => d.html ?? escapeHtml(d.text)),
+            });
+        }
+        catch {
+            // A `ClipboardItem` that takes no promises: the synchronous text stands.
+            return;
+        }
+        // With nothing copied the write fails, and the clipboard keeps what it had.
+        navigator.clipboard.write([item]).catch((e) => data.then((d) => d && report(e), () => { }));
+    };
+    const onMessage = (m) => {
+        const r = m.payload;
+        if (m.kind !== Kind.HostRequest || r.type !== 'clipboard')
+            return;
+        // A copy the engine asks for (a menu's).
+        lastCopy = r.data;
+        write(Promise.resolve(r.data));
+    };
+    s.hostListeners.add(onMessage);
+    s.disposers.push(() => s.hostListeners.delete(onMessage));
+    // Queued now, so keys pressed after it run after it.
+    const copy = (cut) => s.call(Method.Copy, { cut }).then((d) => {
+        if (d)
+            lastCopy = d;
+        return d;
+    });
+    const onCopy = (cut) => (e) => {
+        e.preventDefault();
+        // The engine answers later (in worker mode, from another thread), so the event gets the selection's plain text
+        // now, mirrored in the state: it is the copy where the formatted write below can't run.
+        const text = s.state.selection.text;
+        if (text)
+            e.clipboardData?.setData('text/plain', text);
+        const data = copy(cut);
+        data.catch(report);
+        // The write starts inside the event, which keeps the user's activation; the data follows from the engine.
+        write(data);
+    };
+    ledger.listen(input, 'copy', onCopy(false));
+    ledger.listen(input, 'cut', onCopy(true));
+    const lines = (text) => text.replace(/\r\n/g, '\n');
+    const paste = async (data, asText) => {
+        const text = lines(data.text);
+        if (!text)
+            return;
+        const internal = lastCopy?.internal;
+        await s.call(Method.Paste, { data: { ...data, text, ...(internal ? { internal } : {}) }, asText });
+    };
+    // Ctrl+Shift+V pastes as text.
+    let plain = false;
+    ledger.listen(input, 'keydown', (e) => {
+        plain = (e.ctrlKey || e.metaKey) && e.shiftKey && e.code === 'KeyV';
+    });
+    ledger.listen(input, 'paste', (e) => {
+        e.preventDefault();
+        const t = e.clipboardData;
+        if (!t)
+            return;
+        const html = t.getData('text/html');
+        paste({ text: t.getData('text/plain'), ...(html ? { html } : {}) }, plain).catch(report);
+        plain = false;
+    });
+    // External drags: text and images from outside the editor, shown with the drop caret.
+    const external = (e) => !!e.dataTransfer && ['Files', 'text/plain', 'text/html'].some((t) => e.dataTransfer.types.includes(t));
+    ledger.listen(dom.scroller, 'dragover', (e) => {
+        if (!external(e))
+            return;
+        e.preventDefault();
+        e.dataTransfer.dropEffect = 'copy';
+        s.call(Method.HostDragOver, toViewport(e)).catch(report);
+    });
+    ledger.listen(dom.scroller, 'dragleave', (e) => {
+        if (!external(e) || dom.scroller.contains(e.relatedTarget))
+            return;
+        s.call(Method.HostDragLeave).catch(report);
+    });
+    ledger.listen(dom.scroller, 'drop', (e) => {
+        if (!external(e))
+            return;
+        e.preventDefault();
+        const t = e.dataTransfer;
+        const at = toViewport(e);
+        const image = [...t.files].find((f) => f.type.startsWith('image/'));
+        const op = image
+            ? image.arrayBuffer().then((b) => ({ type: 'insertPicture', data: new Uint8Array(b) }))
+            : Promise.resolve(t.getData('text/plain') ? { type: 'pasteText', value: t.getData('text/plain') } : null);
+        op.then((command) => (command ? s.commit(Method.HostDrop, { at, command }) : s.call(Method.HostDragLeave))).catch(report);
+    });
+    return {
+        paste: async (options) => {
+            let items;
+            try {
+                items = await navigator.clipboard.read();
+            }
+            catch (cause) {
+                throw new EditorError('not-allowed', 'the browser refused to read the clipboard', { cause });
+            }
+            const read = async (type) => {
+                const item = items.find((i) => i.types.includes(type));
+                return item ? (await item.getType(type)).text() : '';
+            };
+            const [text, html] = await Promise.all([read('text/plain'), read('text/html')]);
+            await s.guard(() => paste({ text, ...(html ? { html } : {}) }, options?.as === 'text'));
+        },
+    };
+}

package/dist/host/cursors.d.ts

@@ -0,0 +1,15 @@
+export declare const CELL_SELECT: {
+    url: string;
+    x: number;
+    y: number;
+};
+export declare const COLUMN_SELECT: {
+    url: string;
+    x: number;
+    y: number;
+};
+export declare const ROW_SELECT: {
+    url: string;
+    x: number;
+    y: number;
+};

package/dist/host/cursors.js

@@ -0,0 +1,5 @@
+// Generated by bindings/dotnet/Twip.WinForms/Cursors/make-cursors.py: do not edit.
+// The table and margin selection cursors as .cur data URLs, with their hotspots.
+export const CELL_SELECT = { url: 'data:image/x-icon;base64,AAACAAEAICAAAB0AAwCoEAAAFgAAACgAAAAgAAAAQAAAAAEAIAAAAAAAgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///9Q////UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////YP//////////////YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///2D/////YGBg/2BgYP//////////YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///9Q/////2BgYP8AAAD/AAAA/2BgYP//////////YAAAAAAAAAAAAAAAAAAAAAD///9Q////QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///1D/////YGBg/wAAAP8AAAD/AAAA/2BgYP//////////YAAAAAAAAAAA////YP////////+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///2D/////YGBg/wAAAP8AAAD/AAAA/2BgYP//////////YP///2D/////z8/P/////4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///2D/////YGBg/wAAAP8AAAD/AAAA/2BgYP///////////2BgYP+AgID/////gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///2D/////YGBg/wAAAP8AAAD/AAAA/1BQUP9QUFD/AAAA/4CAgP////+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///2D/////YGBg/wAAAP8AAAD/AAAA/wAAAP8AAAD/gICA/////4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///2D/////UFBQ/wAAAP8AAAD/AAAA/wAAAP+AgID/////gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////YP////9QUFD/AAAA/wAAAP8AAAD/AAAA/4CAgP////+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///2D/////YGBg/wAAAP8AAAD/AAAA/wAAAP8AAAD/gICA/////4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///9Q/////8/Pz/+AgID/gICA/4CAgP+AgID/gICA/4CAgP+/v7//////gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///0D///+A////gP///4D///+A////gP///4D///+A////gP///4D///9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=', x: 29, y: 3 };
+export const COLUMN_SELECT = { url: 'data:image/x-icon;base64,AAACAAEAICAAABAADgCoEAAAFgAAACgAAAAgAAAAQAAAAAEAIAAAAAAAgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////UP///1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///2D//////////////2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///9g/////2BgYP9gYGD//////////2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////YP////9gYGD/AAAA/wAAAP9gYGD//////////2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///2D/////YGBg/wAAAP8AAAD/AAAA/wAAAP9gYGD//////////2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///9Q/////8/Pz/+AgID/QEBA/wAAAP8AAAD/QEBA/4CAgP/Pz8///////////1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///0D///+A////gP///7+AgID/AAAA/wAAAP+AgID/////v////4D///+A////QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////gICAgP8AAAD/AAAA/4CAgP////+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///+AgICA/wAAAP8AAAD/gICA/////4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///4CAgID/AAAA/wAAAP+AgID/////gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////gICAgP8AAAD/AAAA/4CAgP////+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///+Av7+//4CAgP+AgID/v7+//////4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///0D///+A////gP///4D///+A////QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=', x: 16, y: 14 };
+export const ROW_SELECT = { url: 'data:image/x-icon;base64,AAACAAEAICAAAB0AAwCoEAAAFgAAACgAAAAgAAAAQAAAAAEAIAAAAAAAgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAA3xAQEP8AAADfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAQEBD//////yAgIP8AAABgAAAAAAAAAAAAAAAAAAAAAAAAAFAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+fn5//n5+f/wAAAN8AAAAAAAAAAAAAAAAAAABgAAAA/wAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCAgIP//////ICAg/wAAAGAAAAAAAAAAYAAAAP8wMDD/AAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA35+fn/+fn5//AAAA3wAAAGAAAAD/n5+f/4CAgP8AAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgICAg//////8gICD/AAAA/5+fn///////gICA/wAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAIAAAACAAAAAgAAAAIAAAAD/n5+f/7+/v/+vr6////////////+AgID/AAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAD/MDAw/4CAgP+AgID/gICA/4CAgP+/v7///////////////////////4CAgP8AAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAD/n5+f////////////////////////////////////////////gICA/wAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAD/n5+f//////////////////////////////////////+AgID/AAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAD/n5+f/////////////////////////////////4CAgP8AAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAD/n5+f////////////////////////////gICA/wAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAD/n5+f//////////////////////+AgID/AAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAD/n5+f/////////////////4CAgP8AAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAD/n5+f////////////gICA/wAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAD/n5+f//////+AgID/AAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAD/n5+f/4CAgP8AAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAD/MDAw/wAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAD/AAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=', x: 29, y: 3 };