@data-client/core 0.1.0

package/ts3.4/newActions.d.ts

@@ -0,0 +1,88 @@
+import { EndpointInterface, ResolveType, UnknownError } from '@data-client/normalizr';
+import { SET_TYPE, RESET_TYPE, FETCH_TYPE, SUBSCRIBE_TYPE, UNSUBSCRIBE_TYPE, INVALIDATE_TYPE, GC_TYPE, OPTIMISTIC_TYPE, INVALIDATEALL_TYPE } from './actionTypes.js';
+import { EndpointUpdateFunction } from './controller/types.js';
+export interface ReceiveMeta {
+    args: readonly any[];
+    fetchedAt: number;
+    date: number;
+    expiresAt: number;
+}
+export interface ReceiveActionSuccess<E extends EndpointInterface = EndpointInterface> {
+    type: typeof SET_TYPE;
+    endpoint: E;
+    meta: ReceiveMeta;
+    payload: ResolveType<E>;
+    error?: false;
+}
+export interface ReceiveActionError<E extends EndpointInterface = EndpointInterface> {
+    type: typeof SET_TYPE;
+    endpoint: E;
+    meta: ReceiveMeta;
+    payload: UnknownError;
+    error: true;
+}
+export type ReceiveAction<E extends EndpointInterface = EndpointInterface> = ReceiveActionSuccess<E> | ReceiveActionError<E>;
+export type SetAction<E extends EndpointInterface = EndpointInterface> = ReceiveAction<E>;
+export interface FetchMeta {
+    args: readonly any[];
+    throttle: boolean;
+    resolve: (value?: any | PromiseLike<any>) => void;
+    reject: (reason?: any) => void;
+    promise: PromiseLike<any>;
+    createdAt: number;
+    nm?: boolean;
+}
+export interface FetchAction<E extends EndpointInterface = EndpointInterface> {
+    type: typeof FETCH_TYPE;
+    endpoint: E;
+    meta: FetchMeta;
+    payload: () => ReturnType<E>;
+}
+export interface OptimisticAction<E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+} = EndpointInterface & {
+    update?: EndpointUpdateFunction<EndpointInterface>;
+}> {
+    type: typeof OPTIMISTIC_TYPE;
+    endpoint: E;
+    meta: ReceiveMeta;
+    error?: boolean;
+}
+export interface SubscribeAction<E extends EndpointInterface = EndpointInterface> {
+    type: typeof SUBSCRIBE_TYPE;
+    endpoint: E;
+    meta: {
+        args: readonly any[];
+    };
+}
+export interface UnsubscribeAction<E extends EndpointInterface = EndpointInterface> {
+    type: typeof UNSUBSCRIBE_TYPE;
+    endpoint: E;
+    meta: {
+        args: readonly any[];
+    };
+}
+export interface InvalidateAllAction {
+    type: typeof INVALIDATEALL_TYPE;
+    testKey: (key: string) => boolean;
+}
+export interface InvalidateAction {
+    type: typeof INVALIDATE_TYPE;
+    meta: {
+        key: string;
+    };
+}
+export interface ResetAction {
+    type: typeof RESET_TYPE;
+    date: number;
+}
+export interface GCAction {
+    type: typeof GC_TYPE;
+    entities: [
+        string,
+        string
+    ][];
+    results: string[];
+}
+export type ActionTypes = FetchAction | OptimisticAction | ReceiveAction | SubscribeAction | UnsubscribeAction | InvalidateAction | ResetAction | GCAction;
+//# sourceMappingURL=newActions.d.ts.map

package/ts3.4/next/Controller.d.ts

@@ -0,0 +1,14 @@
+import { EndpointInterface, Denormalize } from '@data-client/normalizr';
+import BaseController, { CompatibleDispatch, GenericDispatch } from '../controller/BaseController.js';
+import { EndpointUpdateFunction } from '../controller/types.js';
+export default class Controller<D extends GenericDispatch = CompatibleDispatch> extends BaseController<D> {
+    /**
+     * Fetches the endpoint with given args, updating the Rest Hooks cache with the response or error upon completion.
+     * @see https://resthooks.io/docs/api/Controller#fetch
+     */
+    fetch: <E extends EndpointInterface<import("@data-client/normalizr").FetchFunction, import("@data-client/normalizr").Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...args_0: Parameters<E>) => E["schema"] extends null | undefined ? ReturnType<E> : Promise<Denormalize<E["schema"]>>;
+}
+export * from '../controller/BaseController.js';
+//# sourceMappingURL=Controller.d.ts.map

