applesauce-core 0.10.0 → 0.12.0

package/dist/observable/claim-events.js

@@ -0,0 +1,28 @@
+import { finalize, tap } from "rxjs";
+/** keep a claim on any event that goes through this observable, claims are removed when the observable completes */
+export function claimEvents(database) {
+    return (source) => {
+        const seen = new Set();
+        return source.pipe(
+        // claim all events
+        tap((message) => {
+            if (message === undefined)
+                return;
+            if (Array.isArray(message)) {
+                for (const event of message) {
+                    seen.add(event);
+                    database.claimEvent(event, source);
+                }
+            }
+            else {
+                seen.add(message);
+                database.claimEvent(message, source);
+            }
+        }), 
+        // remove claims on cleanup
+        finalize(() => {
+            for (const e of seen)
+                database.removeClaim(e, source);
+        }));
+    };
+}

package/dist/observable/claim-latest.d.ts

@@ -0,0 +1,5 @@
+import { MonoTypeOperatorFunction } from "rxjs";
+import { NostrEvent } from "nostr-tools";
+import { type Database } from "../event-store/database.js";
+/** An operator that claims the latest event with the database */
+export declare function claimLatest<T extends NostrEvent | undefined>(database: Database): MonoTypeOperatorFunction<T>;

package/dist/observable/claim-latest.js

@@ -0,0 +1,21 @@
+import { finalize, tap } from "rxjs";
+/** An operator that claims the latest event with the database */
+export function claimLatest(database) {
+    return (source) => {
+        let latest = undefined;
+        return source.pipe(tap((event) => {
+            // remove old claim
+            if (latest)
+                database.removeClaim(latest, source);
+            // claim new event
+            if (event)
+                database.claimEvent(event, source);
+            // update state
+            latest = event;
+        }), finalize(() => {
+            // remove latest claim
+            if (latest)
+                database.removeClaim(latest, source);
+        }));
+    };
+}

package/dist/observable/{get-value.d.ts → get-observable-value.d.ts}

@@ -1,3 +1,3 @@
 import { Observable } from "rxjs";
 /** Subscribes and returns the observables current or next value */
-export declare function getValue<T>(observable: Observable<T>): T | Promise<T>;
+export declare function getObservableValue<T>(observable: Observable<T>): T | Promise<T>;

package/dist/observable/{get-value.js → get-observable-value.js}

@@ -1,14 +1,9 @@
-import { BehaviorSubject } from "rxjs";
+import { BehaviorSubject, firstValueFrom } from "rxjs";
 /** Subscribes and returns the observables current or next value */
