applesauce-core 0.0.0-next-20251203172109 → 0.0.0-next-20251209200210

package/dist/event-store/async-delete-manager.d.ts

@@ -0,0 +1,26 @@
+import { Observable } from "rxjs";
+import { NostrEvent } from "../helpers/event.js";
+import { DeleteEventNotification, IAsyncDeleteManager } from "./interface.js";
+/** Async manager for deletion state, ensuring users can only delete their own events */
+export declare class AsyncDeleteManager implements IAsyncDeleteManager {
+    /** A stream of pointers that may have been deleted */
+    readonly deleted$: Observable<DeleteEventNotification>;
+    /** Internal sync delete manager instance for state */
+    private internal;
+    constructor();
+    /**
+     * Process a kind 5 delete event
+     * Extracts event pointers and address pointers from the delete event
+     * Enforces that users can only delete their own events
+     */
+    add(deleteEvent: NostrEvent): Promise<DeleteEventNotification[]>;
+    /**
+     * Check if an event is deleted
+     * Verifies the event was deleted by its own author
+     */
+    check(event: NostrEvent): Promise<boolean>;
+    /**
+     * Filter out all deleted events from an array of events
+     */
+    filter(events: NostrEvent[]): Promise<NostrEvent[]>;
+}

package/dist/event-store/async-delete-manager.js

@@ -0,0 +1,33 @@
+import { DeleteManager } from "./delete-manager.js";
+/** Async manager for deletion state, ensuring users can only delete their own events */
+export class AsyncDeleteManager {
+    /** A stream of pointers that may have been deleted */
+    deleted$;
+    /** Internal sync delete manager instance for state */
+    internal;
+    constructor() {
+        this.internal = new DeleteManager();
+        this.deleted$ = this.internal.deleted$;
+    }
+    /**
+     * Process a kind 5 delete event
+     * Extracts event pointers and address pointers from the delete event
+     * Enforces that users can only delete their own events
+     */
+    async add(deleteEvent) {
+        return this.internal.add(deleteEvent);
+    }
+    /**
+     * Check if an event is deleted
+     * Verifies the event was deleted by its own author
+     */
+    async check(event) {
+        return this.internal.check(event);
+    }
+    /**
+     * Filter out all deleted events from an array of events
+     */
+    async filter(events) {
+        return this.internal.filter(events);
+    }
+}

package/dist/event-store/async-event-store.d.ts

@@ -4,16 +4,38 @@ import { Filter } from "../helpers/filter.js";
 import { AddressPointer, AddressPointerWithoutD, EventPointer } from "../helpers/pointers.js";
 import { EventMemory } from "./event-memory.js";
 import { EventModels } from "./event-models.js";