package/ts3.4/next/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Controller } from './Controller.js';
+export * from './Controller.js';
+//# sourceMappingURL=index.d.ts.map

package/ts3.4/previousActions.d.ts

@@ -0,0 +1,94 @@
+import { EndpointExtraOptions, EndpointInterface, Schema } from '@data-client/normalizr';
+import { UpdateFunction } from '@data-client/normalizr';
+import { FSAWithMeta, FSAWithPayloadAndMeta } from 'flux-standard-action';
+import { FETCH_TYPE, GC_TYPE, OPTIMISTIC_TYPE, RECEIVE_TYPE, RESET_TYPE, SUBSCRIBE_TYPE, UNSUBSCRIBE_TYPE } from './actionTypes.js';
+import { EndpointUpdateFunction } from './controller/types.js';
+import { FetchShape } from './endpoint/index.js';
+import { ErrorableFSAWithPayloadAndMeta } from './fsa.js';
+import { InvalidateAction, InvalidateAllAction } from './newActions.js';
+export interface ReceiveMeta<S extends Schema | undefined> {
+    schema?: S;
+    key: string;
+    args?: readonly any[];
+    updaters?: Record<string, UpdateFunction<S, any>>;
+    update?: (result: any, ...args: any) => Record<string, (...args: any) => any>;
+    fetchedAt?: number;
+    date: number;
+    expiresAt: number;
+    errorPolicy?: (error: any) => 'hard' | 'soft' | undefined;
+}
+export type ReceiveAction<Payload extends object | string | number | null = object | string | number | null, S extends Schema | undefined = any> = ErrorableFSAWithPayloadAndMeta<typeof RECEIVE_TYPE, Payload, ReceiveMeta<S>> & {
+    endpoint?: EndpointInterface;
+};
+export type OptimisticAction<E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+} = EndpointInterface & {
+    update?: EndpointUpdateFunction<EndpointInterface>;
+}> = {
+    type: typeof OPTIMISTIC_TYPE;
+    meta: {
+        schema: E['schema'];
+        key: string;
+        args: readonly any[];
+        update?: (result: any, ...args: any) => Record<string, (...args: any) => any>;
+        fetchedAt: number;
+        date: number;
+        expiresAt: number;
+        errorPolicy?: (error: any) => 'hard' | 'soft' | undefined;
+    };
+    endpoint: E;
+    error?: undefined;
+};
+export interface ResetAction {
+    type: typeof RESET_TYPE;
+    date: number | Date;
+}
+interface FetchMeta<Payload extends object | string | number | null = object | string | number | null, S extends Schema | undefined = any> {
+    type: FetchShape<any, any>['type'];
+    schema?: S;
+    key: string;
+    args?: readonly any[];
+    updaters?: Record<string, UpdateFunction<S, any>>;
+    update?: (result: any, ...args: any) => Record<string, (...args: any) => any>;
+    options?: EndpointExtraOptions;
+    throttle: boolean;
+    resolve: (value?: any | PromiseLike<any>) => void;
+    reject: (reason?: any) => void;
+    promise: PromiseLike<any>;
+    createdAt: number | Date;
+    optimisticResponse?: Payload;
+    nm?: boolean;
+}
+export interface FetchAction<Payload extends object | string | number | null = object | string | number | null, S extends Schema | undefined = any> extends FSAWithPayloadAndMeta<typeof FETCH_TYPE, () => Promise<Payload>, FetchMeta<any, any>> {
+    meta: FetchMeta<Payload, S>;
+    endpoint?: EndpointInterface;
+}
+export interface SubscribeAction extends FSAWithMeta<typeof SUBSCRIBE_TYPE, undefined, any> {
+    endpoint?: EndpointInterface;
+    meta: {
+        args?: readonly any[];
+        schema: Schema | undefined;
+        fetch: () => Promise<any>;
+        key: string;
+        options: EndpointExtraOptions | undefined;
+    };
+}
+export interface UnsubscribeAction extends FSAWithMeta<typeof UNSUBSCRIBE_TYPE, undefined, any> {
+    endpoint?: EndpointInterface;
+    meta: {
+        args?: readonly any[];
+        key: string;
+        options: EndpointExtraOptions | undefined;
+    };
+}
+export { InvalidateAction, InvalidateAllAction };
+export interface GCAction {
+    type: typeof GC_TYPE;
+    entities: [
+        string,
+        string
+    ][];
+    results: string[];
+}
+export type ActionTypes = FetchAction | OptimisticAction | ReceiveAction | SubscribeAction | UnsubscribeAction | InvalidateAction | InvalidateAllAction | ResetAction | GCAction;
+//# sourceMappingURL=previousActions.d.ts.map