-export function getValue(observable) {
+export function getObservableValue(observable) {
     if (observable instanceof BehaviorSubject)
         return observable.value;
     if (Reflect.has(observable, "value"))
         return Reflect.get(observable, "value");
-    return new Promise((res) => {
-        const sub = observable.subscribe((v) => {
-            res(v);
-            sub.unsubscribe();
-        });
-    });
+    return firstValueFrom(observable);
 }

package/dist/observable/index.d.ts

@@ -1,2 +1,3 @@
-export * from "./get-value.js";
+export * from "./get-observable-value.js";
 export * from "./share-latest-value.js";
+export * from "./simple-timeout.js";

package/dist/observable/index.js

@@ -1,2 +1,3 @@
-export * from "./get-value.js";
+export * from "./get-observable-value.js";
 export * from "./share-latest-value.js";
+export * from "./simple-timeout.js";

package/dist/observable/share-latest-value.d.ts

@@ -1,8 +1,6 @@
-import { Observable, ShareConfig } from "rxjs";
+import { OperatorFunction } from "rxjs";
 /**
  * Creates an operator that adds a 'value' property and multiplexes the source
  * @param config Optional ShareConfig for customizing sharing behavior
  */
-export declare function shareLatestValue<T>(config?: ShareConfig<T>): (source: Observable<T>) => Observable<T> & {
-    value: T | undefined;
-};
+export declare function shareLatestValue<T>(): OperatorFunction<T, T | undefined>;

package/dist/observable/share-latest-value.js

@@ -1,21 +1,24 @@
-import { share } from "rxjs";
-import { tap } from "rxjs/operators";
+import { BehaviorSubject, share } from "rxjs";
 /**
  * Creates an operator that adds a 'value' property and multiplexes the source
  * @param config Optional ShareConfig for customizing sharing behavior
  */
-export function shareLatestValue(config = {}) {
-    return (source) => {
-        // Create storage for latest value
-        let latestValue = undefined;
-        // Create shared source with value tracking
-        const shared$ = source.pipe(tap((value) => {
-            latestValue = value;
-        }), share(config));
-        // Add value property
-        Object.defineProperty(shared$, "value", {
-            get: () => latestValue,
-        });
-        return shared$;
-    };
+export function shareLatestValue() {
+    return (source$) => source$.pipe(share({ connector: () => new BehaviorSubject(undefined) }));
+    // return (source: Observable<T>): Observable<T> & { value: T | undefined } => {
+    //   // Create storage for latest value
+    //   let latestValue: T | undefined = undefined;
+    //   // Create shared source with value tracking
+    //   const shared$ = source.pipe(
+    //     tap((value) => {
+    //       latestValue = value;
+    //     }),
+    //     share(config),
+    //   );
+    //   // Add value property
+    //   Object.defineProperty(shared$, "value", {
+    //     get: () => latestValue,
+    //   });
+    //   return shared$ as Observable<T> & { value: T | undefined };
+    // };
 }

package/dist/observable/simple-timeout.d.ts

@@ -0,0 +1,4 @@
+import { MonoTypeOperatorFunction } from "rxjs";
+export declare class TimeoutError extends Error {
+}
+export declare function simpleTimeout<T extends unknown>(first: number, message?: string): MonoTypeOperatorFunction<T>;

package/dist/observable/simple-timeout.js

@@ -0,0 +1,6 @@
+import { throwError, timeout } from "rxjs";
+export class TimeoutError extends Error {
+}
+export function simpleTimeout(first, message) {
+    return timeout({ first, with: () => throwError(() => new TimeoutError(message ?? "Timeout")) });
+}

package/dist/observable/with-immediate-value.d.ts

@@ -0,0 +1,3 @@
+import { OperatorFunction } from "rxjs";
+/** if a synchronous value is not emitted, default is emitted */
+export declare function withImmediateValueOrDefault<Value, Default extends unknown = unknown>(defaultValue: Default): OperatorFunction<Value, Value | Default>;

package/dist/observable/with-immediate-value.js

@@ -0,0 +1,19 @@
+import { Observable } from "rxjs";
+/** if a synchronous value is not emitted, default is emitted */
+export function withImmediateValueOrDefault(defaultValue) {
+    return (source) => new Observable((observer) => {
+        let seen = false;
+        const sub = source.subscribe({
+            next: (v) => {
+                seen = true;
+                observer.next(v);
+            },
+            error: (err) => observer.error(err),
+            complete: () => observer.complete(),
+        });
+        // if a value is not emitted sync, emit default
+        if (!seen)
+            observer.next(defaultValue);
+        return sub;
+    });
+}

package/dist/queries/blossom.d.ts

@@ -0,0 +1,2 @@
+import { Query } from "../query-store/index.js";
+export declare function UserBlossomServersQuery(pubkey: string): Query<URL[] | undefined>;

package/dist/queries/blossom.js

@@ -0,0 +1,10 @@
+import { map } from "rxjs/operators";
+import { BLOSSOM_SERVER_LIST_KIND, getBlossomServersFromList } from "../helpers/blossom.js";
+export function UserBlossomServersQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (store) => store
+            .replaceable(BLOSSOM_SERVER_LIST_KIND, pubkey)
+            .pipe(map((event) => event && getBlossomServersFromList(event))),
+    };
+}

package/dist/queries/bookmarks.d.ts

