@nostrify/policies 0.36.2

package/.turbo/turbo-build.log

@@ -0,0 +1,5 @@
+
+
+> @nostrify/policies@0.36.2 build /home/sid/repos/NSpec/packages/policies
+> tsc -p tsconfig.json
+

package/AntiDuplicationPolicy.test.ts

@@ -0,0 +1,50 @@
+import { genEvent } from '@nostrify/nostrify/test';
+import { assertEquals } from '@std/assert';
+
+import { AntiDuplicationPolicy } from './AntiDuplicationPolicy.ts';
+
+Deno.test('AntiDuplicationPolicy', async () => {
+  using kv = await Deno.openKv(':memory:');
+
+  const policy = new AntiDuplicationPolicy({ kv });
+  const content = 'Spicy peppermint apricot mediterranean ginger carrot spiced juice edamame hummus';
+
+  const event1 = genEvent({ kind: 1, content });
+
+  assertEquals((await policy.call(event1))[2], true);
+  assertEquals((await policy.call(event1))[2], false);
+  assertEquals((await policy.call(event1))[2], false);
+
+  const event2 = genEvent({ kind: 1, content: 'a' });
+
+  assertEquals((await policy.call(event2))[2], true);
+  assertEquals((await policy.call(event2))[2], true);
+  assertEquals((await policy.call(event2))[2], true);
+});
+
+Deno.test('AntiDuplicationPolicy with deobfuscate', async () => {
+  using kv = await Deno.openKv(':memory:');
+
+  const policy = new AntiDuplicationPolicy({
+    kv,
+    deobfuscate: ({ content }) => (
+      content
+        .replace(/[\p{Emoji}\p{Emoji_Modifier}\p{Emoji_Component}\p{Emoji_Modifier_Base}\p{Emoji_Presentation}]/gu, '')
+        .replace(/\s/g, '')
+        .toLowerCase()
+    ),
+  });
+
+  const event1 = genEvent({
+    kind: 1,
+    content: 'Spicy peppermint apricot mediterranean ginger carrot spiced juice edamame hummus',
+  });
+
+  const event2 = genEvent({
+    kind: 1,
+    content: 'Spicy 🌶️  peppermint apricot 🍑 mediterranean 🌊 ginger carrot 🥕 spiced 🌶️ juice 🥤 edamame 🌱  hummus ',
+  });
+
+  assertEquals((await policy.call(event1))[2], true);
+  assertEquals((await policy.call(event2))[2], false);
+});

package/AntiDuplicationPolicy.ts