-import { IAsyncEventDatabase, IAsyncEventStore } from "./interface.js";
+import { IAsyncEventDatabase, IAsyncEventStore, IAsyncDeleteManager, IExpirationManager } from "./interface.js";
+export type AsyncEventStoreOptions = {
+    /** Keep deleted events in the store */
+    keepDeleted?: boolean;
+    /** Keep expired events in the store */
+    keepExpired?: boolean;
+    /** Enable this to keep old versions of replaceable events */
+    keepOldVersions?: boolean;
+    /** The database to use for storing events */
+    database: IAsyncEventDatabase;
+    /** Custom {@link IAsyncDeleteManager} implementation */
+    deleteManager?: IAsyncDeleteManager;
+    /** Custom {@link IExpirationManager} implementation */
+    expirationManager?: IExpirationManager;
+    /** The method used to verify events */
+    verifyEvent?: (event: NostrEvent) => boolean;
+};
 /** An async wrapper around an async event database that handles replaceable events, deletes, and models */
 export declare class AsyncEventStore extends EventModels implements IAsyncEventStore {
     database: IAsyncEventDatabase;
     /** Optional memory database for ensuring single event instances */
     memory: EventMemory;
+    /** Manager for handling event deletions with authorization */
+    private deletes;
+    /** Manager for handling event expirations */
+    private expiration;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions: boolean;
-    /** Enable this to keep expired events */
+    /** Keep expired events in the store */
     keepExpired: boolean;
+    /** Keep deleted events in the store */
+    keepDeleted: boolean;
     /** The method used to verify events */
     private _verifyEventMethod?;
     /** Get the method used to verify events */
@@ -28,34 +50,15 @@ export declare class AsyncEventStore extends EventModels implements IAsyncEventS
     remove$: Subject<import("nostr-tools/core").Event>;
     /**
      * A method that will be called when an event isn't found in the store
-     * @experimental
-     */
-    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
-    /**
-     * A method that will be called when a replaceable event isn't found in the store
-     * @experimental
-     */
-    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
-    /**
-     * A method that will be called when an addressable event isn't found in the store
-     * @experimental
      */
-    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
-    constructor(database: IAsyncEventDatabase);
+    eventLoader?: (pointer: EventPointer | AddressPointer | AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    constructor(options: AsyncEventStoreOptions);
     /** A method to add all events to memory to ensure there is only ever a single instance of an event */
     private mapToMemory;
-    protected deletedIds: Set<string>;
-    protected deletedCoords: Map<string, number>;
-    protected checkDeleted(event: string | NostrEvent): boolean;
-    protected expirations: Map<string, number>;
-    /** Adds an event to the expiration map */
-    protected addExpiration(event: NostrEvent): void;
-    protected expirationTimeout: number | null;
-    protected nextExpirationCheck: number | null;
-    protected handleExpiringEvent(event: NostrEvent): void;
-    /** Remove expired events from the store */
-    protected pruneExpired(): Promise<void>;
-    protected handleDeleteEvent(deleteEvent: NostrEvent): Promise<void>;
+    /** Handle a delete event by pointer */
+    private handleDeleteNotification;
+    /** Handle an expired event by id */
+    private handleExpiredNotification;
     /** Copies important metadata from and identical event to another */
     static mergeDuplicateEvent(source: NostrEvent, dest: NostrEvent): void;
     /**
@@ -97,8 +100,4 @@ export declare class AsyncEventStore extends EventModels implements IAsyncEventS
     unclaimed(): Generator<NostrEvent>;
     /** Removes any event that is not being used by a subscription */
     prune(limit?: number): number;
-    /** Returns an observable that completes when an event is removed */
-    removed(id: string): Observable<never>;
-    /** Creates an observable that emits when event is updated */
-    updated(event: string | NostrEvent): Observable<NostrEvent>;
 }

package/dist/event-store/async-event-store.js

@@ -1,22 +1,29 @@
-import { EMPTY, filter, mergeMap, Subject, take } from "rxjs";
-import { getDeleteCoordinates, getDeleteIds } from "../helpers/delete.js";
-import { createReplaceableAddress, EventStoreSymbol, FromCacheSymbol, isAddressableKind, isReplaceable, kinds, } from "../helpers/event.js";
+import { Subject } from "rxjs";
+import { EventStoreSymbol, FromCacheSymbol, getReplaceableIdentifier, isReplaceable, kinds, } from "../helpers/event.js";
 import { getExpirationTimestamp } from "../helpers/expiration.js";
-import { parseCoordinate } from "../helpers/pointers.js";
+import { eventMatchesPointer, isEventPointer, isAddressPointer, } from "../helpers/pointers.js";
 import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
 import { unixNow } from "../helpers/time.js";
 import { EventMemory } from "./event-memory.js";
 import { EventModels } from "./event-models.js";
 import { verifyEvent as coreVerifyEvent } from "nostr-tools/pure";
+import { AsyncDeleteManager } from "./async-delete-manager.js";
+import { ExpirationManager } from "./expiration-manager.js";
 /** An async wrapper around an async event database that handles replaceable events, deletes, and models */
 export class AsyncEventStore extends EventModels {
     database;
     /** Optional memory database for ensuring single event instances */
     memory;
+    /** Manager for handling event deletions with authorization */
+    deletes;
+    /** Manager for handling event expirations */
+    expiration;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions = false;
-    /** Enable this to keep expired events */
+    /** Keep expired events in the store */
     keepExpired = false;
+    /** Keep deleted events in the store */
+    keepDeleted = false;
     /** The method used to verify events */
     _verifyEventMethod = coreVerifyEvent;
     /** Get the method used to verify events */
@@ -26,9 +33,8 @@ export class AsyncEventStore extends EventModels {
     /** Sets the method used to verify events */
     set verifyEvent(method) {
         this._verifyEventMethod = method;
-        if (method === undefined) {
+        if (method === undefined)
             console.warn("[applesauce-core] AsyncEventStore.verifyEvent is undefined; signature checks are disabled.");
-        }
     }
     /** A stream of new events added to the store */
     insert$ = new Subject();
@@ -38,23 +44,37 @@ export class AsyncEventStore extends EventModels {
     remove$ = new Subject();
     /**
      * A method that will be called when an event isn't found in the store
-     * @experimental
      */
     eventLoader;
-    /**
-     * A method that will be called when a replaceable event isn't found in the store
-     * @experimental
-     */
-    replaceableLoader;
-    /**
-     * A method that will be called when an addressable event isn't found in the store
-     * @experimental
-     */
-    addressableLoader;
-    constructor(database) {
+    constructor(options) {
         super();
-        this.database = database;
+        this.database = options.database;
         this.memory = new EventMemory();
+        // Set options if provided
+        if (options.keepDeleted !== undefined)
+            this.keepDeleted = options.keepDeleted;
+        if (options.keepExpired !== undefined)
+            this.keepExpired = options.keepExpired;
+        if (options.keepOldVersions !== undefined)
+            this.keepOldVersions = options.keepOldVersions;
+        if (options.verifyEvent)
+            this.verifyEvent = options.verifyEvent;
+        // Use provided delete manager or create a default one
+        this.deletes = options.deleteManager ?? new AsyncDeleteManager();
+        // Listen to delete notifications and remove matching events
+        this.deletes.deleted$.subscribe((notification) => {
+            this.handleDeleteNotification(notification).catch((error) => {
+                console.error("[applesauce-core] Error handling delete notification:", error);
+            });
+        });
+        // Create expiration manager
+        this.expiration = options.expirationManager ?? new ExpirationManager();
+        // Listen to expired events and remove them from the store
+        this.expiration.expired$.subscribe((id) => {
+            this.handleExpiredNotification(id).catch((error) => {
+                console.error("[applesauce-core] Error handling expired notification:", error);
+            });
+        });
         // when events are added to the database, add the symbol
         this.insert$.subscribe((event) => {
             Reflect.set(event, EventStoreSymbol, this);
@@ -71,89 +91,37 @@ export class AsyncEventStore extends EventModels {
             return event;
         return this.memory.add(event);
     }
-    // delete state
-    deletedIds = new Set();
-    deletedCoords = new Map();
-    checkDeleted(event) {
-        if (typeof event === "string")
-            return this.deletedIds.has(event);
-        else {
-            if (this.deletedIds.has(event.id))
-                return true;
-            if (isAddressableKind(event.kind)) {
-                const identifier = event.tags.find((t) => t[0] === "d")?.[1];
-                const deleted = this.deletedCoords.get(createReplaceableAddress(event.kind, event.pubkey, identifier));
-                if (deleted)
-                    return deleted > event.created_at;
-            }
-        }
-        return false;
-    }
-    expirations = new Map();
-    /** Adds an event to the expiration map */
-    addExpiration(event) {
-        const expiration = getExpirationTimestamp(event);
-        if (expiration && Number.isFinite(expiration))
-            this.expirations.set(event.id, expiration);
-    }
-    expirationTimeout = null;
-    nextExpirationCheck = null;
-    handleExpiringEvent(event) {
-        const expiration = getExpirationTimestamp(event);
-        if (!expiration)
+    /** Handle a delete event by pointer */
+    async handleDeleteNotification({ pointer, until }) {
+        // Skip if keeping deleted events
+        if (this.keepDeleted)
             return;
-        // Add event to expiration map
-        this.expirations.set(event.id, expiration);
-        // Exit if the next check is already less than the next expiration
-        if (this.expirationTimeout && this.nextExpirationCheck && this.nextExpirationCheck < expiration)
-            return;
-        // Set timeout to prune expired events
-        if (this.expirationTimeout)
-            clearTimeout(this.expirationTimeout);
-        const timeout = expiration - unixNow();
-        this.expirationTimeout = setTimeout(this.pruneExpired.bind(this), timeout * 1000 + 10);
-        this.nextExpirationCheck = expiration;
-    }
-    /** Remove expired events from the store */
-    async pruneExpired() {
-        const now = unixNow();
-        for (const [id, expiration] of this.expirations) {
-            if (expiration <= now) {
-                this.expirations.delete(id);
-                await this.remove(id);
-            }
+        if (isEventPointer(pointer)) {
+            // For event pointers, get the event by ID and remove if it exists
+            const event = await this.getEvent(pointer.id);
+            if (event && until >= event.created_at && eventMatchesPointer(event, pointer))
+                await this.remove(event);
         }
-        // Cleanup timers
-        if (this.expirationTimeout)
-            clearTimeout(this.expirationTimeout);
-        this.nextExpirationCheck = null;
-        this.expirationTimeout = null;
-    }
-    // handling delete events
-    async handleDeleteEvent(deleteEvent) {
-        const ids = getDeleteIds(deleteEvent);
-        for (const id of ids) {
-            this.deletedIds.add(id);
-            // remove deleted events in the database
-            await this.remove(id);
-        }
-        const coords = getDeleteCoordinates(deleteEvent);
-        for (const coord of coords) {
-            this.deletedCoords.set(coord, Math.max(this.deletedCoords.get(coord) ?? 0, deleteEvent.created_at));
-            // Parse the nostr address coordinate
-            const parsed = parseCoordinate(coord);
-            if (!parsed)
-                continue;
-            // Remove older versions of replaceable events
-            const events = await this.database.getReplaceableHistory(parsed.kind, parsed.pubkey, parsed.identifier);
+        else if (isAddressPointer(pointer)) {
+            // For address pointers, get all events matching the address and remove if deleted
+            const events = await this.getReplaceableHistory(pointer.kind, pointer.pubkey, pointer.identifier);
             if (events) {
                 for (const event of events) {
-                    if (event.created_at < deleteEvent.created_at)
+                    // Remove the event if its older than the delete notification and matches the pointer
+                    if (until >= event.created_at && eventMatchesPointer(event, pointer)) {
                         await this.remove(event);
+                    }
                 }
             }
         }
     }
+    /** Handle an expired event by id */
+    async handleExpiredNotification(id) {
+        // Skip if keeping expired events
+        if (this.keepExpired)
+            return;
+        await this.remove(id);
+    }
     /** Copies important metadata from and identical event to another */
     static mergeDuplicateEvent(source, dest) {
         const relays = getSeenRelays(source);
@@ -172,19 +140,21 @@ export class AsyncEventStore extends EventModels {
      */
     async add(event, fromRelay) {
         // Handle delete events differently
-        if (event.kind === kinds.EventDeletion)
-            await this.handleDeleteEvent(event);
+        if (event.kind === kinds.EventDeletion) {
+            await this.deletes.add(event);
+            return event;
+        }
         // Ignore if the event was deleted
-        if (this.checkDeleted(event))
+        if (await this.deletes.check(event))
             return event;
         // Reject expired events if keepExpired is false
         const expiration = getExpirationTimestamp(event);
         if (this.keepExpired === false && expiration && expiration <= unixNow())
             return null;
         // Get the replaceable identifier
-        const identifier = isReplaceable(event.kind) ? event.tags.find((t) => t[0] === "d")?.[1] : undefined;
+        const identifier = isReplaceable(event.kind) ? getReplaceableIdentifier(event) : undefined;
         // Don't insert the event if there is already a newer version
-        if (!this.keepOldVersions && isReplaceable(event.kind)) {
+        if (this.keepOldVersions === false && isReplaceable(event.kind)) {
             const existing = await this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
             // If there is already a newer version, copy cached symbols and return existing event
             if (existing && existing.length > 0 && existing[0].created_at >= event.created_at) {
@@ -218,7 +188,7 @@ export class AsyncEventStore extends EventModels {
         if (inserted === event)
             this.insert$.next(inserted);
         // remove all old version of the replaceable event
-        if (!this.keepOldVersions && isReplaceable(event.kind)) {
+        if (this.keepOldVersions === false && isReplaceable(event.kind)) {
             const existing = await this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
             if (existing && existing.length > 0) {
                 const older = Array.from(existing).filter((e) => e.created_at < event.created_at);
@@ -230,14 +200,17 @@ export class AsyncEventStore extends EventModels {
                     return existing[0];
             }
         }
-        // Add event to expiration map
-        if (this.keepExpired === false && expiration)
-            this.handleExpiringEvent(inserted);
+        // Add event to expiration manager if it has an expiration tag
+        if (this.keepExpired === false && expiration !== undefined)
+            this.expiration.track(inserted);
         return inserted;
     }
     /** Removes an event from the store and updates subscriptions */
     async remove(event) {
-        let instance = this.memory?.getEvent(typeof event === "string" ? event : event.id);
+        const eventId = typeof event === "string" ? event : event.id;
+        let instance = this.memory?.getEvent(eventId);
+        // Remove from expiration manager
+        this.expiration.forget(eventId);
         // Remove from memory if available
         if (this.memory)
             this.memory.remove(event);
@@ -253,6 +226,9 @@ export class AsyncEventStore extends EventModels {
     async removeByFilters(filters) {
         // Get events that will be removed for notification
         const eventsToRemove = await this.getByFilters(filters);
+        // Remove from expiration manager
+        for (const event of eventsToRemove)
+            this.expiration.forget(event.id);
         // Remove from memory if available
         if (this.memory)
             this.memory.removeByFilters(filters);
@@ -298,11 +274,8 @@ export class AsyncEventStore extends EventModels {
     /** Returns all versions of a replaceable event */
     async getReplaceableHistory(kind, pubkey, identifier) {
         // Get the events from memory first, then from the database
-        const memoryEvents = this.memory?.getReplaceableHistory(kind, pubkey, identifier);
-        if (memoryEvents)
-            return memoryEvents;
-        const dbEvents = await this.database.getReplaceableHistory(kind, pubkey, identifier);
-        return dbEvents?.map((e) => this.mapToMemory(e) ?? e);
+        return (this.memory?.getReplaceableHistory(kind, pubkey, identifier) ??
+            (await this.database.getReplaceableHistory(kind, pubkey, identifier))?.map((e) => this.mapToMemory(e) ?? e));
     }
     /** Get all events matching a filter */
     async getByFilters(filters) {
@@ -310,7 +283,7 @@ export class AsyncEventStore extends EventModels {
         const events = await this.database.getByFilters(filters);
         // Map events to memory if available for better performance
         if (this.memory)
-            return events.map((e) => this.mapToMemory(e) ?? e);
+            return events.map((e) => this.mapToMemory(e));
         else
             return events;
     }
@@ -350,21 +323,4 @@ export class AsyncEventStore extends EventModels {
     prune(limit) {
         return this.memory?.prune(limit) ?? 0;
     }
-    /** Returns an observable that completes when an event is removed */
-    removed(id) {
-        const deleted = this.checkDeleted(id);
-        if (deleted)
-            return EMPTY;
-        return this.remove$.pipe(
-        // listen for removed events
-        filter((e) => e.id === id), 
-        // complete as soon as we find a matching removed event
-        take(1), 
-        // switch to empty
-        mergeMap(() => EMPTY));
-    }
-    /** Creates an observable that emits when event is updated */
-    updated(event) {
-        return this.update$.pipe(filter((e) => e.id === event || e === event));
-    }
 }

package/dist/event-store/delete-manager.d.ts

@@ -0,0 +1,30 @@
+import { Observable } from "rxjs";
+import { NostrEvent } from "../helpers/event.js";
+import { DeleteEventNotification, IDeleteManager } from "./interface.js";
+/** Manages deletion state for events, ensuring users can only delete their own events */
+export declare class DeleteManager implements IDeleteManager {
+    /** A stream of pointers that may have been deleted */
+    readonly deleted$: Observable<DeleteEventNotification>;
+    /** Internal subject for deleted$ observable */
+    private deletedSubject;
+    /** Maps author pubkey to Set of event IDs they have deleted */
+    private deletedIds;
+    /** Maps of author pubkey to Map of kind + "|" + identifier and timestamp of the delete event */
+    private deletedIdentifiers;
+    constructor();
+    /**
+     * Process a kind 5 delete event
+     * Extracts event pointers and address pointers from the delete event
+     * Enforces that users can only delete their own events
+     */
+    add(deleteEvent: NostrEvent): DeleteEventNotification[];
+    /**
+     * Check if an event is deleted
+     * Verifies the event was deleted by its own author
+     */
+    check(event: NostrEvent): boolean;
+    /**
+     * Filter out all deleted events from an array of events
+     */
+    filter(events: NostrEvent[]): NostrEvent[];
+}

package/dist/event-store/delete-manager.js

@@ -0,0 +1,99 @@
+import { Subject } from "rxjs";
+import { getDeleteAddressPointers, getDeleteEventPointers } from "../helpers/delete.js";
+import { getReplaceableIdentifier, isAddressableKind, isReplaceableKind, kinds } from "../helpers/event.js";
+/** Manages deletion state for events, ensuring users can only delete their own events */
+export class DeleteManager {
+    /** A stream of pointers that may have been deleted */
+    deleted$;
+    /** Internal subject for deleted$ observable */
+    deletedSubject = new Subject();
+    /** Maps author pubkey to Set of event IDs they have deleted */
+    deletedIds = new Map();
+    /** Maps of author pubkey to Map of kind + "|" + identifier and timestamp of the delete event */
+    deletedIdentifiers = new Map();
+    constructor() {
+        this.deleted$ = this.deletedSubject.asObservable();
+    }
+    /**
+     * Process a kind 5 delete event
+     * Extracts event pointers and address pointers from the delete event
+     * Enforces that users can only delete their own events
+     */
+    add(deleteEvent) {
+        // SKip non-delete events
+        if (deleteEvent.kind !== kinds.EventDeletion)
+            return [];
+        const author = deleteEvent.pubkey;
+        const notifications = [];
+        // Extract event pointers from "e" tags (already filtered and author set by helper)
+        const eventPointers = getDeleteEventPointers(deleteEvent);
+        if (eventPointers.length > 0) {
+            let ids = this.deletedIds.get(author);
+            if (!ids) {
+                ids = new Set();
+                this.deletedIds.set(author, ids);
+            }
+            for (const pointer of eventPointers) {
+                ids.add(pointer.id);
+                const notification = {
+                    pointer,
+                    until: deleteEvent.created_at,
+                };
+                notifications.push(notification);
+                this.deletedSubject.next(notification);
+            }
+        }
+        // Add address pointers to memory
+        const addressPointers = getDeleteAddressPointers(deleteEvent);
+        if (addressPointers.length > 0) {
+            let identifiers = this.deletedIdentifiers.get(author);
+            if (!identifiers) {
+                identifiers = new Map();
+                this.deletedIdentifiers.set(author, identifiers);
+            }
+            for (const pointer of addressPointers) {
+                const key = pointer.kind + "|" + pointer.identifier;
+                identifiers.set(key, deleteEvent.created_at);
+                const notification = {
+                    pointer,
+                    until: deleteEvent.created_at,
+                };
+                notifications.push(notification);
+                this.deletedSubject.next(notification);
+            }
+        }
+        return notifications;
+    }
+    /**
+     * Check if an event is deleted
+     * Verifies the event was deleted by its own author
+     */
+    check(event) {
+        const author = event.pubkey;
+        if (isReplaceableKind(event.kind) || isAddressableKind(event.kind)) {
+            const identifiers = this.deletedIdentifiers.get(author);
+            if (!identifiers)
+                return false;
+            const identifier = getReplaceableIdentifier(event);
+            const key = event.kind + "|" + identifier;
+            const timestamp = identifiers.get(key);
+            if (timestamp === undefined)
+                return false;
+            // Check that the delete event timestamp is newer than the event
+            return timestamp >= event.created_at;
+        }
+        else {
+            const ids = this.deletedIds.get(author);
+            if (!ids)
+                return false;
+            // Check if that event id was deleted by the author
+            return ids.has(event.id);
+        }
+    }
+    /**
+     * Filter out all deleted events from an array of events
+     */
+    filter(events) {
+        return events.filter((event) => this.check(event) === false);
+    }
+}