package/ts3.4/state/RIC.d.ts

@@ -0,0 +1,2 @@
+declare const RIC: (cb: (...args: any[]) => void, options: any) => void;
+export default RIC;

package/ts3.4/state/applyUpdatersToResults.d.ts

@@ -0,0 +1,13 @@
+import { Schema, Normalize, UpdateFunction } from '@data-client/normalizr';
+type ResultStateFromUpdateFunctions<SourceSchema extends Schema, UpdateFunctions extends {
+    [key: string]: UpdateFunction<SourceSchema, any>;
+}> = {
+    [K in keyof UpdateFunctions]: any;
+};
+export default function applyUpdatersToResults<SourceSchema extends Schema, UpdateFunctions extends {
+    [key: string]: UpdateFunction<SourceSchema, any>;
+}>(results: ResultStateFromUpdateFunctions<SourceSchema, UpdateFunctions>, result: Normalize<SourceSchema>, updaters: UpdateFunctions): ResultStateFromUpdateFunctions<SourceSchema, UpdateFunctions> & {
+    [k: string]: any;
+};
+export {};
+//# sourceMappingURL=applyUpdatersToResults.d.ts.map

package/ts3.4/state/legacy-actions/createFetch.d.ts

@@ -0,0 +1,19 @@
+import { Schema } from '@data-client/normalizr';
+import { FetchShape, SchemaFromShape, ParamsFromShape, BodyFromShape, OptimisticUpdateParams } from '../../endpoint/index.js';
+import { FetchAction } from '../../legacyActions.js';
+interface Options<Shape extends FetchShape<Schema | undefined, Readonly<object>, Readonly<object | string> | void>> {
+    params: ParamsFromShape<Shape>;
+    body?: BodyFromShape<Shape>;
+    throttle: boolean;
+    updateParams?: OptimisticUpdateParams<SchemaFromShape<Shape>, FetchShape<Schema | undefined, any, any>>[] | undefined;
+}
+/** Requesting a fetch to begin
+ *
+ * @param fetchShape
+ * @param param1 { params, body, throttle, updateParams }
+ */
+export default function createFetch<Shape extends FetchShape<Schema | undefined, Readonly<object>, Readonly<object | string> | void>>(fetchShape: Shape & {
+    update?: (...args: any) => Record<string, (...args: any) => any>;
+}, { params, body, throttle, updateParams }: Options<Shape>): FetchAction;
+export {};
+//# sourceMappingURL=createFetch.d.ts.map

package/ts3.4/state/legacy-actions/createReceive.d.ts

@@ -0,0 +1,14 @@
+import { Schema, EndpointExtraOptions as FetchOptions } from '@data-client/normalizr';
+import { FetchAction, ReceiveAction } from '../../legacyActions.js';
+interface Options<Payload extends object | string | number | null = object | string | number | null, S extends Schema | undefined = any> extends Pick<FetchAction<Payload, S>['meta'], 'schema' | 'key' | 'type' | 'updaters' | 'update' | 'args'> {
+    dataExpiryLength: NonNullable<FetchOptions['dataExpiryLength']>;
+    fetchedAt?: number;
+}
+/** Update state with data
+ *
+ * @param data
+ * @param param1 { schema, key, type, updaters, dataExpiryLength }
+ */
+export default function createReceive<Payload extends object | string | number | null = object | string | number | null, S extends Schema | undefined = any>(data: Payload, { schema, key, args, updaters, fetchedAt, update, dataExpiryLength, }: Options<Payload, S>): ReceiveAction<Payload, S>;
+export {};
+//# sourceMappingURL=createReceive.d.ts.map

package/ts3.4/state/legacy-actions/createReceiveError.d.ts

@@ -0,0 +1,9 @@
+import { Schema, EndpointExtraOptions as FetchOptions } from '@data-client/normalizr';
+import { FetchAction, ReceiveAction } from '../../legacyActions.js';
+interface Options<S extends Schema | undefined = any> extends Pick<FetchAction<any, S>['meta'], 'schema' | 'key' | 'options'> {
+    errorExpiryLength?: NonNullable<FetchOptions['errorExpiryLength']>;
+    fetchedAt?: number;
+}
+export default function createReceiveError<S extends Schema | undefined = any>(error: Error, { schema, key, options, errorExpiryLength, fetchedAt, }: Options<S>): ReceiveAction;
+export {};
+//# sourceMappingURL=createReceiveError.d.ts.map