@@ -0,0 +1,8 @@
+import { Bookmarks } from "../helpers/bookmarks.js";
+import { Query } from "../query-store/index.js";
+export declare function UserBookmarkQuery(pubkey: string): Query<Bookmarks | undefined>;
+export declare function UserHiddenBookmarkQuery(pubkey: string): Query<(Bookmarks & {
+    locked: false;
+}) | {
+    locked: true;
+} | undefined>;

package/dist/queries/bookmarks.js

@@ -0,0 +1,23 @@
+import { kinds } from "nostr-tools";
+import { map } from "rxjs/operators";
+import { isHiddenTagsLocked } from "../helpers/index.js";
+import { getBookmarks, getHiddenBookmarks } from "../helpers/bookmarks.js";
+export function UserBookmarkQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (store) => store.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getBookmarks(event))),
+    };
+}
+export function UserHiddenBookmarkQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (store) => store.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => {
+            if (!event)
+                return undefined;
+            const bookmarks = getHiddenBookmarks(event);
+            if (isHiddenTagsLocked(event) || !bookmarks)
+                return { locked: true };
+            return { locked: false, ...bookmarks };
+        })),
+    };
+}

package/dist/queries/channels.d.ts

@@ -0,0 +1,11 @@
+import { Query } from "applesauce-core";
+import { NostrEvent } from "nostr-tools";
+import { ChannelMetadataContent } from "../helpers/channels.js";
+/** A query that returns a map of hidden messages Map<id, reason> */
+export declare function ChannelHiddenQuery(channel: NostrEvent, authors?: string[]): Query<Map<string, string>>;
+/** A query that returns all messages in a channel */
+export declare function ChannelMessagesQuery(channel: NostrEvent): Query<NostrEvent[]>;
+/** A query that returns the latest parsed metadata */
+export declare function ChannelMetadataQuery(channel: NostrEvent): Query<ChannelMetadataContent | undefined>;
+/** A query that returns a map of muted users Map<pubkey, reason> */
+export declare function ChannelMutedQuery(channel: NostrEvent, authors?: string[]): Query<Map<string, string>>;

package/dist/queries/channels.js

