lean4monaco 1.0.42 → 1.0.45

package/dist/vscode-lean4/lean4-infoview/src/infoview/event.js

@@ -0,0 +1,57 @@
+export class EventEmitter {
+    freshId = 0;
+    handlers = new Map();
+    handlersWithKey = new Map();
+    current;
+    /**
+     * Register a handler that will receive events from this emitter
+     * and return a closure that removes the handler registration.
+     *
+     * If `key` is specified, only events fired with that key
+     * will be propagated to this handler.
+     */
+    on(handler, key) {
+        const id = this.freshId;
+        this.freshId += 1;
+        if (key) {
+            const handlersForKey = this.handlersWithKey.get(key) ?? [];
+            handlersForKey.push(handler);
+            this.handlersWithKey.set(key, handlersForKey);
+        }
+        else {
+            this.handlers.set(id, handler);
+        }
+        return {
+            dispose: () => {
+                if (key) {
+                    const handlersForKey = this.handlersWithKey.get(key) ?? [];
+                    // We assume that no key has so many handlers registered
+                    // that the linear `filter` operation becomes a perf issue.
+                    this.handlersWithKey.set(key, handlersForKey.filter(h => h !== handler));
+                }
+                else {
+                    this.handlers.delete(id);
+                }
+            },
+        };
+    }
+    /**
+     * Propagate the event to registered handlers.
+     *
+     * The event is propagated to all keyless handlers.
+     * Furthermore if `key` is provided,
+     * the event is also propagated to handlers registered with that key.
+     */
+    fire(event, key) {
+        this.current = event;
+        for (const h of this.handlers.values()) {
+            h(event);
+        }
+        if (key) {
+            const handlersForKey = this.handlersWithKey.get(key) ?? [];
+            for (const h of handlersForKey) {
+                h(event);
+            }
+        }
+    }
+}

package/dist/vscode-lean4/lean4-infoview/src/infoview/serverVersion.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Keeps track of the Lean server version and available features.
+ * @module
+ */
+export declare class ServerVersion {
+    major: number;
+    minor: number;
+    patch: number;
+    constructor(version: string);
+}

package/dist/vscode-lean4/lean4-infoview/src/infoview/serverVersion.js

@@ -0,0 +1,25 @@
+/**
+ * Keeps track of the Lean server version and available features.
+ * @module
+ */
+export class ServerVersion {
+    major;
+    minor;
+    patch;
+    constructor(version) {
+        const vs = version.split('.');
+        if (vs.length === 2) {
+            this.major = parseInt(vs[0]);
+            this.minor = parseInt(vs[1]);
+            this.patch = 0;
+        }
+        else if (vs.length === 3) {
+            this.major = parseInt(vs[0]);
+            this.minor = parseInt(vs[1]);
+            this.patch = parseInt(vs[2]);
+        }
+        else {
+            throw new Error(`cannot parse Lean server version '${version}'`);
+        }
+    }
+}

package/dist/vscode-lean4/lean4-infoview/src/infoview/util.d.ts