package/ts3.4/state/legacy-actions/index.d.ts

@@ -0,0 +1,4 @@
+export { default as createFetch } from './createFetch.js';
+export { default as createReceive } from './createReceive.js';
+export { default as createReceiveError } from './createReceiveError.js';
+//# sourceMappingURL=index.d.ts.map

package/ts3.4/state/reducer/createReducer.d.ts

@@ -0,0 +1,7 @@
+import Controller from '../../controller/Controller.js';
+import { ActionTypes, State } from '../../types.js';
+export default function createReducer(controller: Controller): ReducerType;
+export declare const initialState: State<unknown>;
+type ReducerType = (state: State<unknown> | undefined, action: ActionTypes) => State<unknown>;
+export {};
+//# sourceMappingURL=createReducer.d.ts.map

package/ts3.4/state/reducer/fetchReducer.d.ts

@@ -0,0 +1,4 @@
+import { FetchAction } from '../../previousActions.js';
+import { State } from '../../types.js';
+export declare function fetchReducer(state: State<unknown>, action: FetchAction): State<unknown>;
+//# sourceMappingURL=fetchReducer.d.ts.map

package/ts3.4/state/reducer/invalidateReducer.d.ts

@@ -0,0 +1,37 @@
+import { InvalidateAllAction, InvalidateAction } from '../../previousActions.js';
+import { State } from '../../types.js';
+export declare function invalidateReducer(state: State<unknown>, action: InvalidateAction | InvalidateAllAction): {
+    results: {
+        [x: string]: unknown;
+    };
+    meta: {
+        [x: string]: {
+            readonly date: number;
+            readonly error?: import("packages/normalizr/lib/index.js").ErrorTypes | undefined;
+            readonly expiresAt: number;
+            readonly prevExpiresAt?: number | undefined;
+            readonly invalidated?: boolean | undefined;
+            readonly errorPolicy?: "hard" | "soft" | undefined;
+        };
+    };
+    entities: {
+        readonly [entityKey: string]: {
+            readonly [pk: string]: unknown;
+        } | undefined;
+    };
+    indexes: import("packages/normalizr/lib/interface.js").NormalizedIndex;
+    entityMeta: {
+        readonly [entityKey: string]: {
+            readonly [pk: string]: {
+                readonly date: number;
+                readonly expiresAt: number;
+                readonly fetchedAt: number;
+            };
+        };
+    };
+    optimistic: (import("../../previousActions.js").ReceiveAction<string | number | object | null, any> | import("../../previousActions.js").OptimisticAction<import("packages/normalizr/lib/index.js").EndpointInterface<import("packages/normalizr/lib/index.js").FetchFunction, import("packages/normalizr/lib/interface.js").Schema | undefined, boolean | undefined> & {
+        update?: import("../../index.js").EndpointUpdateFunction<import("packages/normalizr/lib/index.js").EndpointInterface<import("packages/normalizr/lib/index.js").FetchFunction, import("packages/normalizr/lib/interface.js").Schema | undefined, boolean | undefined>> | undefined;
+    }>)[];
+    lastReset: number | Date;
+};
+//# sourceMappingURL=invalidateReducer.d.ts.map

package/ts3.4/state/reducer/setReducer.d.ts

@@ -0,0 +1,40 @@
+import Controller from '../../controller/Controller.js';
+import { ReceiveAction, OptimisticAction } from '../../previousActions.js';
+import { State } from '../../types.js';
+export declare function setReducer(state: State<unknown>, action: OptimisticAction | ReceiveAction, controller: Controller): State<unknown> | {
+    entities: {
+        [x: string]: any;
+    };
+    indexes: import("@data-client/normalizr").NormalizedIndex;
+    results: {
+        [x: string]: any;
+    };
+    entityMeta: {
+        readonly [entityKey: string]: {
+            readonly [pk: string]: {
+                readonly date: number;
+                readonly expiresAt: number;
+                readonly fetchedAt: number;
+            };
+        };
+    };
+    meta: {
+        [x: string]: {
+            readonly date: number;
+            readonly error?: import("@data-client/normalizr").ErrorTypes | undefined;
+            readonly expiresAt: number;
+            readonly prevExpiresAt?: number | undefined;
+            readonly invalidated?: boolean | undefined;
+            readonly errorPolicy?: "hard" | "soft" | undefined;
+        } | {
+            date: number;
+            expiresAt: number;
+            prevExpiresAt: number;
+        };
+    };
+    optimistic: (ReceiveAction<string | number | object | null, any> | OptimisticAction<import("@data-client/normalizr").EndpointInterface<import("@data-client/normalizr").FetchFunction, import("@data-client/normalizr").Schema | undefined, boolean | undefined> & {
+        update?: import("../../index.js").EndpointUpdateFunction<import("@data-client/normalizr").EndpointInterface<import("@data-client/normalizr").FetchFunction, import("@data-client/normalizr").Schema | undefined, boolean | undefined>> | undefined;
+    }>)[];
+    lastReset: number | Date;
+};
+//# sourceMappingURL=setReducer.d.ts.map

