@lynxflow/seo-engine 2.8.0 → 3.2.0

package/dist/plugins/theme/index.d.ts

@@ -0,0 +1,83 @@
+/**
+ * LynxSEO - Theme Plugin
+ * Gestion des thèmes d'interface (clair/sombre, couleurs personnalisées, typographie).
+ * Inspiré de Matomo Theme (GPLv3 / AGPLv3 compatible).
+ */
+import { LynxSeoPlugin, type PluginManifest, type PluginContext, type PluginEvent } from "../../plugin/types";
+export type ThemeMode = "light" | "dark" | "system";
+export type ThemePreset = "default" | "ocean" | "forest" | "midnight" | "sunset";
+export interface ThemeDefinition {
+    id: string;
+    name: string;
+    mode: ThemeMode;
+    preset: ThemePreset;
+    colors: {
+        primary: string;
+        secondary: string;
+        background: string;
+        surface: string;
+        text: string;
+        textSecondary: string;
+        border: string;
+        accent: string;
+        success: string;
+        warning: string;
+        error: string;
+    };
+    typography: {
+        fontFamily: string;
+        baseSize: string;
+        scale: number;
+    };
+    borderRadius: string;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ThemeSettings {
+    siteId: string;
+    activeThemeId: string;
+    customCss?: string;
+    updatedAt: string;
+}
+export declare class ThemeService {
+    private themes;
+    private settings;
+    private defaultThemes;
+    constructor();
+    listThemes(): ThemeDefinition[];
+    getTheme(themeId: string): ThemeDefinition | undefined;
+    createTheme(theme: Omit<ThemeDefinition, "id" | "createdAt" | "updatedAt"> & {
+        id?: string;
+    }): ThemeDefinition;
+    updateTheme(themeId: string, patch: Partial<ThemeDefinition>): ThemeDefinition | undefined;
+    deleteTheme(themeId: string): boolean;
+    setActiveTheme(themeId: string): ThemeDefinition | undefined;
+    getActiveTheme(): ThemeDefinition | undefined;
+    setSiteSettings(siteId: string, activeThemeId: string, customCss?: string): ThemeSettings;
+    getSiteSettings(siteId: string): ThemeSettings | undefined;
+    count(): number;
+    clear(): void;
+}
+export declare class ThemePlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private service;
+    private ctx?;
+    enable(_ctx: PluginContext): Promise<void>;
+    disable(): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    listThemes(): ThemeDefinition[];
+    getTheme(themeId: string): ThemeDefinition | undefined;
+    createTheme(theme: Omit<ThemeDefinition, "id" | "createdAt" | "updatedAt"> & {
+        id?: string;
+    }): ThemeDefinition;
+    updateTheme(themeId: string, patch: Partial<ThemeDefinition>): ThemeDefinition | undefined;
+    deleteTheme(themeId: string): boolean;
+    setActiveTheme(themeId: string): ThemeDefinition | undefined;
+    getActiveTheme(): ThemeDefinition | undefined;
+    setSiteSettings(siteId: string, activeThemeId: string, customCss?: string): ThemeSettings;
+    getSiteSettings(siteId: string): ThemeSettings | undefined;
+    count(): number;
+    reset(): void;
+}
+export default ThemePlugin;

package/dist/plugins/tracking-spam-prevention/index.d.ts