@@ -0,0 +1,78 @@
+import { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+import { Kv, KvKey } from '@deno/kv';
+
+/** Policy options for `AntiDuplicationPolicy`. */
+interface AntiDuplicationPolicyOpts {
+  /** Deno.Kv implementation to use. */
+  kv: Pick<Kv, 'get' | 'set'>;
+  /** Time in ms until a message with this content may be posted again. Default: `60000` (1 minute). */
+  expireIn?: number;
+  /** Note text under this limit will be skipped by the policy. Default: `50`. */
+  minLength?: number;
+  /** Normalize the event's content before a hash is taken, to prevent the attacker from making small changes. Should return the normalized content. */
+  deobfuscate?(event: NostrEvent): string;
+}
+
+/**
+ * Prevent messages with the exact same content from being submitted repeatedly.
+ *
+ * It stores a hashcode for each content in a Deno.Kv database and rate-limits them. Only messages that meet the minimum length criteria are selected.
+ * Each time a matching message is submitted, the timer will reset, so spammers sending the same message will only ever get the first one through.
+ *
+ * ```ts
+ * // Open a Deno.KV instance.
+ * const kv = await Deno.openKv();
+ *
+ * // Prevent the same message from being posted within 60 seconds.
+ * new AntiDuplicationPolicy({ kv, expireIn: 60000 });
+ *
+ * // Only enforce the policy on messages with at least 50 characters.
+ * new AntiDuplicationPolicy({ kv, expireIn: 60000, minLength: 50 });
+ * ```
+ */
+export class AntiDuplicationPolicy implements NPolicy {
+  constructor(private opts: AntiDuplicationPolicyOpts) {}
+
+  async call(event: NostrEvent): Promise<NostrRelayOK> {
+    const { id, kind } = event;
+    const { kv, expireIn = 60000, minLength = 50, deobfuscate } = this.opts;
+
+    const content = deobfuscate?.(event) ?? event.content;
+
+    if (kind === 1 && content.length >= minLength) {
+      const hash = AntiDuplicationPolicy.hashCode(content);
+      const key: KvKey = ['nostrify', 'policies', 'antiduplication', hash];
+
+      const { value } = await kv.get(key);
+
+      if (value) {
+        await kv.set(key, true, { expireIn });
+        return [
+          'OK',
+          id,
+          false,
+          'blocked: the same message has been repeated too many times',
+        ];
+      }
+
+      await kv.set(key, true, { expireIn });
+    }
+
+    return ['OK', id, true, ''];
+  }
+
+  /**
+   * Get a "good enough" unique identifier for this content.
+   * This algorithm was chosen because it's very fast with a low chance of collisions.
+   * https://stackoverflow.com/a/8831937
+   */
+  private static hashCode(str: string): number {
+    let hash = 0;
+    for (let i = 0, len = str.length; i < len; i++) {
+      const chr = str.charCodeAt(i);
+      hash = (hash << 5) - hash + chr;
+      hash |= 0; // Convert to 32bit integer
+    }
+    return hash;
+  }
+}

package/AnyPolicy.test.ts

@@ -0,0 +1,57 @@
+import { assertEquals } from '@std/assert';
+import { finalizeEvent, generateSecretKey } from 'nostr-tools';
+
+import { AnyPolicy } from './AnyPolicy.ts';
+import { NoOpPolicy } from './NoOpPolicy.ts';
+import { ReadOnlyPolicy } from './ReadOnlyPolicy.ts';
+
+Deno.test('accepts when all policies accept', async () => {
+  const policy = new AnyPolicy([
+    new NoOpPolicy(),
+    new NoOpPolicy(),
+    new NoOpPolicy(),
+  ]);
+
+  const event = finalizeEvent(
+    { kind: 1, content: '', tags: [], created_at: 0 },
+    generateSecretKey(),
+  );
+
+  const [_, _eventId, ok] = await policy.call(event);
+
+  assertEquals(ok, true);
+});
+
+Deno.test('accepts when some policies reject', async () => {
+  const policy = new AnyPolicy([
+    new NoOpPolicy(),
+    new ReadOnlyPolicy(),
+    new NoOpPolicy(),
+  ]);
+
+  const event = finalizeEvent(
+    { kind: 1, content: '', tags: [], created_at: 0 },
+    generateSecretKey(),
+  );
+
+  const [_, _eventId, ok] = await policy.call(event);
+
+  assertEquals(ok, true);
+});
+
+Deno.test('rejects when all policies reject', async () => {
+  const policy = new AnyPolicy([
+    new ReadOnlyPolicy(),
+    new ReadOnlyPolicy(),
+    new ReadOnlyPolicy(),
+  ]);
+
+  const event = finalizeEvent(
+    { kind: 1, content: '', tags: [], created_at: 0 },
+    generateSecretKey(),
+  );
+
+  const [_, _eventId, ok] = await policy.call(event);
+
+  assertEquals(ok, false);
+});

package/AnyPolicy.ts

@@ -0,0 +1,21 @@
+import { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+
+/** Similar to `PipePolicy`, but passes if at least one policy passes. */
+export class AnyPolicy implements NPolicy {
+  constructor(private policies: NPolicy[]) {}
+
+  async call(event: NostrEvent, signal?: AbortSignal): Promise<NostrRelayOK> {
+    let result: NostrRelayOK = ['OK', event.id, false, 'blocked: no policy passed'];
+
+    for (const policy of this.policies) {
+      result = await policy.call(event, signal);
+
+      const ok = result[2];
+      if (ok) {
+        return result;
+      }
+    }
+
+    return result;
+  }
+}

package/AuthorPolicy.test.ts

@@ -0,0 +1,23 @@
+import { genEvent, MockRelay } from '@nostrify/nostrify/test';
+import { assertEquals } from '@std/assert';
+import { generateSecretKey } from 'nostr-tools';
+
+import { AuthorPolicy } from './AuthorPolicy.ts';
+
+Deno.test('AuthorPolicy', async () => {
+  const store = new MockRelay();
+  const policy = new AuthorPolicy(store);
+
+  const sk = generateSecretKey();
+  const event = genEvent({ kind: 1 }, sk);
+
+  const [, , ok1] = await policy.call(event);
+
+  assertEquals(ok1, false);
+
+  await store.event(genEvent({ kind: 0 }, sk));
+
+  const [, , ok2] = await policy.call(event);
+
+  assertEquals(ok2, true);
+});

package/AuthorPolicy.ts

@@ -0,0 +1,23 @@
+import { NostrEvent, NostrRelayOK, NPolicy, NStore } from '@nostrify/types';
+
+/** Rejects events by authors without a kind 0, then optionally applies another policy to the kind 0. */
+export class AuthorPolicy implements NPolicy {
+  constructor(private store: NStore, private policy?: NPolicy) {}
+
+  async call(event: NostrEvent, signal?: AbortSignal): Promise<NostrRelayOK> {
+    const author: NostrEvent | undefined = event.kind === 0 ? event : await this.store
+      .query([{ kinds: [0], authors: [event.pubkey], limit: 1 }], { signal })
+      .then(([event]) => event);
+
+    if (!author) {
+      return ['OK', event.id, false, 'blocked: author is missing a kind 0 event'];
+    }
+
+    if (this.policy) {
+      const [, , ok, reason] = await this.policy.call(author, signal);
+      return ['OK', event.id, ok, reason];
+    }
+
+    return ['OK', event.id, true, ''];
+  }
+}

package/CHANGELOG.md

@@ -0,0 +1,66 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## 0.36.2 - 2025-06-06
+
+### Fixed
+
+- DomainPolicy blacklist now includes subdomains.
+
+## 0.36.1 - 2024-10-09
+
+### Fixed
+
+- WoTPolicy: fix unhandled promise rejection by delaying getPubkeys until the first call.
+
+## 0.36.0 - 2024-09-25
+
+### Added
+
+- Added WoTPolicy to whitelist follows of follows.
+
+## 0.35.0 - 2024-09-23
+
+### Added
+
+- AntiDuplicationPolicy: added `deobfuscate` option to pre-process event content before taking the hash.
+
+## 0.34.0 - 2024-09-21
+
+### Added
+
+- Added DomainPolicy to filter events by NIP-05 domain.
+
+## 0.33.1 - 2024-09-11
+
+### Fixed
+
+- AuthorPolicy: treat kind 0s as its own author
+
+## 0.33.0 - 2024-09-09
+
+### Fixed
+
+- Exported `ReplyBotPolicy` and `AuthorPolicy`.
+
+## 0.32.0 - 2024-09-09
+
+### Added
+
+- ReplyBotPolicy: accept a `signal`.
+- PipePolicy: accept a `signal`.
+- AnyPolicy: accept a `signal`.
+
+### Changed
+
+- BREAKING: OpenAIPolicy: Removed `timeout` opt. It now accept a `signal` in its `call` method.
+
+## 0.31.0 - 2024-09-09
+
+### Added
+
+- Initial release of `@nostrify/policies`, moved from `@nostrify/nostrify/policies`.

package/DomainPolicy.test.ts

@@ -0,0 +1,246 @@
+import { genEvent, MockRelay } from '@nostrify/nostrify/test';
+import { NostrMetadata } from '@nostrify/types';
+import { assertEquals } from '@std/assert';
+import { generateSecretKey, getPublicKey } from 'nostr-tools';
+
+import { DomainPolicy } from './DomainPolicy.ts';
+
+Deno.test('DomainPolicy allows events from authors with a valid nip05', async () => {
+  const sk = generateSecretKey();
+  const pubkey = getPublicKey(sk);
+
+  const store = new MockRelay();
+  const policy = new DomainPolicy(store, {
+    // deno-lint-ignore require-await
+    async lookup(nip05: string) {
+      if (nip05 === 'alex@gleasonator.dev') {
+        return { pubkey };
+      } else {
+        throw new Error('not found');
+      }
+    },
+  });
+
+  const metadata: NostrMetadata = { nip05: 'alex@gleasonator.dev' };
+  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
+  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+
+  const result = await policy.call(event);
+
+  assertEquals(result, ['OK', event.id, true, '']);
+});
+
+Deno.test('DomainPolicy rejects events from authors without a kind 0', async () => {
+  const store = new MockRelay();
+  const policy = new DomainPolicy(store);
+  const event = genEvent({ kind: 1, content: 'hello world' });
+
+  const result = await policy.call(event);
+
+  assertEquals(result, ['OK', event.id, false, 'blocked: author is missing a kind 0 event']);
+});
+
+Deno.test('DomainPolicy rejects events from authors with a missing nip05', async () => {
+  const store = new MockRelay();
+  const policy = new DomainPolicy(store);
+
+  const sk = generateSecretKey();
+  const metadata: NostrMetadata = {};
+  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
+  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+
+  const result = await policy.call(event);
+
+  assertEquals(result, ['OK', event.id, false, 'blocked: missing nip05']);
+});
+
+Deno.test('DomainPolicy rejects events from authors with a malformed nip05', async () => {
+  const store = new MockRelay();
+  const policy = new DomainPolicy(store);
+
+  const sk = generateSecretKey();
+  const metadata: NostrMetadata = { nip05: 'asdf' };
+  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
+  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+
+  const result = await policy.call(event);
+
+  assertEquals(result, ['OK', event.id, false, 'blocked: missing nip05']);
+});
+
+Deno.test('DomainPolicy rejects events from authors with an invalid nip05', async () => {
+  const store = new MockRelay();
+
+  const policy = new DomainPolicy(store, {
+    // deno-lint-ignore require-await
+    async lookup(_nip05: string) {
+      const pubkey = getPublicKey(generateSecretKey());
+      return { pubkey };
+    },
+  });
+
+  const metadata: NostrMetadata = { nip05: 'alex@gleasonator.dev' };
+  const sk = generateSecretKey();
+  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
+  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+
+  const result = await policy.call(event);
+
+  assertEquals(result, ['OK', event.id, false, 'blocked: mismatched nip05 pubkey']);
+});
+
+Deno.test('DomainPolicy rejects events from authors with a blacklisted nip05 domain', async () => {
+  const sk = generateSecretKey();
+  const pubkey = getPublicKey(sk);
+
+  const store = new MockRelay();
+  const policy = new DomainPolicy(store, {
+    // deno-lint-ignore require-await
+    async lookup(nip05: string) {
+      if (nip05 === 'bot@replyguy.dev') {
+        return { pubkey };
+      } else {
+        throw new Error('not found');
+      }
+    },
+    blacklist: ['replyguy.dev'],
+  });
+
+  const metadata: NostrMetadata = { nip05: 'bot@replyguy.dev' };
+  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
+  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+
+  const result = await policy.call(event);
+
+  assertEquals(result, ['OK', event.id, false, 'blocked: blacklisted nip05 domain']);
+});
+
+Deno.test("DomainPolicy rejects events from authors who aren't on a whitelisted domain", async () => {
+  const sk = generateSecretKey();
+  const pubkey = getPublicKey(sk);
+
+  const store = new MockRelay();
+  const policy = new DomainPolicy(store, {
+    // deno-lint-ignore require-await
+    async lookup(nip05: string) {
+      if (nip05 === 'bot@replyguy.dev') {
+        return { pubkey };
+      } else {
+        throw new Error('not found');
+      }
+    },
+    whitelist: ['gleasonator.dev'],
+  });
+
+  const metadata: NostrMetadata = { nip05: 'bot@replyguy.dev' };
+  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
+  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+
+  const result = await policy.call(event);
+
+  assertEquals(result, ['OK', event.id, false, 'blocked: nip05 domain not in whitelist']);
+});
+
+Deno.test('DomainPolicy allows events from authors who are on a whitelisted domain', async () => {
+  const sk = generateSecretKey();
+  const pubkey = getPublicKey(sk);
+
+  const store = new MockRelay();
+  const policy = new DomainPolicy(store, {
+    // deno-lint-ignore require-await
+    async lookup(nip05: string) {
+      if (nip05 === 'alex@gleasonator.dev') {
+        return { pubkey };
+      } else {
+        throw new Error('not found');
+      }
+    },
+    whitelist: ['gleasonator.dev'],
+  });
+
+  const metadata: NostrMetadata = { nip05: 'alex@gleasonator.dev' };
+  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
+  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+
+  const result = await policy.call(event);
+
+  assertEquals(result, ['OK', event.id, true, '']);
+});
+
+Deno.test('DomainPolicy rejects events from authors with a subdomain of a blacklisted domain', async () => {
+  const sk = generateSecretKey();
+  const pubkey = getPublicKey(sk);
+
+  const store = new MockRelay();
+  const policy = new DomainPolicy(store, {
+    // deno-lint-ignore require-await
+    async lookup(nip05: string) {
+      if (nip05 === 'bot@spam.replyguy.dev') {
+        return { pubkey };
+      } else {
+        throw new Error('not found');
+      }
+    },
+    blacklist: ['replyguy.dev'],
+  });
+
+  const metadata: NostrMetadata = { nip05: 'bot@spam.replyguy.dev' };
+  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
+  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+
+  const result = await policy.call(event);
+
+  assertEquals(result, ['OK', event.id, false, 'blocked: blacklisted nip05 domain']);
+});
+
+Deno.test('DomainPolicy rejects events from authors with a deeply nested subdomain of a blacklisted domain', async () => {
+  const sk = generateSecretKey();
+  const pubkey = getPublicKey(sk);
+
+  const store = new MockRelay();
+  const policy = new DomainPolicy(store, {
+    // deno-lint-ignore require-await
+    async lookup(nip05: string) {
+      if (nip05 === 'user@deep.nested.spam.replyguy.dev') {
+        return { pubkey };
+      } else {
+        throw new Error('not found');
+      }
+    },
+    blacklist: ['replyguy.dev'],
+  });
+
+  const metadata: NostrMetadata = { nip05: 'user@deep.nested.spam.replyguy.dev' };
+  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
+  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+
+  const result = await policy.call(event);
+
+  assertEquals(result, ['OK', event.id, false, 'blocked: blacklisted nip05 domain']);
+});
+
+Deno.test('DomainPolicy allows events from authors with similar but not subdomain of blacklisted domain', async () => {
+  const sk = generateSecretKey();
+  const pubkey = getPublicKey(sk);
+
+  const store = new MockRelay();
+  const policy = new DomainPolicy(store, {
+    // deno-lint-ignore require-await
+    async lookup(nip05: string) {
+      if (nip05 === 'user@notreplyguy.dev') {
+        return { pubkey };
+      } else {
+        throw new Error('not found');
+      }
+    },
+    blacklist: ['replyguy.dev'],
+  });
+
+  const metadata: NostrMetadata = { nip05: 'user@notreplyguy.dev' };
+  await store.event(genEvent({ kind: 0, content: JSON.stringify(metadata) }, sk));
+  const event = genEvent({ kind: 1, content: 'hello world' }, sk);
+
+  const result = await policy.call(event);
+
+  assertEquals(result, ['OK', event.id, true, '']);
+});

package/DomainPolicy.ts

@@ -0,0 +1,96 @@
+import { NIP05, NSchema as n } from '@nostrify/nostrify';
+import { NPolicy, NProfilePointer, NStore } from '@nostrify/types';
+
+import { AuthorPolicy } from './AuthorPolicy';
+
+/** Options for `DomainPolicy`. */
+interface DomainPolicyOpts {
+  /** Custom NIP-05 lookup function. */
+  lookup?(nip05: string, signal?: AbortSignal): Promise<NProfilePointer>;
+  /** List of domains to blacklist. Reject events from users with a NIP-05 matching any of these domains. */
+  blacklist?: string[];
+  /** List of domains to whitelist. If provided, only events from users with a valid NIP-05 on the given domains will be accepted. */
+  whitelist?: string[];
+}
+
+/** Ban events unless their author has a valid NIP-05 name. Domains can also be whitelisted or blacklisted. */
+export class DomainPolicy extends AuthorPolicy implements NPolicy {
+  constructor(store: NStore, opts: DomainPolicyOpts = {}) {
+    super(store, {
+      async call(event, signal) {
+        const { blacklist = [], whitelist, lookup = DomainPolicy.lookup } = opts;
+
+        const metadata = n.json().pipe(n.metadata()).safeParse(event.content);
+
+        if (!metadata.success) {
+          return ['OK', event.id, false, 'blocked: invalid kind 0 metadata'];
+        }
+
+        const { nip05 } = metadata.data;
+
+        if (!nip05) {
+          return ['OK', event.id, false, 'blocked: missing nip05'];
+        }
+
+        const domain = nip05.split('@').pop();
+
+        if (!domain) {
+          return ['OK', event.id, false, 'blocked: invalid nip05'];
+        }
+
+        if (DomainPolicy.isDomainBlacklisted(domain, blacklist)) {
+          return ['OK', event.id, false, 'blocked: blacklisted nip05 domain'];
+        }
+
+        try {
+          const { pubkey } = await lookup(nip05, signal);
+
+          if (pubkey !== event.pubkey) {
+            return ['OK', event.id, false, 'blocked: mismatched nip05 pubkey'];
+          }
+
+          if (whitelist && !whitelist.includes(domain)) {
+            return [
+              'OK',
+              event.id,
+              false,
+              'blocked: nip05 domain not in whitelist',
+            ];
+          }
+
+          return ['OK', event.id, true, ''];
+        } catch {
+          return ['OK', event.id, false, 'blocked: failed to lookup nip05'];
+        }
+      },
+    });
+  }
+
+  /** Check if a domain is blacklisted, including subdomains of blacklisted domains. */
+  private static isDomainBlacklisted(
+    domain: string,
+    blacklist: string[],
+  ): boolean {
+    // Check for exact match
+    if (blacklist.includes(domain)) {
+      return true;
+    }
+
+    // Check if domain is a subdomain of any blacklisted domain
+    for (const blacklistedDomain of blacklist) {
+      if (domain.endsWith('.' + blacklistedDomain)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /** Default NIP-05 lookup method if one isn't provided by the caller. */
+  private static lookup(
+    nip05: string,
+    signal?: AbortSignal,
+  ): Promise<NProfilePointer> {
+    return NIP05.lookup(nip05, { signal });
+  }
+}

package/FiltersPolicy.test.ts

@@ -0,0 +1,14 @@
+import { assertEquals } from '@std/assert';
+import { finalizeEvent, generateSecretKey } from 'nostr-tools';
+
+import { FiltersPolicy } from './FiltersPolicy.ts';
+
+Deno.test('FiltersPolicy', async () => {
+  const event = finalizeEvent(
+    { kind: 1, content: '', tags: [], created_at: 0 },
+    generateSecretKey(),
+  );
+
+  assertEquals((await new FiltersPolicy([{ kinds: [1] }]).call(event))[2], true);
+  assertEquals((await new FiltersPolicy([{ kinds: [1], authors: [] }]).call(event))[2], false);
+});