package/ts3.4/state/reducerInstance.d.ts

@@ -0,0 +1,7 @@
+import { ActionTypes, State } from '../types.js';
+/**
+ * @deprecated use createReducer instead
+ */
+declare const reducer: (state: State<unknown> | undefined, action: ActionTypes) => State<unknown>;
+export default reducer;
+//# sourceMappingURL=reducerInstance.d.ts.map

package/ts3.4/state/selectMeta.d.ts

@@ -0,0 +1,3 @@
+import { State } from '../types.js';
+export default function selectMeta<R = any>(state: State<R>, fetchKey: string): State<R>['meta'][string];
+//# sourceMappingURL=selectMeta.d.ts.map

package/ts3.4/types.d.ts

@@ -0,0 +1,73 @@
+import { EndpointInterface, NormalizedIndex, Schema } from '@data-client/normalizr';
+import { UpdateFunction, AbstractInstanceType } from '@data-client/normalizr';
+import { ErrorTypes } from '@data-client/normalizr';
+import { RECEIVE_TYPE } from './actionTypes.js';
+import { CompatibleFetchAction, CompatibleReceiveAction, CompatibleSubscribeAction, CompatibleUnsubscribeAction } from './compatibleActions.js';
+import { EndpointUpdateFunction } from './controller/types.js';
+import * as legacyActions from './legacyActions.js';
+import { Dispatch, Middleware, MiddlewareAPI } from './middlewareTypes.js';
+import * as newActions from './newActions.js';
+import * as previousActions from './previousActions.js';
+export { AbstractInstanceType, UpdateFunction };
+export type ReceiveTypes = typeof RECEIVE_TYPE;
+export type PK = string;
+export interface State<T> {
+    readonly entities: {
+        readonly [entityKey: string]: {
+            readonly [pk: string]: T;
+        } | undefined;
+    };
+    readonly indexes: NormalizedIndex;
+    readonly results: {
+        readonly [key: string]: unknown | PK[] | PK | undefined;
+    };
+    readonly meta: {
+        readonly [key: string]: {
+            readonly date: number;
+            readonly error?: ErrorTypes;
+            readonly expiresAt: number;
+            readonly prevExpiresAt?: number;
+            readonly invalidated?: boolean;
+            readonly errorPolicy?: 'hard' | 'soft' | undefined;
+        };
+    };
+    readonly entityMeta: {
+        readonly [entityKey: string]: {
+            readonly [pk: string]: {
+                readonly date: number;
+                readonly expiresAt: number;
+                readonly fetchedAt: number;
+            };
+        };
+    };
+    readonly optimistic: (previousActions.ReceiveAction | previousActions.OptimisticAction)[];
+    readonly lastReset: Date | number;
+}
+import * as legacyActions_1 from './legacyActions.js';
+export { legacyActions_1 as legacyActions };
+import * as newActions_1 from './newActions.js';
+export { newActions_1 as newActions };
+export { SetAction } from './newActions.js';
+export type OptimisticAction<E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+} = EndpointInterface & {
+    update?: EndpointUpdateFunction<EndpointInterface>;
+}> = newActions.OptimisticAction<E>;
+export type InvalidateAction = newActions.InvalidateAction;
+export type ResetAction = newActions.ResetAction | legacyActions.ResetAction;
+export type GCAction = newActions.GCAction;
+export type FetchAction<Payload extends object | string | number | null = object | string | number | null, S extends Schema | undefined = any> = CompatibleFetchAction | legacyActions.FetchAction<Payload, S>;
+export type ReceiveAction<Payload extends object | string | number | null = object | string | number | null, S extends Schema | undefined = any> = CompatibleReceiveAction | legacyActions.ReceiveAction<Payload, S>;
+export type SubscribeAction = CompatibleSubscribeAction | legacyActions.SubscribeAction;
+export type UnsubscribeAction = CompatibleUnsubscribeAction | legacyActions.UnsubscribeAction;
+export type ResponseActions = ReceiveAction;
+export type OldActionTypes = previousActions.ActionTypes;
+export type CombinedActionTypes = OptimisticAction | InvalidateAction | ResetAction | GCAction | FetchAction | ReceiveAction | SubscribeAction | UnsubscribeAction;
+export type ActionTypes = CombinedActionTypes;
+export interface Manager<Actions = CombinedActionTypes> {
+    getMiddleware(): Middleware<Actions>;
+    cleanup(): void;
+    init?: (state: State<any>) => void;
+}
+export { Dispatch, Middleware, MiddlewareAPI };
+//# sourceMappingURL=types.d.ts.map