@@ -0,0 +1,73 @@
+import { safeParse } from "applesauce-core/helpers/json";
+import { kinds } from "nostr-tools";
+import { map } from "rxjs";
+import { getChannelMetadataContent } from "../helpers/channels.js";
+/** A query that returns a map of hidden messages Map<id, reason> */
+export function ChannelHiddenQuery(channel, authors = []) {
+    return {
+        key: channel.id,
+        run: (events) => {
+            const hidden = new Map();
+            return events
+                .filters([{ kinds: [kinds.ChannelHideMessage], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
+                .pipe(map((event) => {
+                const reason = safeParse(event.content)?.reason;
+                for (const tag of event.tags) {
+                    if (tag[0] === "e" && tag[1])
+                        hidden.set(tag[1], reason ?? "");
+                }
+                return hidden;
+            }));
+        },
+    };
+}
+/** A query that returns all messages in a channel */
+export function ChannelMessagesQuery(channel) {
+    return {
+        key: channel.id,
+        run: (events) => events.timeline([{ kinds: [kinds.ChannelMessage], "#e": [channel.id] }]),
+    };
+}
+/** A query that returns the latest parsed metadata */
+export function ChannelMetadataQuery(channel) {
+    return {
+        key: channel.id,
+        run: (events) => {
+            const filters = [
+                { ids: [channel.id] },
+                { kinds: [kinds.ChannelMetadata], "#e": [channel.id], authors: [channel.pubkey] },
+            ];
+            let latest = channel;
+            return events.filters(filters).pipe(map((event) => {
+                try {
+                    if (event.pubkey === latest.pubkey && event.created_at > latest.created_at) {
+                        latest = event;
+                    }
+                    return getChannelMetadataContent(latest);
+                }
+                catch (error) {
+                    return undefined;
+                }
+            }));
+        },
+    };
+}
+/** A query that returns a map of muted users Map<pubkey, reason> */
+export function ChannelMutedQuery(channel, authors = []) {
+    return {
+        key: channel.id + authors.join(","),
+        run: (events) => {
+            const muted = new Map();
+            return events
+                .filters([{ kinds: [kinds.ChannelMuteUser], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
+                .pipe(map((event) => {
+                const reason = safeParse(event.content)?.reason;
+                for (const tag of event.tags) {
+                    if (tag[0] === "p" && tag[1])
+                        muted.set(tag[1], reason ?? "");
+                }
+                return muted;
+            }));
+        },
+    };
+}

package/dist/queries/contacts.d.ts

@@ -0,0 +1,3 @@
+import { ProfilePointer } from "nostr-tools/nip19";
+import { Query } from "../query-store/index.js";
+export declare function UserContactsQuery(pubkey: string): Query<ProfilePointer[] | undefined>;

package/dist/queries/contacts.js

@@ -0,0 +1,12 @@
+import { kinds } from "nostr-tools";
+import { map } from "rxjs/operators";
+import { isPTag, processTags } from "../helpers/tags.js";
+import { getProfilePointerFromPTag } from "../helpers/pointers.js";
+export function UserContactsQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (store) => store
+            .replaceable(kinds.Contacts, pubkey)
+            .pipe(map((event) => event && processTags(event.tags.filter(isPTag), getProfilePointerFromPTag))),
+    };
+}

package/dist/queries/index.d.ts

@@ -1,5 +1,11 @@
+export * from "./blossom.js";
+export * from "./bookmarks.js";
+export * from "./channels.js";
 export * from "./comments.js";
+export * from "./contacts.js";
 export * from "./mailboxes.js";
+export * from "./mutes.js";
+export * from "./pins.js";
 export * from "./profile.js";
 export * from "./reactions.js";
 export * from "./simple.js";

package/dist/queries/index.js

@@ -1,5 +1,11 @@
+export * from "./blossom.js";
+export * from "./bookmarks.js";
+export * from "./channels.js";
 export * from "./comments.js";
+export * from "./contacts.js";
 export * from "./mailboxes.js";
+export * from "./mutes.js";
+export * from "./pins.js";
 export * from "./profile.js";
 export * from "./reactions.js";
 export * from "./simple.js";

package/dist/queries/mutes.d.ts

@@ -0,0 +1,8 @@
+import { Mutes } from "../helpers/mutes.js";
+import { Query } from "../query-store/index.js";
+export declare function UserMuteQuery(pubkey: string): Query<Mutes | undefined>;
+export declare function UserHiddenMuteQuery(pubkey: string): Query<(Mutes & {
+    locked: false;
+}) | {
+    locked: true;
+} | undefined>;

package/dist/queries/mutes.js

@@ -0,0 +1,23 @@
+import { kinds } from "nostr-tools";
+import { map } from "rxjs/operators";
+import { getHiddenMutedThings, getMutedThings } from "../helpers/mutes.js";
+import { isHiddenTagsLocked } from "../helpers/hidden-tags.js";
+export function UserMuteQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (event) => event.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getMutedThings(event))),
+    };
+}
+export function UserHiddenMuteQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (store) => store.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => {
+            if (!event)
+                return undefined;
+            const muted = getHiddenMutedThings(event);
+            if (isHiddenTagsLocked(event) || !muted)
+                return { locked: true };
+            return { locked: false, ...muted };
+        })),
+    };
+}

package/dist/queries/pins.d.ts

@@ -0,0 +1,3 @@
+import { Query } from "applesauce-core";
+import { EventPointer } from "nostr-tools/nip19";
+export declare function UserPinnedQuery(pubkey: string): Query<EventPointer[] | undefined>;

package/dist/queries/pins.js

@@ -0,0 +1,12 @@
+import { kinds } from "nostr-tools";
+import { map } from "rxjs/operators";
+import { isETag, processTags } from "../helpers/tags.js";
+import { getEventPointerFromETag } from "../helpers/pointers.js";
+export function UserPinnedQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (store) => store
+            .replaceable(kinds.Pinlist, pubkey)
+            .pipe(map((event) => event && processTags(event.tags.filter(isETag), getEventPointerFromETag))),
+    };
+}

package/dist/queries/simple.d.ts