@@ -0,0 +1,29 @@
+import type { LynxSeoPlugin, PluginContext, PluginEvent, PluginManifest } from "../../plugin/types";
+export interface SpamStats {
+    accepted: number;
+    rejected: number;
+}
+export interface DetailedSpamStats extends SpamStats {
+    reasonsBreakdown: Record<string, number>;
+}
+export interface CheckSpamResult {
+    isSpam: boolean;
+    reason?: "known_spam_domain" | "spam_keyword" | "bot_user_agent" | "custom_blacklist" | "malformed_referrer";
+    domain?: string;
+}
+export declare class TrackingSpamPreventionPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private readonly customBlacklist;
+    private readonly allowlist;
+    private readonly stats;
+    enable(_ctx: PluginContext): Promise<void>;
+    addCustomSpamDomain(siteId: string, domain: string): void;
+    addAllowlistDomain(siteId: string, domain: string): void;
+    check(siteId: string, referrer?: string, userAgent?: string): CheckSpamResult;
+    isSpam(payload: Record<string, unknown>, siteId?: string): boolean;
+    onEvent(event: PluginEvent): Promise<void>;
+    getStats(siteId: string): SpamStats;
+    getDetailedStats(siteId: string): DetailedSpamStats;
+    disable(): Promise<void>;
+}
+export default TrackingSpamPreventionPlugin;

package/dist/plugins/traffic-shield/index.d.ts

@@ -0,0 +1 @@
+export * from "./traffic-shield";

package/dist/plugins/traffic-shield/traffic-shield.d.ts

@@ -0,0 +1,64 @@
+/**
+ * TrafficShieldPlugin — Règle de protection d'ingestion et anti-pollution
+ *
+ * Inspiré des règles de Plausible Shield (ip_rule, country_rule, hostname_rule, page_rule),
+ * de Matomo Exclude Rules et des filtres d'ingestion PostHog.
+ *
+ * Implémentation Clean-Room indépendante sous licence AGPL-3.0.
+ */
+import type { LynxSeoPlugin, PluginManifest } from "../../plugin/types";
+export type ShieldRuleType = "ip_cidr" | "hostname" | "country" | "path_pattern" | "param_strip" | "user_agent";
+export interface ShieldRule {
+    id: string;
+    type: ShieldRuleType;
+    pattern: string;
+    action: "block" | "strip";
+    description?: string;
+    enabled: boolean;
+    createdAt: string;
+}
+export interface ShieldEvaluationInput {
+    ip?: string;
+    hostname?: string;
+    url?: string;
+    country?: string;
+    userAgent?: string;
+}
+export interface ShieldEvaluationResult {
+    allowed: boolean;
+    reason?: string;
+    matchedRuleId?: string;
+    sanitizedUrl?: string;
+}
+export interface ShieldStats {
+    totalEvaluated: number;
+    totalAllowed: number;
+    totalBlocked: number;
+    totalSanitized: number;
+    blockedByType: Record<ShieldRuleType, number>;
+}
+export declare class TrafficShieldPlugin implements LynxSeoPlugin {
+    manifest: PluginManifest;
+    readonly id = "traffic-shield";
+    readonly name = "Traffic Shield & Ingestion Filtering";
+    readonly version = "1.0.0";
+    private rules;
+    private stats;
+    constructor(initialRules?: ShieldRule[]);
+    private initDefaultRules;
+    getRules(): ShieldRule[];
+    addRule(rule: Omit<ShieldRule, "createdAt">): ShieldRule;
+    removeRule(ruleId: string): boolean;
+    toggleRule(ruleId: string, enabled: boolean): boolean;
+    getStats(): ShieldStats;
+    resetStats(): void;
+    /**
+     * Évalue un événement d'ingestion contre les règles de protection
+     */
+    evaluate(input: ShieldEvaluationInput): ShieldEvaluationResult;
+    private extractPath;
+    private stripQueryParams;
+    private matchesIpCidr;
+    private isIpInSubnet;
+    private ipToNumber;
+}

package/dist/plugins/transitions/index.d.ts