package/typescript.svg

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="21px" height="21px" viewBox="0 0 256 256" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="xMidYMid">
+	<g>
+		<polygon fill="#007ACC" transform="translate(128.000000, 128.000000) scale(1, -1) translate(-128.000000, -128.000000) " points="0 128 0 0 128 0 256 0 256 128 256 256 128 256 0 256"></polygon>
+		<path d="M146.658132,223.436863 L146.739401,212.953054 L130.079084,212.953054 L113.418767,212.953054 L113.418767,165.613371 L113.418767,118.273689 L101.63464,118.273689 L89.8505126,118.273689 L89.8505126,165.613371 L89.8505126,212.953054 L73.1901951,212.953054 L56.5298776,212.953054 L56.5298776,223.233689 C56.5298776,228.922577 56.6517824,233.676863 56.8143221,233.798768 C56.9362269,233.961308 77.2130522,234.042577 101.797179,234.001943 L146.536227,233.880038 L146.658132,223.436863 Z" fill="#FFFFFF" transform="translate(101.634640, 176.142993) rotate(-180.000000) translate(-101.634640, -176.142993) "></path>
+		<path d="M206.566631,234.272145 C213.068219,232.646748 218.025679,229.761668 222.57679,225.048018 C224.933616,222.528653 228.428219,217.936907 228.712663,216.839764 C228.793933,216.514684 217.659965,209.037859 210.914568,204.852462 C210.670758,204.689922 209.69552,205.74643 208.598377,207.371827 C205.306949,212.166748 201.852981,214.239129 196.570441,214.604843 C188.809171,215.133097 183.811076,211.069605 183.851711,204.283573 C183.851711,202.292462 184.136155,201.114049 184.948854,199.488653 C186.65552,195.953414 189.825044,193.840399 199.7806,189.533097 C218.106949,181.649922 225.949489,176.448653 230.825679,169.053097 C236.270758,160.804208 237.489806,147.638494 233.792028,137.845478 C229.728536,127.199129 219.651076,119.966113 205.469489,117.568653 C201.080917,116.796589 190.678377,116.918494 185.964727,117.771827 C175.684092,119.600399 165.931711,124.679764 159.917743,131.343891 C157.560917,133.944526 152.969171,140.730557 153.253616,141.218176 C153.37552,141.380716 154.432028,142.030875 155.610441,142.721668 C156.748219,143.371827 161.05552,145.850557 165.119012,148.207383 L172.473933,152.474049 L174.01806,150.198494 C176.171711,146.907065 180.885362,142.396589 183.729806,140.893097 C191.897425,136.585795 203.112663,137.195319 208.639012,142.15278 C210.995838,144.30643 211.971076,146.541351 211.971076,149.83278 C211.971076,152.799129 211.605362,154.099446 210.061235,156.334367 C208.070123,159.178811 204.006631,161.576272 192.466314,166.574367 C179.259965,172.263256 173.571076,175.798494 168.369806,181.406113 C165.362822,184.656907 162.518377,189.858176 161.339965,194.206113 C160.364727,197.822621 160.120917,206.884208 160.892981,210.541351 C163.61552,223.300716 173.245996,232.199764 187.143139,234.841034 C191.653616,235.694367 202.137425,235.369287 206.566631,234.272145 Z" fill="#FFFFFF" transform="translate(194.578507, 176.190240) scale(1, -1) translate(-194.578507, -176.190240) "></path>
+	</g>
+</svg>