@@ -0,0 +1,141 @@
+import * as React from 'react';
+import type { DocumentUri, Position, Range, TextDocumentPositionParams } from 'vscode-languageserver-protocol';
+import { EventEmitter } from './event';
+/** A document URI and a position in that document. */
+export interface DocumentPosition extends Position {
+    uri: DocumentUri;
+}
+export declare namespace DocumentPosition {
+    function isEqual(p1: DocumentPosition, p2: DocumentPosition): boolean;
+    function toTdpp(p: DocumentPosition): TextDocumentPositionParams;
+    function toString(p: DocumentPosition): string;
+}
+export declare namespace PositionHelpers {
+    function isLessThanOrEqual(p1: Position, p2: Position): boolean;
+}
+export declare namespace RangeHelpers {
+    function contains(range: Range, pos: Position, ignoreCharacter?: boolean): boolean;
+}
+export declare function escapeHtml(s: string): string;
+/** @deprecated (unused) */
+export declare function colorizeMessage(goal: string): string;
+export declare function basename(path: string): string;
+/**
+ * A specialization of {@link React.useEffect} which executes `f` with the event data
+ * whenever `ev` fires.
+ * If `key` is provided, `f` is only invoked on events fired with that key.
+ */
+export declare function useEvent<E, K>(ev: EventEmitter<E, K>, f: (_: E) => void, dependencies?: React.DependencyList, key?: K): void;
+/**
+ * A piece of React {@link React.useState} which returns the data that `ev` most recently fired with.
+ * If `f` is provided, the data is mapped through `f` first. */
+export declare function useEventResult<E, K>(ev: EventEmitter<E, K>): E | undefined;
+export declare function useEventResult<E, K, T>(ev: EventEmitter<E, K>, f: (newVal: E) => T): T | undefined;
+export declare function useServerNotificationEffect<T>(method: string, f: (params: T) => void, deps?: React.DependencyList): void;
+/**
+ * Returns the same tuple as `setState` such that whenever a server notification with `method`
+ * arrives at the editor, the state will be updated according to `f`.
+ */
+export declare function useServerNotificationState<S, T>(method: string, initial: S, f: (params: T) => Promise<(state: S) => S>, deps?: React.DependencyList): [S, React.Dispatch<React.SetStateAction<S>>];
+export declare function useClientNotificationEffect<T>(method: string, f: (params: T) => void, deps?: React.DependencyList): void;
+/**
+ * Like {@link useServerNotificationState} but for client->server notifications sent by the editor.
+ */
+export declare function useClientNotificationState<S, T>(method: string, initial: S, f: (state: S, params: T) => S, deps?: React.DependencyList): [S, React.Dispatch<React.SetStateAction<S>>];
+/** Useful for controlling {@link usePausableState} from child components. */
+export interface PausableProps {
+    isPaused: boolean;
+    setPaused: React.Dispatch<React.SetStateAction<boolean>>;
+}
+/**
+ * Returns `[{ isPaused, setPaused }, tPausable, tRef]` s.t.
+ * - `[isPaused, setPaused]` are the paused status state
+ * - for as long as `isPaused` is set, `tPausable` holds its initial value (the `t` passed before pausing)
+ *   rather than updates with changes to `t`.
+ * - `tRef` can be used to overwrite the paused state
+ *
+ * To pause child components, `startPaused` can be passed in their props.
+ */
+export declare function usePausableState<T>(startPaused: boolean, t: T): [PausableProps, T, React.MutableRefObject<T>];
+export type Keyed<T> = T & {
+    key: string;
+};
+/**
+ * Adds a unique `key` property to each element in `elems` using
+ * the values of (possibly non-injective) `getId`.
+ */
+export declare function addUniqueKeys<T>(elems: T[], getId: (el: T) => string): Keyed<T>[];
+export interface LogicalDomElement {
+    contains(el: Node): boolean;
+}
+export interface LogicalDomStorage {
+    /** Registers a descendant in the logical DOM.
+     * Returns a function which disposes of the registration. */
+    registerDescendant(el: LogicalDomElement): () => void;
+}
+export declare const LogicalDomContext: React.Context<LogicalDomStorage>;
+/** Suppose a component B appears as a React descendant of the component A. For layout reasons,
+ * we sometimes don't want B to appear as a descendant of A in the DOM, so we use `createPortal`.
+ * We may still however want to carry out `contains` checks as if B were there, i.e. according to
+ * the React tree structure rather than the DOM structure. While React already correctly propagates
+ * DOM events up the React tree, other functionality such as `contains` is not provided. We provide
+ * it in this hook.
+ *
+ * Accepts a ref to the observed {@link HTMLElement} (A in the example). Returns:
+ * - a {@link LogicalDomElement} which provides `contains` checks for that {@link HTMLElement}; and
+ * - a {@link LogicalDomStorage} which MUST be passed to a {@link LogicalDomContext} enclosing
+ *   the observed {@link HTMLElement}.
+ *
+ * Additionally, any component which introduces a portal MUST call `registerDescendant` in the
+ * {@link LogicalDomContext} with a ref to the portalled component (B in the example). */
+export declare function useLogicalDomObserver(elt: React.RefObject<HTMLElement>): [LogicalDomElement, LogicalDomStorage];
+/**
+ * An effect which calls `onClickOutside` whenever an element not logically descending from `ld`
+ * (see {@link useLogicalDomObserver}) is clicked. Note that `onClickOutside` is not called on clicks
+ * on the scrollbar since these should usually not impact the app's state.
+ * `isActive` controls whether the `onClickOutside` handler is active. This can be useful for performance,
+ * since having lots of `onClickOutside` handlers when they are not needed can be expensive.
+ */
+export declare function useOnClickOutside(ld: LogicalDomElement, onClickOutside: (_: PointerEvent) => void, isActive?: boolean): void;
+/** Sends an exception object to a throwable error.
+ * Maps JSON Rpc errors to throwable errors.
+ */
+export declare function mapRpcError(err: unknown): Error;
+/** Catch handler for RPC methods that just returns undefined if the method is not found.
+ * This is useful for compatibility with versions of Lean that do not yet have the given RPC method.
+ */
+export declare function discardMethodNotFound(e: unknown): undefined;
+export type AsyncState<T> = {
+    state: 'loading';
+} | {
+    state: 'resolved';
+    value: T;
+} | {
+    state: 'rejected';
+    error: any;
+};
+export type AsyncWithTriggerState<T> = {
+    state: 'notStarted';
+} | AsyncState<T>;
+export declare function useAsyncWithTrigger<T>(fn: () => Promise<T>, deps?: React.DependencyList): [AsyncWithTriggerState<T>, () => Promise<void>];
+/** This React hook will run the given promise function `fn` whenever the deps change
+ * and use it to update the status and result when the promise resolves.
+ *
+ * This function prevents race conditions if the requests resolve in a
+ * different order to that which they were requested in:
+ *
+ * - Request 1 is sent with, say, line=42.
+ * - Request 2 is sent with line=90.
+ * - Request 2 returns with diags=[].
+ * - Request 1 returns with diags=['error'].
+ *
+ * Without `useAsync` we would now return the diagnostics for line 42 even though we're at line 90.
+ *
+ * When the deps change, the function immediately returns `{ state: 'loading' }`.
+ */
+export declare function useAsync<T>(fn: () => Promise<T>, deps?: React.DependencyList): AsyncState<T>;
+/** Like {@link useAsync} but never transitions from `resolved` to `loading` by internally storing
+ * the latest `resolved` state and continuing to return it while an update is in flight. The lower
+ * amount of re-renders tends to be less visually jarring.
+ */
+export declare function useAsyncPersistent<T>(fn: () => Promise<T>, deps?: React.DependencyList): AsyncState<T>;