@@ -0,0 +1,69 @@
+/**
+ * LynxSEO - Transitions Plugin
+ * Analyse des flux de navigation : pages précédentes, suivantes, entrées et sorties de session.
+ * Inspiré de Matomo Transitions (GPLv3 / AGPLv3 compatible).
+ */
+import { LynxSeoPlugin, type PluginManifest, type PluginContext, type PluginEvent } from "../../plugin/types";
+export interface PageTransition {
+    url: string;
+    count: number;
+}
+export interface TransitionStats {
+    previousPages: PageTransition[];
+    followingPages: PageTransition[];
+}
+export declare class TransitionsService {
+    /** sessionId → ordered list of visited pages */
+    private sessions;
+    /** Maps url → { prevUrl → count } */
+    private previousMap;
+    /** Maps url → { nextUrl → count } */
+    private followingMap;
+    private entryUrls;
+    private exitUrls;
+    /**
+     * Enregistre une page vue dans une session.
+     * Met à jour les flux de navigation.
+     */
+    recordPageView(sessionId: string, url: string): void;
+    /**
+     * Clôture une session : enregistre la dernière page comme exit.
+     * Peut être appelé explicitement ; sinon getExitPages recalcule depuis sessions.
+     */
+    closeSession(sessionId: string): void;
+    /** Retourne les pages qui précèdent `pageUrl`. */
+    getPreviousPages(pageUrl: string): PageTransition[];
+    /** Retourne les pages qui suivent `pageUrl`. */
+    getFollowingPages(pageUrl: string): PageTransition[];
+    /** Pages d'entrée (première page de session). */
+    getEntryPages(): PageTransition[];
+    /**
+     * Pages de sortie (dernière page enregistrée de chaque session).
+     * Si closeSession n'a pas été appelé, recalcule depuis sessions.
+     */
+    getExitPages(): PageTransition[];
+    reset(): void;
+    private increment;
+    private mapToSorted;
+}
+export declare class TransitionsPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    /** Per-site service instances */
+    private siteServices;
+    enable(_ctx: PluginContext): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    /** Pages précédentes de `pageUrl` pour le site donné. */
+    getPreviousPages(siteId: string, pageUrl: string): PageTransition[];
+    /** Pages suivantes de `pageUrl` pour le site donné. */
+    getFollowingPages(siteId: string, pageUrl: string): PageTransition[];
+    /** Pages d'entrée pour le site donné. */
+    getEntryPages(siteId: string): PageTransition[];
+    /** Pages de sortie pour le site donné. */
+    getExitPages(siteId: string): PageTransition[];
+    /** Clôture explicitement une session (utile pour les tests). */
+    closeSession(siteId: string, sessionId: string): void;
+    /** Réinitialise les données d'un site. */
+    reset(siteId: string): void;
+    private getService;
+}
+export default TransitionsPlugin;

package/dist/plugins/two-factor-auth/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * LynxSEO - Two-Factor Authentication Plugin (2FA)
+ * Inspiré de Matomo Two-Factor Auth (GPLv3 / AGPLv3 compatible).
+ *
+ * Authentification à deux facteurs (TOTP), codes de secours, authentification renforcée.
+ */
+import { LynxSeoPlugin, type PluginManifest, type PluginContext, type PluginEvent } from "../../plugin/types";
+export interface TOTPSecret {
+    userId: string;
+    secret: string;
+    backupCodes: string[];
+    enabledAt: string;
+    verified: boolean;
+}
+export interface TwoFactorAttempt {
+    userId: string;
+    success: boolean;
+    timestamp: string;
+    method: "totp" | "backup";
+}
+export declare class TwoFactorAuthPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private ctx?;
+    private secrets;
+    private attempts;
+    private verifiedUsers;
+    enable(ctx: PluginContext): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    /**
+     * Génère un secret TOTP pour un utilisateur (base32 simplifié).
+     */
+    generateSecret(userId: string): TOTPSecret;
+    /**
+     * Vérifie un code TOTP (implémentation simplifiée — production utiliserait otplib).
+     */
+    verifyTOTP(userId: string, token: string): boolean;
+    /**
+     * Vérifie un code de secours.
+     */
+    verifyBackupCode(userId: string, code: string): boolean;
+    /**
+     * Vérifie si un utilisateur a la 2FA activée et vérifiée.
+     */
+    isTwoFactorEnabled(userId: string): boolean;
+    /**
+     * Désactive la 2FA pour un utilisateur.
+     */
+    disableTwoFactor(userId: string): void;
+    /**
+     * Récupère les codes de secours restants.
+     */
+    getBackupCodes(userId: string): string[];
+    private recordAttempt;
+    private generateBase32Secret;
+    private generateBackupCode;
+    private mockVerifyTOTP;
+    disable(): Promise<void>;
+}
+export default TwoFactorAuthPlugin;

