applesauce-signers 3.0.0 → 3.1.0

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./interface.js";
+export * from "./interop.js";
 export * from "./signers/index.js";
 export * as Helpers from "./helpers/index.js";

package/dist/index.js

@@ -1,3 +1,3 @@
-export * from "./interface.js";
+export * from "./interop.js";
 export * from "./signers/index.js";
 export * as Helpers from "./helpers/index.js";

package/dist/interop.d.ts

@@ -0,0 +1,49 @@
+import { EventTemplate, Filter, NostrEvent } from "nostr-tools";
+import { ObservableInput } from "rxjs";
+export type ISigner = {
+    getPublicKey: () => Promise<string>;
+    signEvent: (template: EventTemplate) => Promise<NostrEvent>;
+    nip04?: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
+    };
+    nip44?: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
+    };
+};
+/** @deprecated Use ISigner instead */
+export type Nip07Interface = ISigner;
+/** A method used to subscribe to events on a set of relays */
+export type NostrSubscriptionMethod = (relays: string[], filters: Filter[]) => ObservableInput<NostrEvent | string>;
+/** A method used for publishing an event, can return a Promise that completes when published or an Observable that completes when published*/
+export type NostrPublishMethod = (relays: string[], event: NostrEvent) => Promise<any> | ObservableInput<any>;
+/** A simple pool type that combines the subscription and publish methods */
+export type NostrPool = {
+    subscription: NostrSubscriptionMethod;
+    publish: NostrPublishMethod;
+};
+/** Options for setting the subscription and publish methods */
+export type NostrConnectionMethodsOptions = {
+    /** An optional method for subscribing to relays */
+    subscriptionMethod?: NostrSubscriptionMethod;
+    /** An optional method for publishing events */
+    publishMethod?: NostrPublishMethod;
+    /** An optional pool for connection methods */
+    pool?: NostrPool;
+};
+/** A class that implements has global fallback methods for subscription and publish methods */
+export interface NostrConnectionClassMethods {
+    new (...args: any[]): any;
+    /** A fallback method to use for subscriptionMethod if none is passed in when creating the client */
+    subscriptionMethod: NostrSubscriptionMethod | undefined;
+    /** A fallback method to use for publishMethod if none is passed in when creating the client */
+    publishMethod: NostrPublishMethod | undefined;
+    /** A fallback pool to use if none is pass in when creating the signer */
+    pool: NostrPool | undefined;
+}
+/** Get the subscription and publish methods for a NostrConnect class */
+export declare function getConnectionMethods(options: NostrConnectionMethodsOptions, cls?: NostrConnectionClassMethods): {
+    subscriptionMethod: NostrSubscriptionMethod;
+    publishMethod: NostrPublishMethod;
+};

package/dist/interop.js

@@ -0,0 +1,19 @@
+/** Get the subscription and publish methods for a NostrConnect class */
+export function getConnectionMethods(options, cls) {
+    const subscriptionMethod = options.subscriptionMethod ||
+        options.pool?.subscription.bind(options.pool) ||
+        cls?.subscriptionMethod ||
+        cls?.pool?.subscription.bind(cls.pool);
+    if (!subscriptionMethod)
+        throw new Error("Missing subscriptionMethod, either pass a method or set subscriptionMethod globally on the class");
+    const publishMethod = options.publishMethod ||
+        options.pool?.publish.bind(options.pool) ||
+        cls?.publishMethod ||
+        cls?.pool?.publish.bind(cls.pool);
+    if (!publishMethod)
+        throw new Error("Missing publishMethod, either pass a method or set publishMethod globally on the class");
+    return {
+        subscriptionMethod,
+        publishMethod,
+    };
+}

package/dist/signers/amber-clipboard-signer.d.ts

@@ -1,5 +1,5 @@
 import { EventTemplate, VerifiedEvent, verifyEvent } from "nostr-tools";