package/dist/vscode-lean4/lean4-infoview/src/infoview/util.js

@@ -0,0 +1,336 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable react-hooks/exhaustive-deps */
+import * as React from 'react';
+import { isRpcError, RpcErrorCode } from '@leanprover/infoview-api';
+import { EditorContext } from './contexts';
+export var DocumentPosition;
+(function (DocumentPosition) {
+    function isEqual(p1, p2) {
+        return p1.uri === p2.uri && p1.line === p2.line && p1.character === p2.character;
+    }
+    DocumentPosition.isEqual = isEqual;
+    function toTdpp(p) {
+        return { textDocument: { uri: p.uri }, position: { line: p.line, character: p.character } };
+    }
+    DocumentPosition.toTdpp = toTdpp;
+    function toString(p) {
+        return `${p.uri}:${p.line + 1}:${p.character}`;
+    }
+    DocumentPosition.toString = toString;
+})(DocumentPosition || (DocumentPosition = {}));
+export var PositionHelpers;
+(function (PositionHelpers) {
+    function isLessThanOrEqual(p1, p2) {
+        return p1.line < p2.line || (p1.line === p2.line && p1.character <= p2.character);
+    }
+    PositionHelpers.isLessThanOrEqual = isLessThanOrEqual;
+})(PositionHelpers || (PositionHelpers = {}));
+export var RangeHelpers;
+(function (RangeHelpers) {
+    function contains(range, pos, ignoreCharacter) {
+        if (!ignoreCharacter) {
+            if (pos.line === range.start.line && pos.character < range.start.character)
+                return false;
+            if (pos.line === range.end.line && pos.character > range.end.character)
+                return false;
+        }
+        return range.start.line <= pos.line && pos.line <= range.end.line;
+    }
+    RangeHelpers.contains = contains;
+})(RangeHelpers || (RangeHelpers = {}));
+// https://stackoverflow.com/questions/6234773/can-i-escape-html-special-chars-in-javascript
+export function escapeHtml(s) {
+    return s
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+}
+/** @deprecated (unused) */
+export function colorizeMessage(goal) {
+    return goal
+        .replace(/^([|⊢]) /gm, '<strong class="goal-vdash">$1</strong> ')
+        .replace(/^(\d+ goals|1 goal)/gm, '<strong class="goal-goals">$1</strong>')
+        .replace(/^(context|state):/gm, '<strong class="goal-goals">$1</strong>:')
+        .replace(/^(case) /gm, '<strong class="goal-case">$1</strong> ')
+        .replace(/^([^:\n< ][^:\n⊢{[(⦃]*) :/gm, '<strong class="goal-hyp">$1</strong> :');
+}
+export function basename(path) {
+    const bn = path.split(/[\\/]/).pop();
+    if (bn)
+        return bn;
+    else
+        return '';
+}
+/**
+ * A specialization of {@link React.useEffect} which executes `f` with the event data
+ * whenever `ev` fires.
+ * If `key` is provided, `f` is only invoked on events fired with that key.
+ */
+export function useEvent(ev, f, dependencies, key) {
+    React.useEffect(() => {
+        const h = ev.on(f, key);
+        return () => h.dispose();
+    }, dependencies);
+}
+export function useEventResult(ev, f) {
+    const fn = f ?? (x => x);
+    const [s, setS] = React.useState(ev.current ? fn(ev.current) : undefined);
+    useEvent(ev, newV => setS(newV ? fn(newV) : undefined));
+    return s;
+}
+export function useServerNotificationEffect(method, f, deps) {
+    const ec = React.useContext(EditorContext);
+    React.useEffect(() => {
+        void ec.api.subscribeServerNotifications(method).catch(ex => {
+            console.error(`Failed subscribing to server notification '${method}': ${ex}`);
+        });
+        const h = ec.events.gotServerNotification.on(([thisMethod, params]) => {
+            if (thisMethod !== method)
+                return;
+            f(params);
+        });
+        return () => {
+            h.dispose();
+            void ec.api.unsubscribeServerNotifications(method);
+        };
+    }, deps);
+}
+/**
+ * Returns the same tuple as `setState` such that whenever a server notification with `method`
+ * arrives at the editor, the state will be updated according to `f`.
+ */
+export function useServerNotificationState(method, initial, f, deps) {
+    const [s, setS] = React.useState(initial);
+    useServerNotificationEffect(method, (params) => void f(params).then(g => setS(g)), deps);
+    return [s, setS];
+}
+export function useClientNotificationEffect(method, f, deps) {
+    const ec = React.useContext(EditorContext);
+    React.useEffect(() => {
+        void ec.api.subscribeClientNotifications(method).catch(ex => {
+            console.error(`Failed subscribing to client notification '${method}': ${ex}`);
+        });
+        const h = ec.events.sentClientNotification.on(([thisMethod, params]) => {
+            if (thisMethod !== method)
+                return;
+            f(params);
+        });
+        return () => {
+            h.dispose();
+            void ec.api.unsubscribeClientNotifications(method);
+        };
+    }, deps);
+}
+/**
+ * Like {@link useServerNotificationState} but for client->server notifications sent by the editor.
+ */
+export function useClientNotificationState(method, initial, f, deps) {
+    const [s, setS] = React.useState(initial);
+    useClientNotificationEffect(method, (params) => {
+        setS(state => f(state, params));
+    }, deps);
+    return [s, setS];
+}
+/**
+ * Returns `[{ isPaused, setPaused }, tPausable, tRef]` s.t.
+ * - `[isPaused, setPaused]` are the paused status state
+ * - for as long as `isPaused` is set, `tPausable` holds its initial value (the `t` passed before pausing)
+ *   rather than updates with changes to `t`.
+ * - `tRef` can be used to overwrite the paused state
+ *
+ * To pause child components, `startPaused` can be passed in their props.
+ */
+export function usePausableState(startPaused, t) {
+    const [isPaused, setPaused] = React.useState(startPaused);
+    const old = React.useRef(t);
+    if (!isPaused)
+        old.current = t;
+    return [{ isPaused, setPaused }, old.current, old];
+}
+/**
+ * Adds a unique `key` property to each element in `elems` using
+ * the values of (possibly non-injective) `getId`.
+ */
+export function addUniqueKeys(elems, getId) {
+    const keys = {};
+    return elems.map(el => {
+        const id = getId(el);
+        keys[id] = (keys[id] || 0) + 1;
+        return { key: `${id}:${keys[id]}`, ...el };
+    });
+}
+export const LogicalDomContext = React.createContext({ registerDescendant: () => () => { } });
+/** Suppose a component B appears as a React descendant of the component A. For layout reasons,
+ * we sometimes don't want B to appear as a descendant of A in the DOM, so we use `createPortal`.
+ * We may still however want to carry out `contains` checks as if B were there, i.e. according to
+ * the React tree structure rather than the DOM structure. While React already correctly propagates
+ * DOM events up the React tree, other functionality such as `contains` is not provided. We provide
+ * it in this hook.
+ *
+ * Accepts a ref to the observed {@link HTMLElement} (A in the example). Returns:
+ * - a {@link LogicalDomElement} which provides `contains` checks for that {@link HTMLElement}; and
+ * - a {@link LogicalDomStorage} which MUST be passed to a {@link LogicalDomContext} enclosing
+ *   the observed {@link HTMLElement}.
+ *
+ * Additionally, any component which introduces a portal MUST call `registerDescendant` in the
+ * {@link LogicalDomContext} with a ref to the portalled component (B in the example). */
+export function useLogicalDomObserver(elt) {
+    const parentCtx = React.useContext(LogicalDomContext);
+    const descendants = React.useRef(new Set());
+    // Provides a `contains` check for the children only, but not the observed element.
+    // We pass this to the parent context under the assumption that its own DOM-based
+    // `contains` check already includes the observed element.
+    const logicalChildrenElt = React.useMemo(() => ({
+        contains: (e) => {
+            for (const d of descendants.current) {
+                if (d.contains(e))
+                    return true;
+            }
+            return false;
+        },
+    }), []);
+    React.useEffect(() => parentCtx.registerDescendant(logicalChildrenElt), [parentCtx, logicalChildrenElt]);
+    const logicalElt = React.useMemo(() => ({
+        contains: (e) => {
+            if (!elt.current)
+                return false;
+            if (elt.current.contains(e))
+                return true;
+            return logicalChildrenElt.contains(e);
+        },
+    }), [elt, logicalChildrenElt]);
+    const registerDescendant = React.useCallback((el) => {
+        descendants.current.add(el);
+        return () => {
+            descendants.current.delete(el);
+        };
+    }, []);
+    return [logicalElt, React.useMemo(() => ({ registerDescendant }), [registerDescendant])];
+}
+/**
+ * An effect which calls `onClickOutside` whenever an element not logically descending from `ld`
+ * (see {@link useLogicalDomObserver}) is clicked. Note that `onClickOutside` is not called on clicks
+ * on the scrollbar since these should usually not impact the app's state.
+ * `isActive` controls whether the `onClickOutside` handler is active. This can be useful for performance,
+ * since having lots of `onClickOutside` handlers when they are not needed can be expensive.
+ */
+export function useOnClickOutside(ld, onClickOutside, isActive = true) {
+    React.useEffect(() => {
+        if (!isActive) {
+            return;
+        }
+        const onClickAnywhere = (e) => {
+            if (e.target instanceof Node && !ld.contains(e.target)) {
+                if (e.target instanceof Element && e.target.tagName === 'HTML') {
+                    // then user might be clicking in a scrollbar, otherwise
+                    // e.target would be a tag other than 'HTML'
+                }
+                else
+                    onClickOutside(e);
+            }
+        };
+        document.addEventListener('pointerdown', onClickAnywhere);
+        return () => document.removeEventListener('pointerdown', onClickAnywhere);
+    }, [ld, onClickOutside, isActive]);
+}
+/** Sends an exception object to a throwable error.
+ * Maps JSON Rpc errors to throwable errors.
+ */
+export function mapRpcError(err) {
+    if (isRpcError(err)) {
+        return new Error(`Rpc error: ${RpcErrorCode[err.code]}: ${err.message}`);
+    }
+    else if (!(err instanceof Error)) {
+        return new Error(`Unrecognised error ${JSON.stringify(err)}`);
+    }
+    else {
+        return err;
+    }
+}
+/** Catch handler for RPC methods that just returns undefined if the method is not found.
+ * This is useful for compatibility with versions of Lean that do not yet have the given RPC method.
+ */
+export function discardMethodNotFound(e) {
+    if (isRpcError(e) && e.code === RpcErrorCode.MethodNotFound) {
+        return undefined;
+    }
+    else {
+        throw mapRpcError(e);
+    }
+}
+export function useAsyncWithTrigger(fn, deps = []) {
+    const asyncState = React.useRef({ state: 'notStarted' });
+    const asyncStateDeps = React.useRef([]);
+    // A monotonically increasing counter.
+    const tick = React.useRef(0);
+    // This is bumped up to the current `tick` whenever `asyncState.current` is assigned,
+    // in order to trigger a React update.
+    const [_, setUpdate] = React.useState(0);
+    const trigger = React.useCallback(async () => {
+        if (asyncState.current.state === 'loading' || asyncState.current.state === 'resolved')
+            return;
+        tick.current += 1;
+        asyncState.current = { state: 'loading' };
+        setUpdate(tick.current);
+        tick.current += 1;
+        const startTick = tick.current;
+        const set = (state) => {
+            if (tick.current === startTick) {
+                asyncState.current = state;
+                setUpdate(tick.current);
+            }
+        };
+        return fn().then(value => set({ state: 'resolved', value }), error => set({ state: 'rejected', error }));
+    }, deps);
+    const depsTheSame = asyncStateDeps.current.length === deps.length && asyncStateDeps.current.every((d, i) => Object.is(d, deps[i]));
+    if (!depsTheSame) {
+        tick.current += 1;
+        asyncState.current = { state: 'notStarted' };
+        asyncStateDeps.current = deps;
+        setUpdate(tick.current);
+    }
+    return [asyncState.current, trigger];
+}
+/** This React hook will run the given promise function `fn` whenever the deps change
+ * and use it to update the status and result when the promise resolves.
+ *
+ * This function prevents race conditions if the requests resolve in a
+ * different order to that which they were requested in:
+ *
+ * - Request 1 is sent with, say, line=42.
+ * - Request 2 is sent with line=90.
+ * - Request 2 returns with diags=[].
+ * - Request 1 returns with diags=['error'].
+ *
+ * Without `useAsync` we would now return the diagnostics for line 42 even though we're at line 90.
+ *
+ * When the deps change, the function immediately returns `{ state: 'loading' }`.
+ */
+export function useAsync(fn, deps = []) {
+    const [state, trigger] = useAsyncWithTrigger(fn, deps);
+    if (state.state === 'notStarted') {
+        void trigger();
+        return { state: 'loading' };
+    }
+    else {
+        return state;
+    }
+}
+/** Like {@link useAsync} but never transitions from `resolved` to `loading` by internally storing
+ * the latest `resolved` state and continuing to return it while an update is in flight. The lower
+ * amount of re-renders tends to be less visually jarring.
+ */
+export function useAsyncPersistent(fn, deps = []) {
+    const [latestState, setLatestState] = React.useState(undefined);
+    const state = useAsync(async () => {
+        const newState = await fn();
+        setLatestState(newState);
+        return newState;
+    }, deps);
+    if (state.state === 'loading' && latestState !== undefined) {
+        return { state: 'resolved', value: latestState };
+    }
+    return state;
+}

package/dist/vscode-lean4/vscode-lean4/media/diagnostic-gutter-icons/error-dark.svg

@@ -0,0 +1,91 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   width="16"
+   height="16"
+   viewBox="0 0 16 16"
+   fill="currentColor"
+   version="1.1"
+   id="svg1"
+   sodipodi:docname="error-dark.svg"
+   inkscape:version="1.4 (e7c3feb100, 2024-10-09)"
+   inkscape:export-filename="error-t-passthrough-light-2.svg"
+   inkscape:export-xdpi="96"
+   inkscape:export-ydpi="96"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs1">
+    <clipPath
+       clipPathUnits="userSpaceOnUse"
+       id="clipPath12">
+      <rect
+         style="display:inline;fill:none;stroke-width:1.00098"
+         id="rect12"
+         width="16"
+         height="16"
+         x="0"
+         y="0" />
+    </clipPath>
+    <clipPath
+       clipPathUnits="userSpaceOnUse"
+       id="clipPath13">
+      <rect
+         style="display:inline;fill:none;stroke-width:1.00098"
+         id="rect13"
+         width="16"
+         height="16"
+         x="0"
+         y="0" />
+    </clipPath>
+    <clipPath
+       clipPathUnits="userSpaceOnUse"
+       id="clipPath14">
+      <rect
+         style="display:inline;fill:none;stroke-width:1.00098"
+         id="rect14"
+         width="16"
+         height="16"
+         x="0"
+         y="0" />
+    </clipPath>
+    <clipPath
+       clipPathUnits="userSpaceOnUse"
+       id="clipPath15">
+      <rect
+         style="display:inline;fill:none;stroke-width:1.00098"
+         id="rect15"
+         width="16"
+         height="16"
+         x="0"
+         y="0" />
+    </clipPath>
+  </defs>
+  <sodipodi:namedview
+     id="namedview1"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:zoom="45.254834"
+     inkscape:cx="-0.23201941"
+     inkscape:cy="8.1648736"
+     inkscape:window-width="3838"
+     inkscape:window-height="2128"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="svg1" />
+  <path
+     fill-rule="evenodd"
+     clip-rule="evenodd"
+     d="m 8.5534798,2.5369052 c 1.247156,0.077947 2.4163642,0.7015251 3.2737842,1.5589451 1.013314,1.0912614 1.558945,2.4163647 1.558945,3.9753096 0,1.2471562 -0.467684,2.4163641 -1.247156,3.4296791 -0.779473,0.935366 -1.870734,1.636892 -3.1178896,1.870734 -1.247156,0.233841 -2.494312,0.07795 -3.5855736,-0.545631 C 4.3443284,12.202364 3.4869086,11.266997 3.0192251,10.097788 2.5515416,8.9285796 2.4735943,7.6034766 2.8633305,6.4342677 3.2530667,5.1871117 3.9545922,4.1737974 5.0458535,3.4722722 6.0591679,2.7707471 7.3063239,2.4589579 8.5534798,2.5369052 Z M 8.9432161,12.5921 c 1.0133143,-0.233842 1.9486809,-0.779472 2.6502059,-1.636892 0.623578,-0.85742 1.013314,-1.8707338 0.935367,-2.9619951 0,-1.2471563 -0.467684,-2.4943123 -1.325103,-3.351732 C 10.424213,3.8620084 9.4888469,3.3943249 8.3975852,3.3163776 7.3842712,3.2384303 6.2930095,3.4722722 5.4355898,4.0958503 4.57817,4.7194282 3.9545922,5.5768479 3.642803,6.6681096 3.331014,7.6814237 3.331014,8.7726853 3.7986976,9.7859997 c 0.4676835,1.0133133 1.1692086,1.7927863 2.1045757,2.3384173 0.935367,0.54563 2.0266284,0.701525 3.0399428,0.467683 z M 8.007849,7.6034766 9.8785831,5.6547952 10.424213,6.2004261 8.5534798,8.1491072 10.424213,10.097788 9.8785831,10.643419 8.007849,8.694738 6.1371152,10.643419 5.5914844,10.097788 7.4622184,8.1491072 5.5914844,6.2004261 6.1371152,5.6547952 Z"
+     id="path1"
+     style="fill:#f14c4c;fill-opacity:1;stroke-width:0.779473"
+     sodipodi:nodetypes="scscsssccssccscscsssccccccccccccc"
+     clip-path="url(#clipPath15)" />
+</svg>