package/dist/plugins/user-country-map/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * LynxSEO - User Country Map Plugin
+ * Inspiré de Matomo UserCountryMap (GPLv3 / AGPLv3 compatible).
+ *
+ * Prépare les données de carte monde : agrégation par pays avec coordonnées
+ * du centroïde, intensité relative et séries pour la carte de chaleur.
+ */
+import { LynxSeoPlugin, type PluginManifest, type PluginContext, type PluginEvent } from "../../plugin/types";
+export interface CountryMapPoint {
+    countryCode: string;
+    countryName: string;
+    visits: number;
+    /** Part relative (0-1) pour le rendu de la carte. */
+    intensity: number;
+    latitude: number;
+    longitude: number;
+}
+export interface VisitorMapData {
+    points: CountryMapPoint[];
+    maxVisits: number;
+    totalVisits: number;
+    countriesCovered: number;
+    /** Visites sans pays résolu. */
+    unresolvedVisits: number;
+}
+export declare class UserCountryMapPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private ctx?;
+    private countries;
+    private unresolved;
+    enable(ctx: PluginContext): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    /** Pays connus avec leur centroïde, ou null si inconnu. */
+    static getCentroid(countryCode: string): {
+        name: string;
+        lat: number;
+        lon: number;
+    } | null;
+    /** Données prêtes pour le rendu de carte (Matomo UserCountryMap.visitorMap). */
+    getVisitorMap(siteId: string): VisitorMapData;
+    /** Coordonnées disponibles pour un pays (utilitaire carte). */
+    getCountryCoordinates(countryCode: string): {
+        latitude: number;
+        longitude: number;
+    } | null;
+    reset(siteId: string): void;
+    disable(): Promise<void>;
+}
+export default UserCountryMapPlugin;

package/dist/plugins/user-id/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * LynxSEO - User ID Plugin
+ * Inspiré de Matomo UserId (GPLv3 / AGPLv3 compatible).
+ *
+ * Unification des sessions d'un même utilisateur authentifié à travers les appareils.
+ * Déduit l'UserID depuis le tracker JS, le cookie d'authentification, ou un header custom.
+ */
+import { LynxSeoPlugin, type PluginManifest, type PluginContext, type PluginEvent } from "../../plugin/types";
+export declare class UserIdPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private ctx?;
+    enable(ctx: PluginContext): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    /**
+     * Récupère le userId associé à un visitorId.
+     */
+    getUserIdForVisitor(visitorId: string): string | undefined;
+    /**
+     * Récupère la mapping complète pour un userId.
+     */
+    getMapping(userId: string): import("../..").UserIdMapping | undefined;
+    /**
+     * Liste tous les userIds trackés.
+     */
+    listUserIds(): string[];
+    /**
+     * Nombre d'utilisateurs uniques authentifiés.
+     */
+    countUniqueUsers(): number;
+    disable(): Promise<void>;
+}
+export default UserIdPlugin;

package/dist/plugins/user-language/index.d.ts

@@ -0,0 +1,13 @@
+import type { LynxSeoPlugin, PluginContext, PluginEvent, PluginManifest } from "../../plugin/types";
+export interface LanguageStat {
+    language: string;
+    visits: number;
+}
+export declare class UserLanguagePlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private readonly bySite;
+    enable(_ctx: PluginContext): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    getStats(siteId: string): LanguageStat[];
+}
+export default UserLanguagePlugin;