@@ -3,14 +3,14 @@ import { Query } from "../query-store/index.js";
 /** Creates a Query that returns a single event or undefined */
 export declare function SingleEventQuery(id: string): Query<NostrEvent | undefined>;
 /** Creates a Query that returns a multiple events in a map */
-export declare function MultipleEventsQuery(ids: string[]): Query<Map<string, NostrEvent>>;
+export declare function MultipleEventsQuery(ids: string[]): Query<Record<string, NostrEvent>>;
 /** Creates a Query returning the latest version of a replaceable event */
 export declare function ReplaceableQuery(kind: number, pubkey: string, d?: string): Query<NostrEvent | undefined>;
 /** Creates a Query that returns an array of sorted events matching the filters */
-export declare function TimelineQuery(filters: Filter | Filter[], keepOldVersions?: boolean): Query<NostrEvent[]>;
+export declare function TimelineQuery(filters: Filter | Filter[], includeOldVersion?: boolean): Query<NostrEvent[]>;
 /** Creates a Query that returns a directory of events by their UID */
 export declare function ReplaceableSetQuery(pointers: {
     kind: number;
     pubkey: string;
     identifier?: string;
-}[]): Query<Map<string, NostrEvent>>;
+}[]): Query<Record<string, NostrEvent>>;

package/dist/queries/simple.js

@@ -22,11 +22,11 @@ export function ReplaceableQuery(kind, pubkey, d) {
     };
 }
 /** Creates a Query that returns an array of sorted events matching the filters */