-import { ISigner } from "../interface.js";
+import { ISigner } from "../interop.js";
 /**
  * A Signer for [amber](https://github.com/greenart7c3/Amber) clipboard API
  * @see https://github.com/greenart7c3/Amber/blob/master/docs/web-apps.md

package/dist/signers/extension-signer.d.ts

@@ -1,5 +1,5 @@
 import { EventTemplate, VerifiedEvent } from "nostr-tools";
-import { ISigner } from "../interface.js";
+import { ISigner } from "../interop.js";
 /** AN error that is throw when the window.nostr extension is missing */
 export declare class ExtensionMissingError extends Error {
 }

package/dist/signers/nostr-connect-provider.d.ts

@@ -1,8 +1,7 @@
 import { EventTemplate, NostrEvent } from "nostr-tools";
+import { Subscription } from "rxjs";
 import { ConnectRequestParams, ConnectResponseResults, NostrConnectMethod, NostrConnectResponse, NostrConnectURI } from "../helpers/nostr-connect.js";
-import { ISigner } from "../interface.js";
-import { Unsubscribable } from "../helpers/observable.js";
-import { NostrPool, NostrPublishMethod, NostrSubscriptionMethod } from "./nostr-connect-signer.js";
+import { ISigner, NostrConnectionMethodsOptions, NostrPool, NostrPublishMethod, NostrSubscriptionMethod } from "../interop.js";
 export interface ProviderAuthorization {
     /** A method used to accept or reject `connect` requests */
     onConnect?: (client: string, permissions: string[]) => boolean | Promise<boolean>;
@@ -17,7 +16,7 @@ export interface ProviderAuthorization {
     /** A method used to accept or reject `nip44_decrypt` requests */
     onNip44Decrypt?: (pubkey: string, ciphertext: string, client: string) => boolean | Promise<boolean>;
 }
-export type NostrConnectProviderOptions = ProviderAuthorization & {
+export type NostrConnectProviderOptions = ProviderAuthorization & NostrConnectionMethodsOptions & {
     /** The relays to communicate over */
     relays: string[];
     /** The signer to use for signing events and encryption */
@@ -30,12 +29,6 @@ export type NostrConnectProviderOptions = ProviderAuthorization & {
     onClientConnect?: (client: string) => any;
     /** Callback for when a client disconnects (previously connected and the provider stops) */
     onClientDisconnect?: (client: string) => void;
-    /** A method for subscribing to relays */
-    subscriptionMethod?: NostrSubscriptionMethod;
-    /** A method for publishing events */
-    publishMethod?: NostrPublishMethod;
-    /** A pool of methods to use if none are passed in when creating the provider */
-    pool?: NostrPool;
 };
 export declare class NostrConnectProvider implements ProviderAuthorization {
     /** A fallback method to use for subscriptionMethod if none is passed in when creating the provider */
@@ -81,9 +74,9 @@ export declare class NostrConnectProvider implements ProviderAuthorization {
     onNip44Encrypt?: (pubkey: string, plaintext: string, client: string) => boolean | Promise<boolean>;
     /** A method used to accept or reject `nip44_decrypt` requests */
     onNip44Decrypt?: (pubkey: string, ciphertext: string, client: string) => boolean | Promise<boolean>;
-    constructor(opts: NostrConnectProviderOptions);
+    constructor(options: NostrConnectProviderOptions);
     /** The currently active REQ subscription */
-    protected req?: Unsubscribable;
+    protected req?: Subscription;
     /** Updates the relay subscription to listen for request events */
     protected updateSubscription(): Promise<void>;
     /**

package/dist/signers/nostr-connect-provider.js

@@ -1,10 +1,12 @@
 import { logger } from "applesauce-core";
 import { getEncryptedContentEncryptionMethods, getHiddenContent, isEvent, unixNow, unlockHiddenContent, } from "applesauce-core/helpers";
 import { createDefer } from "applesauce-core/promise";
-import { kinds, verifyEvent } from "nostr-tools";
 import { nanoid } from "nanoid";
+import { kinds, verifyEvent } from "nostr-tools";
+import { filter, from, repeat, retry } from "rxjs";
 import { isNIP04 } from "../helpers/encryption.js";
 import { createBunkerURI, NostrConnectMethod, parseNostrConnectURI, } from "../helpers/nostr-connect.js";
+import { getConnectionMethods, } from "../interop.js";
 import { SimpleSigner } from "./simple-signer.js";
 export class NostrConnectProvider {
     /** A fallback method to use for subscriptionMethod if none is passed in when creating the provider */
@@ -50,45 +52,34 @@ export class NostrConnectProvider {
     onNip44Encrypt;
     /** A method used to accept or reject `nip44_decrypt` requests */
     onNip44Decrypt;
-    constructor(opts) {
-        this.relays = opts.relays;
-        this.upstream = opts.upstream;
-        this.signer = opts.signer ?? new SimpleSigner();
-        this.secret = opts.secret;
+    constructor(options) {
+        this.relays = options.relays;
+        this.upstream = options.upstream;
+        this.signer = options.signer ?? new SimpleSigner();
+        this.secret = options.secret;
         // Get the subscription and publish methods
-        const subscriptionMethod = opts.subscriptionMethod ||
-            opts.pool?.subscription ||
-            NostrConnectProvider.subscriptionMethod ||
-            NostrConnectProvider.pool?.subscription;
-        if (!subscriptionMethod)
-            throw new Error("Missing subscriptionMethod, either pass a method or set NostrConnectProvider.subscriptionMethod");
-        const publishMethod = opts.publishMethod ||
-            opts.pool?.publish ||
-            NostrConnectProvider.publishMethod ||
-            NostrConnectProvider.pool?.publish;
-        if (!publishMethod)
-            throw new Error("Missing publishMethod, either pass a method or set NostrConnectProvider.publishMethod");
+        const { subscriptionMethod, publishMethod } = getConnectionMethods(options, NostrConnectProvider);
         // Use arrow functions so "this" isn't bound to the signer
         this.subscriptionMethod = (relays, filters) => subscriptionMethod(relays, filters);
         this.publishMethod = (relays, event) => publishMethod(relays, event);
         // Set client connection callbacks
-        if (opts.onClientConnect)
-            this.onClientConnect = opts.onClientConnect;
-        if (opts.onClientDisconnect)
-            this.onClientDisconnect = opts.onClientDisconnect;
+        if (options.onClientConnect)
+            this.onClientConnect = options.onClientConnect;
+        if (options.onClientDisconnect)
+            this.onClientDisconnect = options.onClientDisconnect;
         // Set authorization callbacks
-        if (opts.onConnect)
-            this.onConnect = opts.onConnect;
-        if (opts.onSignEvent)
-            this.onSignEvent = opts.onSignEvent;
-        if (opts.onNip04Encrypt)
-            this.onNip04Encrypt = opts.onNip04Encrypt;
-        if (opts.onNip04Decrypt)
-            this.onNip04Decrypt = opts.onNip04Decrypt;
-        if (opts.onNip44Encrypt)
-            this.onNip44Encrypt = opts.onNip44Encrypt;
-        if (opts.onNip44Decrypt)
-            this.onNip44Decrypt = opts.onNip44Decrypt;
+        if (options.onConnect)
+            this.onConnect = options.onConnect;
+        if (options.onSignEvent)
+            this.onSignEvent = options.onSignEvent;
+        if (options.onNip04Encrypt)
+            this.onNip04Encrypt = options.onNip04Encrypt;
+        if (options.onNip04Decrypt)
+            this.onNip04Decrypt = options.onNip04Decrypt;
+        if (options.onNip44Encrypt)
+            this.onNip44Encrypt = options.onNip44Encrypt;
+        if (options.onNip44Decrypt)
+            this.onNip44Decrypt = options.onNip44Decrypt;
     }
     /** The currently active REQ subscription */
     req;
@@ -98,7 +89,7 @@ export class NostrConnectProvider {
             this.req.unsubscribe();
         const pubkey = await this.signer.getPublicKey();
         // Setup subscription to listen for requests
-        this.req = this.subscriptionMethod(this.relays, [
+        this.req = from(this.subscriptionMethod(this.relays, [
             // If client is known, only listen for requests from the client
             this.client
                 ? {
@@ -111,9 +102,15 @@ export class NostrConnectProvider {
                         kinds: [kinds.NostrConnect],
                         "#p": [pubkey],
                     },
-        ]).subscribe({
-            next: (event) => typeof event !== "string" && this.handleEvent(event),
-        });
+        ]))
+            .pipe(
+        // Keep the connection open indefinitely
+        repeat(), 
+        // Retry on connection failure
+        retry(), 
+        // Ignore strings (support for applesauce-relay)
+        filter((event) => typeof event !== "string"))
+            .subscribe(this.handleEvent.bind(this));
     }
     /**
      * Start the provider
@@ -254,9 +251,12 @@ export class NostrConnectProvider {
         const providerPubkey = await this.signer.getPublicKey();
         if (target !== providerPubkey)
             throw new Error("Invalid target pubkey");
-        // If a secret is set, check that if matches
-        if (this.secret && this.secret !== secret)
-            throw new Error("Invalid secret");
+        // If the client is already known, ensure that it matches the new client
+        if (this.client && this.client !== client)
+            throw new Error("Only one client can connect at a time");
+        // If this is the first `connect` request, check that the secret matches
+        if (this.secret && !this.client && this.secret !== secret)
+            throw new Error("Invalid connection secret");
         // Handle authorization if callback is provided
         if (this.onConnect) {
             const authorized = await this.onConnect(client, permissions);

package/dist/signers/nostr-connect-signer.d.ts

@@ -1,9 +1,9 @@
 import { Deferred } from "applesauce-core/promise";
-import { ISigner, SimpleSigner } from "applesauce-signers";
-import { EventTemplate, Filter, NostrEvent, verifyEvent } from "nostr-tools";
+import { ISigner, NostrConnectionMethodsOptions, NostrPool, NostrPublishMethod, NostrSubscriptionMethod, SimpleSigner } from "applesauce-signers";
+import { EventTemplate, NostrEvent, verifyEvent } from "nostr-tools";
+import { Subscription } from "rxjs";
 import { BunkerURI, NostrConnectAppMetadata } from "../helpers/nostr-connect.js";
-import { Subscribable, Unsubscribable } from "../helpers/observable.js";
-export type NostrConnectSignerOptions = {
+export type NostrConnectSignerOptions = NostrConnectionMethodsOptions & {
     /** The relays to communicate over */
     relays: string[];
     /** A {@link SimpleSigner} for this client */
@@ -16,33 +16,18 @@ export type NostrConnectSignerOptions = {
     secret?: string;
     /** A method for handling "auth" requests */
     onAuth?: (url: string) => Promise<void>;
-    /** A method for subscribing to relays */
-    subscriptionMethod?: NostrSubscriptionMethod;
-    /** A method for publishing events */
-    publishMethod?: NostrPublishMethod;
-    /** A pool of methods to use if none are passed in when creating the signer */
-    pool?: NostrPool;
-};
-/** A method used to subscribe to events on a set of relays */
-export type NostrSubscriptionMethod = (relays: string[], filters: Filter[]) => Subscribable<NostrEvent | string>;
-/** A method used for publishing an event, can return a Promise that completes when published or an Observable that completes when published*/
-export type NostrPublishMethod = (relays: string[], event: NostrEvent) => Promise<any> | Subscribable<any>;
-/** A simple pool type that combines the subscription and publish methods */
-export type NostrPool = {
-    subscription: NostrSubscriptionMethod;
-    publish: NostrPublishMethod;
 };
 export declare class NostrConnectSigner implements ISigner {
-    /** A method that is called when an event needs to be published */
-    protected publishMethod: NostrPublishMethod;
-    /** The active nostr subscription */
-    protected subscriptionMethod: NostrSubscriptionMethod;
     /** A fallback method to use for subscriptionMethod if none is pass in when creating the signer */
     static subscriptionMethod: NostrSubscriptionMethod | undefined;
     /** A fallback method to use for publishMethod if none is pass in when creating the signer */
     static publishMethod: NostrPublishMethod | undefined;
     /** A fallback pool to use if none is pass in when creating the signer */
     static pool: NostrPool | undefined;
+    /** A method that is called when an event needs to be published */
+    protected publishMethod: NostrPublishMethod;
+    /** The active nostr subscription */
+    protected subscriptionMethod: NostrSubscriptionMethod;
     protected log: import("debug").Debugger;
     /** The local client signer */
     signer: SimpleSigner;
@@ -71,9 +56,9 @@ export declare class NostrConnectSigner implements ISigner {
         encrypt: (pubkey: string, plaintext: string) => Promise<string>;
         decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
     } | undefined;
-    constructor(opts: NostrConnectSignerOptions);
+    constructor(options: NostrConnectSignerOptions);
     /** The currently active REQ subscription */
-    protected req?: Unsubscribable;
+    protected req?: Subscription;
     /** Open the connection */
     open(): Promise<void>;
     /** Close the connection */

package/dist/signers/nostr-connect-signer.js

@@ -1,25 +1,26 @@
 import { logger } from "applesauce-core";
 import { getHiddenContent, unixNow } from "applesauce-core/helpers";
 import { createDefer } from "applesauce-core/promise";
-import { SimpleSigner } from "applesauce-signers";
+import { SimpleSigner, getConnectionMethods, } from "applesauce-signers";
 import { nanoid } from "nanoid";
 import { getPublicKey, kinds, verifyEvent } from "nostr-tools";
+import { filter, from, repeat, retry } from "rxjs";
 import { isNIP04 } from "../helpers/encryption.js";
 import { NostrConnectMethod, buildSigningPermissions, createNostrConnectURI, parseBunkerURI, } from "../helpers/nostr-connect.js";
 async function defaultHandleAuth(url) {
     window.open(url, "auth", "width=400,height=600,resizable=no,status=no,location=no,toolbar=no,menubar=no");
 }
 export class NostrConnectSigner {
-    /** A method that is called when an event needs to be published */
-    publishMethod;
-    /** The active nostr subscription */
-    subscriptionMethod;
     /** A fallback method to use for subscriptionMethod if none is pass in when creating the signer */
     static subscriptionMethod = undefined;
     /** A fallback method to use for publishMethod if none is pass in when creating the signer */
     static publishMethod = undefined;
     /** A fallback pool to use if none is pass in when creating the signer */
     static pool = undefined;
+    /** A method that is called when an event needs to be published */
+    publishMethod;
+    /** The active nostr subscription */
+    subscriptionMethod;
     log = logger.extend("NostrConnectSigner");
     /** The local client signer */
     signer;
@@ -44,27 +45,20 @@ export class NostrConnectSigner {
     secret;
     nip04;
     nip44;
-    constructor(opts) {
-        this.relays = opts.relays;
-        this.pubkey = opts.pubkey;
-        this.remote = opts.remote;
-        this.secret = opts.secret || nanoid(12);
+    constructor(options) {
+        this.relays = options.relays;
+        this.pubkey = options.pubkey;
+        this.remote = options.remote;
+        this.secret = options.secret || nanoid(12);
         // Get the subscription and publish methods
-        const subscriptionMethod = opts.subscriptionMethod ||
-            opts.pool?.subscription ||
-            NostrConnectSigner.subscriptionMethod ||
-            NostrConnectSigner.pool?.subscription;
-        if (!subscriptionMethod)
-            throw new Error("Missing subscriptionMethod, either pass a method or set NostrConnectSigner.subscriptionMethod");
-        const publishMethod = opts.publishMethod || opts.pool?.publish || NostrConnectSigner.publishMethod || NostrConnectSigner.pool?.publish;
-        if (!publishMethod)
-            throw new Error("Missing publishMethod, either pass a method or set NostrConnectSigner.publishMethod");
+        const { subscriptionMethod, publishMethod } = getConnectionMethods(options, NostrConnectSigner);
         // Use arrow functions so "this" isn't bound to the signer
         this.subscriptionMethod = (relays, filters) => subscriptionMethod(relays, filters);
         this.publishMethod = (relays, event) => publishMethod(relays, event);
-        if (opts.onAuth)
-            this.onAuth = opts.onAuth;
-        this.signer = opts?.signer || new SimpleSigner();
+        if (options.onAuth)
+            this.onAuth = options.onAuth;
+        // Get or create the local signer
+        this.signer = options?.signer || new SimpleSigner();
         this.nip04 = {
             encrypt: this.nip04Encrypt.bind(this),
             decrypt: this.nip04Decrypt.bind(this),
@@ -83,14 +77,20 @@ export class NostrConnectSigner {
         this.listening = true;
         const pubkey = await this.signer.getPublicKey();
         // Setup subscription
-        this.req = this.subscriptionMethod(this.relays, [
+        this.req = from(this.subscriptionMethod(this.relays, [
             {
                 kinds: [kinds.NostrConnect],
                 "#p": [pubkey],
             },
-        ]).subscribe({
-            next: (event) => typeof event !== "string" && this.handleEvent(event),
-        });
+        ]))
+            .pipe(
+        // Keep the connection open indefinitely
+        repeat(), 
+        // Retry on connection failure
+        retry(), 
+        // Ignore strings (support for applesauce-relay)
+        filter((event) => typeof event !== "string"))
+            .subscribe(this.handleEvent.bind(this));
         this.log("Opened", this.relays);
     }
     /** Close the connection */

package/dist/signers/password-signer.d.ts

@@ -1,6 +1,6 @@
 import { EventTemplate } from "nostr-tools";
 import { Deferred } from "applesauce-core/promise";
-import { ISigner } from "../interface.js";
+import { ISigner } from "../interop.js";
 /** A NIP-49 (Private Key Encryption) signer */
 export declare class PasswordSigner implements ISigner {
     key: Uint8Array | null;

package/dist/signers/readonly-signer.d.ts

@@ -1,5 +1,5 @@
 import { VerifiedEvent } from "nostr-tools";
-import { ISigner } from "../interface.js";
+import { ISigner } from "../interop.js";
 /** A signer that only implements getPublicKey and throws on ever other method */
 export declare class ReadonlySigner implements ISigner {
     private pubkey;

package/dist/signers/serial-port-signer.d.ts

@@ -1,6 +1,6 @@
 import { Deferred } from "applesauce-core/promise";
 import { EventTemplate, verifyEvent } from "nostr-tools";
-import { ISigner } from "../interface.js";
+import { ISigner } from "../interop.js";
 type Callback = () => void;
 type DeviceOpts = {
     onConnect?: Callback;

package/dist/signers/simple-signer.d.ts

@@ -1,5 +1,5 @@
 import { EventTemplate } from "nostr-tools";
-import { ISigner } from "../interface.js";
+import { ISigner } from "../interop.js";
 /** A Simple NIP-07 signer class */
 export declare class SimpleSigner implements ISigner {
     key: Uint8Array;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-signers",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Signer classes for applesauce",
   "type": "module",
   "main": "dist/index.js",
@@ -38,10 +38,11 @@
     "@noble/hashes": "^1.7.1",
     "@noble/secp256k1": "^1.7.1",
     "@scure/base": "^1.2.4",
-    "applesauce-core": "^3.0.0",
+    "applesauce-core": "^3.1.0",
     "debug": "^4.4.0",
     "nanoid": "^5.0.9",
-    "nostr-tools": "^2.13"
+    "nostr-tools": "~2.15",
+    "rxjs": "^7.8.2"
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",

package/dist/helpers/observable.d.ts

@@ -1,11 +0,0 @@
-export interface Unsubscribable {
-    unsubscribe(): void;
-}
-export interface Observer<T> {
-    next: (value: T) => void;
-    error: (err: any) => void;
-    complete: () => void;
-}
-export type Subscribable<T extends unknown> = {
-    subscribe: (observer: Partial<Observer<T>>) => Unsubscribable;
-};

package/dist/helpers/observable.js

@@ -1,2 +0,0 @@
-// Simple types copied from rxjs
-export {};

package/dist/interface.d.ts

@@ -1,15 +0,0 @@
-import { EventTemplate, NostrEvent } from "nostr-tools";
-export type ISigner = {
-    getPublicKey: () => Promise<string>;
-    signEvent: (template: EventTemplate) => Promise<NostrEvent>;
-    nip04?: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
-    };
-    nip44?: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
-    };
-};
-/** @deprecated Use ISigner instead */
-export type Nip07Interface = ISigner;

package/dist/interface.js

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