package/dist/plugins/user-paths/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * UserPaths Plugin — LynxSEO Engine
+ *
+ * Parité fonctionnelle :
+ * - PostHog Paths : User Paths / Sankey Navigation Flow Analysis
+ * - Matomo Transitions & User Flow : Séquençage étape par étape des parcours de navigation
+ *
+ * Licence : AGPL-3.0-or-later
+ */
+import type { LynxSeoPlugin, PluginContext, PluginEvent, PluginManifest } from "../../plugin";
+export interface PathStepTransition {
+    source: string;
+    target: string;
+    value: number;
+    stepIndex: number;
+    dropoff: boolean;
+}
+export interface PathNodeSummary {
+    name: string;
+    stepIndex: number;
+    totalVisits: number;
+    dropoffCount: number;
+    dropoffRate: number;
+    topNextSteps: Array<{
+        target: string;
+        count: number;
+        percentage: number;
+    }>;
+}
+export interface UserPathsReport {
+    siteId: string;
+    startPoint?: string;
+    endPoint?: string;
+    maxSteps: number;
+    totalAnalyzedPaths: number;
+    transitions: PathStepTransition[];
+    nodes: PathNodeSummary[];
+    topDropoffStep: {
+        stepIndex: number;
+        node: string;
+        dropoffRate: number;
+    } | null;
+    recommendations: string[];
+}
+export declare class UserPathsPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private context?;
+    private sessions;
+    enable(ctx: PluginContext): void;
+    onEvent(event: PluginEvent): void;
+    recordStep(siteId: string, sessionId: string, node: string, timestamp: number): void;
+    getStats(siteId: string): UserPathsReport;
+    getReport(siteId: string, options?: {
+        startPoint?: string;
+        endPoint?: string;
+        maxSteps?: number;
+    }): UserPathsReport;
+    private cleanUrlPath;
+    private getDefaultReport;
+}

package/dist/plugins/users-manager/index.d.ts

@@ -0,0 +1,69 @@
+/**
+ * LynxSEO - Users Manager Plugin
+ * Gestion des utilisateurs, rôles et permissions (RBAC) par organisation et par site.
+ * Inspiré de Matomo UsersManager (GPLv3 / AGPLv3 compatible).
+ */
+import { LynxSeoPlugin, type PluginManifest, type PluginContext, type PluginEvent } from "../../plugin/types";
+export type UserRole = "admin" | "manager" | "viewer" | "editor";
+export interface AppUser {
+    id: string;
+    email: string;
+    name?: string;
+    role: UserRole;
+    organizationId: string;
+    siteIds: string[];
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface UserPermission {
+    userId: string;
+    siteId: string;
+    canView: boolean;
+    canEdit: boolean;
+    canManage: boolean;
+}
+export declare class UsersManagerService {
+    private users;
+    private permissions;
+    create(user: Omit<AppUser, "id" | "createdAt" | "updatedAt" | "isActive"> & {
+        id?: string;
+        isActive?: boolean;
+    }): AppUser;
+    get(userId: string): AppUser | undefined;
+    getByEmail(email: string, organizationId: string): AppUser | undefined;
+    list(organizationId?: string): AppUser[];
+    update(userId: string, patch: Partial<AppUser>): AppUser | undefined;
+    delete(userId: string): boolean;
+    setActive(userId: string, active: boolean): AppUser | undefined;
+    setRole(userId: string, role: UserRole): AppUser | undefined;
+    setSites(userId: string, siteIds: string[]): AppUser | undefined;
+    count(organizationId?: string): number;
+    getPermission(userId: string, siteId: string): UserPermission | undefined;
+    setPermission(userId: string, siteId: string, perm: Omit<UserPermission, "userId" | "siteId">): UserPermission;
+    clear(): void;
+}
+export declare class UsersManagerPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private service;
+    private ctx?;
+    enable(_ctx: PluginContext): Promise<void>;
+    disable(): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    create(user: Omit<AppUser, "id" | "createdAt" | "updatedAt"> & {
+        id?: string;
+    }): AppUser;
+    get(userId: string): AppUser | undefined;
+    getByEmail(email: string, organizationId: string): AppUser | undefined;
+    list(organizationId?: string): AppUser[];
+    update(userId: string, patch: Partial<AppUser>): AppUser | undefined;
+    delete(userId: string): boolean;
+    setActive(userId: string, active: boolean): AppUser | undefined;
+    setRole(userId: string, role: UserRole): AppUser | undefined;
+    setSites(userId: string, siteIds: string[]): AppUser | undefined;
+    count(organizationId?: string): number;
+    getPermission(userId: string, siteId: string): UserPermission | undefined;
+    setPermission(userId: string, siteId: string, perm: Omit<UserPermission, "userId" | "siteId">): UserPermission;
+    reset(): void;
+}
+export default UsersManagerPlugin;