-export function TimelineQuery(filters, keepOldVersions) {
+export function TimelineQuery(filters, includeOldVersion) {
     filters = Array.isArray(filters) ? filters : [filters];
     return {
-        key: hash_sum(filters) + (keepOldVersions ? "-history" : ""),
-        run: (events) => events.timeline(filters, keepOldVersions),
+        key: hash_sum(filters) + (includeOldVersion ? "-history" : ""),
+        run: (events) => events.timeline(filters, includeOldVersion),
     };
 }
 /** Creates a Query that returns a directory of events by their UID */

package/dist/queries/thread.js

@@ -34,7 +34,7 @@ export function ThreadQuery(root, opts) {
     }
     return {
         key: `${rootUID}-${kinds.join(",")}`,
-        run: (events) => events.stream([rootFilter, replyFilter]).pipe(map((event) => {
+        run: (events) => events.filters([rootFilter, replyFilter]).pipe(map((event) => {
             if (!items.has(getEventUID(event))) {
                 const refs = getNip10References(event);
                 const replies = parentReferences.get(getEventUID(event)) || new Set();

package/dist/queries/user-status.d.ts

@@ -0,0 +1,11 @@
+import { NostrEvent } from "nostr-tools";
+import { UserStatusPointer } from "../helpers/user-status.js";
+import { Query } from "../query-store/index.js";
+export type UserStatus = UserStatusPointer & {
+    event: NostrEvent;
+    content: string;
+};
+/** Creates a Query that returns a parsed {@link UserStatus} for a certain type */
+export declare function UserStatusQuery(pubkey: string, type?: string): Query<UserStatus | undefined | null>;
+/** Creates a Query that returns a directory of parsed {@link UserStatus} for a pubkey */
+export declare function UserStatusesQuery(pubkey: string): Query<Record<string, UserStatus>>;

package/dist/queries/user-status.js

@@ -0,0 +1,39 @@
+import { kinds } from "nostr-tools";
+import { map } from "rxjs";
+import { getUserStatusPointer } from "../helpers/user-status.js";
+import { getReplaceableIdentifier } from "../helpers/event.js";
+/** Creates a Query that returns a parsed {@link UserStatus} for a certain type */
+export function UserStatusQuery(pubkey, type = "general") {
+    return {
+        key: pubkey,
+        run: (events) => events.replaceable(kinds.UserStatuses, pubkey, type).pipe(map((event) => {
+            if (!event)
+                return undefined;
+            const pointer = getUserStatusPointer(event);
+            if (!pointer)
+                return null;
+            return {
+                ...pointer,
+                event,
+                content: event.content,
+            };
+        })),
+    };
+}
+/** Creates a Query that returns a directory of parsed {@link UserStatus} for a pubkey */
+export function UserStatusesQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (events) => events.timeline([{ kinds: [kinds.UserStatuses], authors: [pubkey] }]).pipe(map((events) => {
+            return events.reduce((dir, event) => {
+                try {
+                    const d = getReplaceableIdentifier(event);
+                    return { ...dir, [d]: { event, ...getUserStatusPointer(event), content: event.content } };
+                }
+                catch (error) {
+                    return dir;
+                }
+            }, {});
+        })),
+    };
+}

package/dist/query-store/__tests__/query-store.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/query-store/__tests__/query-store.test.js

@@ -0,0 +1,63 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { EventStore } from "../../event-store/event-store.js";
+import { QueryStore } from "../query-store.js";
+import { ProfileQuery } from "../../queries/profile.js";
+import { SingleEventQuery } from "../../queries/simple.js";
+let eventStore;
+let queryStore;
+const event = {
+    content: '{"name":"hzrd149","picture":"https://cdn.hzrd149.com/5ed3fe5df09a74e8c126831eac999364f9eb7624e2b86d521521b8021de20bdc.png","about":"JavaScript developer working on some nostr stuff\\n- noStrudel https://nostrudel.ninja/ \\n- Blossom https://github.com/hzrd149/blossom \\n- Applesauce https://hzrd149.github.io/applesauce/","website":"https://hzrd149.com","nip05":"_@hzrd149.com","lud16":"hzrd1499@minibits.cash","pubkey":"266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5","display_name":"hzrd149","displayName":"hzrd149","banner":""}',
+    created_at: 1738362529,
+    id: "e9df8d5898c4ccfbd21fcd59f3f48abb3ff0ab7259b19570e2f1756de1e9306b",
+    kind: 0,
+    pubkey: "266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5",
+    sig: "465a47b93626a587bf81dadc2b306b8f713a62db31d6ce1533198e9ae1e665a6eaf376a03250bf9ffbb02eb9059c8eafbd37ae1092d05d215757575bd8357586",
+    tags: [],
+};
+beforeEach(() => {
+    eventStore = new EventStore();
+    queryStore = new QueryStore(eventStore);
+});
+describe("createQuery", () => {
+    it("should emit synchronous value if it exists", () => {
+        let value = undefined;
+        eventStore.add(event);
+        queryStore.createQuery(ProfileQuery, event.pubkey).subscribe((v) => (value = v));
+        expect(value).not.toBe(undefined);
+    });
+    it("should not emit undefined if value exists", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(queryStore.createQuery(SingleEventQuery, event.id));
+        expect(spy.getValues()).toEqual([event]);
+    });
+    it("should emit synchronous undefined if value does not exists", () => {
+        let value = 0;
+        queryStore.createQuery(ProfileQuery, event.pubkey).subscribe((v) => {
+            value = v;
+        });
+        expect(value).not.toBe(0);
+        expect(value).toBe(undefined);
+    });
+    it("should share latest value", () => {
+        eventStore.add(event);
+        const spy = subscribeSpyTo(queryStore.createQuery(SingleEventQuery, event.id));
+        const spy2 = subscribeSpyTo(queryStore.createQuery(SingleEventQuery, event.id));
+        expect(spy.getValues()).toEqual([event]);
+        expect(spy2.getValues()).toEqual([event]);
+    });
+});
+describe("executeQuery", () => {
+    it("should resolve when value is already present", async () => {
+        eventStore.add(event);
+        expect(await queryStore.executeQuery(ProfileQuery, event.pubkey)).toEqual(expect.objectContaining({ name: "hzrd149" }));
+    });
+    it("should resolve when value is added to event store", async () => {
+        const p = queryStore.executeQuery(ProfileQuery, event.pubkey);
+        // delay adding the event
+        setTimeout(() => {
+            eventStore.add(event);
+        }, 10);
+        await expect(p).resolves.toEqual(expect.objectContaining({ name: "hzrd149" }));
+    });
+});