package/dist/plugins/visit-frequency/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * LynxSEO - Visit Frequency Plugin
+ * Inspiré de Matomo Visit Frequency (GPLv3 / AGPLv3 compatible).
+ *
+ * Visiteurs nouveaux vs récurrents, fidélité, nombre de sessions par visiteur.
+ */
+import { LynxSeoPlugin, type PluginManifest, type PluginContext, type PluginEvent } from "../../plugin/types";
+export interface VisitFrequencySession {
+    visitorId: string;
+    siteId: string;
+    sessionCount: number;
+    firstVisit: string;
+    lastVisit: string;
+    isNew: boolean;
+}
+export interface FrequencyDistribution {
+    newVisitors: number;
+    returningVisitors: number;
+    sessionsDistribution: Record<string, number>;
+    avgSessionsPerVisitor: number;
+}
+export declare class VisitFrequencyPlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private ctx?;
+    private visitors;
+    enable(ctx: PluginContext): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    /**
+     * Récupère la distribution de fréquence pour un site.
+     */
+    getDistribution(siteId: string): FrequencyDistribution;
+    /**
+     * Récupère les infos d'un visiteur.
+     */
+    getVisitorInfo(visitorId: string): {
+        visitorId: string;
+        siteId: string;
+        sessionCount: number;
+        firstVisit: string;
+        lastVisit: string;
+        sessionIds: Set<string>;
+    } | undefined;
+    /**
+     * Nombre total de visiteurs uniques.
+     */
+    countUniqueVisitors(siteId?: string): number;
+    disable(): Promise<void>;
+}
+export default VisitFrequencyPlugin;

package/dist/plugins/visit-time/index.d.ts

@@ -0,0 +1,50 @@
+import type { LynxSeoPlugin, PluginContext, PluginEvent, PluginManifest } from "../../plugin/types";
+export interface VisitTimeStat {
+    hour: number;
+    visits: number;
+}
+export interface CustomVisitTimeInput {
+    timestamp: string;
+    localHour?: number;
+    isConversion?: boolean;
+}
+export interface VisitTimeReportOptions {
+    customVisits?: CustomVisitTimeInput[];
+}
+export interface HeatmapCell {
+    dayIndex: number;
+    dayName: string;
+    hour: number;
+    visits: number;
+    conversions: number;
+    conversionRate: number;
+}
+export interface DaySummary {
+    dayIndex: number;
+    dayName: string;
+    totalVisits: number;
+    conversions: number;
+}
+export interface HourlySummary {
+    hour: number;
+    totalVisits: number;
+}
+export interface VisitTimeReport {
+    siteId: string;
+    totalVisits: number;
+    heatmapGrid: HeatmapCell[];
+    daySummaries: DaySummary[];
+    hourlyComparison: HourlySummary[];
+    busiestDay: string;
+    busiestHour: number;
+}
+export declare class VisitTimePlugin implements LynxSeoPlugin {
+    readonly manifest: PluginManifest;
+    private readonly visits;
+    enable(_ctx: PluginContext): Promise<void>;
+    onEvent(event: PluginEvent): Promise<void>;
+    getStats(siteId: string): VisitTimeStat[];
+    getReport(siteId: string, options?: VisitTimeReportOptions): VisitTimeReport;
+    disable(): Promise<void>;
+}
+export default VisitTimePlugin;