@libp2p/interface-internal 0.0.1-05abd49f

package/dist/src/index.d.ts

@@ -0,0 +1,548 @@
+/**
+ * @packageDocumentation
+ *
+ * Exports a `Libp2p` type for modules to use as a type argument.
+ *
+ * @example
+ *
+ * ```typescript
+ * import type { Libp2p } from '@libp2p/interface'
+ *
+ * function doSomethingWithLibp2p (node: Libp2p) {
+ *   // ...
+ * }
+ * ```
+ */
+import type { StreamHandler, StreamHandlerOptions } from './registrar/index.js';
+import type { AbortOptions } from '@libp2p/interface';
+import type { Connection, Stream } from '@libp2p/interface/connection';
+import type { ContentRouting } from '@libp2p/interface/content-routing';
+import type { EventEmitter } from '@libp2p/interface/events';
+import type { KeyChain } from '@libp2p/interface/keychain';
+import type { Metrics } from '@libp2p/interface/metrics';
+import type { PeerId } from '@libp2p/interface/peer-id';
+import type { PeerInfo } from '@libp2p/interface/peer-info';
+import type { PeerRouting } from '@libp2p/interface/peer-routing';
+import type { Address, Peer, PeerStore } from '@libp2p/interface/peer-store';
+import type { Startable } from '@libp2p/interface/startable';
+import type { Topology } from '@libp2p/interface/topology';
+import type { Listener } from '@libp2p/interface/transport';
+import type { Multiaddr } from '@multiformats/multiaddr';
+/**
+ * Used by the connection manager to sort addresses into order before dialling
+ */
+export interface AddressSorter {
+    (a: Address, b: Address): -1 | 0 | 1;
+}
+/**
+ * Event detail emitted when peer data changes
+ */
+export interface PeerUpdate {
+    peer: Peer;
+    previous?: Peer;
+}
+/**
+ * Peer data signed by the remote Peer's public key
+ */
+export interface SignedPeerRecord {
+    addresses: Multiaddr[];
+    seq: bigint;
+}
+/**
+ * Data returned from a successful identify response
+ */
+export interface IdentifyResult {
+    /**
+     * The remote Peer's PeerId
+     */
+    peerId: PeerId;
+    /**
+     * The unsigned addresses they are listening on. Note - any multiaddrs present
+     * in the signed peer record should be preferred to the value here.
+     */
+    listenAddrs: Multiaddr[];
+    /**
+     * The protocols the remote peer supports
+     */
+    protocols: string[];
+    /**
+     * The remote protocol version
+     */
+    protocolVersion?: string;
+    /**
+     * The remote agent version
+     */
+    agentVersion?: string;
+    /**
+     * The public key part of the remote PeerId - this is only useful for older
+     * RSA-based PeerIds, the more modern Ed25519 and secp256k1 types have the
+     * public key embedded in them
+     */
+    publicKey?: Uint8Array;
+    /**
+     * If set this is the address that the remote peer saw the identify request
+     * originate from
+     */
+    observedAddr?: Multiaddr;
+    /**
+     * If sent by the remote peer this is the deserialized signed peer record
+     */
+    signedPeerRecord?: SignedPeerRecord;
+}
+/**
+ * Once you have a libp2p instance, you can listen to several events it emits,
+ * so that you can be notified of relevant network events.
+ *
+ * Event names are `noun:verb` so the first part is the name of the object
+ * being acted on and the second is the action.
+ */
+export interface Libp2pEvents<T extends ServiceMap = ServiceMap> {
+    /**
+     * This event is dispatched when a new network peer is discovered.
+     *
+     * @example
+     *
+     * ```js
+     * libp2p.addEventListener('peer:discovery', (event) => {
+     *    const peerInfo = event.detail
+     *    // ...
+     * })
+     * ```
+     */
+    'peer:discovery': CustomEvent<PeerInfo>;
+    /**
+     * This event will be triggered any time a new peer connects.
+     *
+     * @example
+     *
+     * ```js
+     * libp2p.addEventListener('peer:connect', (event) => {
+     *   const peerId = event.detail
+     *   // ...
+     * })
+     * ```
+     */
+    'peer:connect': CustomEvent<PeerId>;
+    /**
+     * This event will be triggered any time we are disconnected from another peer, regardless of
+     * the circumstances of that disconnection. If we happen to have multiple connections to a
+     * peer, this event will **only** be triggered when the last connection is closed.
+     *
+     * @example
+     *
+     * ```js
+     * libp2p.addEventListener('peer:disconnect', (event) => {
+     *   const peerId = event.detail
+     *   // ...
+     * })
+     * ```
+     */
+    'peer:disconnect': CustomEvent<PeerId>;
+    /**
+     * This event is dispatched after a remote peer has successfully responded to the identify
+     * protocol. Note that for this to be emitted, both peers must have an identify service
+     * configured.
+     *
+     * @example
+     *
+     * ```js
+     * libp2p.addEventListener('peer:identify', (event) => {
+     *   const identifyResult = event.detail
+     *   // ...
+     * })
+     * ```
+     */
+    'peer:identify': CustomEvent<IdentifyResult>;
+    /**
+     * This event is dispatched when the peer store data for a peer has been
+     * updated - e.g. their multiaddrs, protocols etc have changed.
+     *
+     * If they were previously known to this node, the old peer data will be
+     * set in the `previous` field.
+     *
+     * This may be in response to the identify protocol running, a manual
+     * update or some other event.
+     */
+    'peer:update': CustomEvent<PeerUpdate>;
+    /**
+     * This event is dispatched when the current node's peer record changes -
+     * for example a transport started listening on a new address or a new
+     * protocol handler was registered.
+     *
+     * @example
+     *
+     * ```js
+     * libp2p.addEventListener('self:peer:update', (event) => {
+     *   const { peer } = event.detail
+     *   // ...
+     * })
+     * ```
+     */
+    'self:peer:update': CustomEvent<PeerUpdate>;
+    /**
+     * This event is dispatched when a transport begins listening on a new address
+     */
+    'transport:listening': CustomEvent<Listener>;
+    /**
+     * This event is dispatched when a transport stops listening on an address
+     */
+    'transport:close': CustomEvent<Listener>;
+    /**
+     * This event is dispatched when the connection manager has more than the
+     * configured allowable max connections and has closed some connections to
+     * bring the node back under the limit.
+     */
+    'connection:prune': CustomEvent<Connection[]>;
+    /**
+     * This event notifies listeners when new incoming or outgoing connections
+     * are opened.
+     */
+    'connection:open': CustomEvent<Connection>;
+    /**
+     * This event notifies listeners when incoming or outgoing connections are
+     * closed.
+     */
+    'connection:close': CustomEvent<Connection>;
+    /**
+     * This event notifies listeners that the node has started
+     *
+     * ```js
+     * libp2p.addEventListener('start', (event) => {
+     *   console.info(libp2p.isStarted()) // true
+     * })
+     * ```
+     */
+    'start': CustomEvent<Libp2p<T>>;
+    /**
+     * This event notifies listeners that the node has stopped
+     *
+     * ```js
+     * libp2p.addEventListener('stop', (event) => {
+     *   console.info(libp2p.isStarted()) // false
+     * })
+     * ```
+     */
+    'stop': CustomEvent<Libp2p<T>>;
+}
+/**
+ * A map of user defined services available on the libp2p node via the
+ * `services` key
+ *
+ * @example
+ *
+ * ```js
+ * const node = await createLibp2p({
+ *   // ...other options
+ *   services: {
+ *     myService: myService({
+ *       // ...service options
+ *     })
+ *   }
+ * })
+ *
+ * // invoke methods on the service
+ * node.services.myService.anOperation()
+ * ```
+ */
+export type ServiceMap = Record<string, unknown>;
+export type PendingDialStatus = 'queued' | 'active' | 'error' | 'success';
+/**
+ * An item in the dial queue
+ */
+export interface PendingDial {
+    /**
+     * A unique identifier for this dial
+     */
+    id: string;
+    /**
+     * The current status of the dial
+     */
+    status: PendingDialStatus;
+    /**
+     * If known, this is the peer id that libp2p expects to be dialling
+     */
+    peerId?: PeerId;
+    /**
+     * The list of multiaddrs that will be dialled. The returned connection will
+     * use the first address that succeeds, all other dials part of this pending
+     * dial will be cancelled.
+     */
+    multiaddrs: Multiaddr[];
+}
+/**
+ * Libp2p nodes implement this interface.
+ */
+export interface Libp2p<T extends ServiceMap = ServiceMap> extends Startable, EventEmitter<Libp2pEvents<T>> {
+    /**
+     * The PeerId is a unique identifier for a node on the network.
+     *
+     * It is the hash of an RSA public key or, for Ed25519 or secp256k1 keys,
+     * the key itself.
+     *
+     * @example
+     *
+     * ```js
+     * console.info(libp2p.peerId)
+     * // PeerId(12D3Foo...)
+     * ````
+     */
+    peerId: PeerId;
+    /**
+     * The peer store holds information we know about other peers on the network.
+     * - multiaddrs, supported protocols, etc.
+     *
+     * @example
+     *
+     * ```js
+     * const peer = await libp2p.peerStore.get(peerId)
+     * console.info(peer)
+     * // { id: PeerId(12D3Foo...), addresses: [] ... }
+     * ```
+     */
+    peerStore: PeerStore;
+    /**
+     * The peer routing subsystem allows the user to find peers on the network
+     * or to find peers close to binary keys.
+     *
+     * @example
+     *
+     * ```js
+     * const peerInfo = await libp2p.peerRouting.findPeer(peerId)
+     * console.info(peerInfo)
+     * // { id: PeerId(12D3Foo...), multiaddrs: [] ... }
+     * ```
+     *
+     * @example
+     *
+     * ```js
+     * for await (const peerInfo of libp2p.peerRouting.getClosestPeers(key)) {
+     *   console.info(peerInfo)
+     *   // { id: PeerId(12D3Foo...), multiaddrs: [] ... }
+     * }
+     * ```
+     */
+    peerRouting: PeerRouting;
+    /**
+     * The content routing subsystem allows the user to find providers for content,
+     * let the network know they are providers for content, and get/put values to
+     * the DHT.
+     *
+     * @example
+     *
+     * ```js
+     * for await (const peerInfo of libp2p.contentRouting.findProviders(cid)) {
+     *   console.info(peerInfo)
+     *   // { id: PeerId(12D3Foo...), multiaddrs: [] ... }
+     * }
+     * ```
+     */
+    contentRouting: ContentRouting;
+    /**
+     * The keychain contains the keys used by the current node, and can create new
+     * keys, export them, import them, etc.
+     *
+     * @example
+     *
+     * ```js
+     * const keyInfo = await libp2p.keychain.createKey('new key')
+     * console.info(keyInfo)
+     * // { id: '...', name: 'new key' }
+     * ```
+     */
+    keychain: KeyChain;
+    /**
+     * The metrics subsystem allows recording values to assess the health/performance
+     * of the running node.
+     *
+     * @example
+     *
+     * ```js
+     * const metric = libp2p.metrics.registerMetric({
+     *   'my-metric'
+     * })
+     *
+     * // later
+     * metric.update(5)
+     * ```
+     */
+    metrics?: Metrics;
+    /**
+     * Get a deduplicated list of peer advertising multiaddrs by concatenating
+     * the listen addresses used by transports with any configured
+     * announce addresses as well as observed addresses reported by peers.
+     *
+     * If Announce addrs are specified, configured listen addresses will be
+     * ignored though observed addresses will still be included.
+     *
+     * @example
+     *
+     * ```js
+     * const listenMa = libp2p.getMultiaddrs()
+     * // [ <Multiaddr 047f00000106f9ba - /ip4/127.0.0.1/tcp/63930> ]
+     * ```
+     */
+    getMultiaddrs: () => Multiaddr[];
+    /**
+     * Returns a list of supported protocols
+     *
+     * @example
+     *
+     * ```js
+     * const protocols = libp2p.getProtocols()
+     * // [ '/ipfs/ping/1.0.0', '/ipfs/id/1.0.0' ]
+     * ```
+     */
+    getProtocols: () => string[];
+    /**
+     * Return a list of all connections this node has open, optionally filtering
+     * by a PeerId
+     *
+     * @example
+     *
+     * ```js
+     * for (const connection of libp2p.getConnections()) {
+     *   console.log(peerId, connection.remoteAddr.toString())
+     *   // Logs the PeerId string and the observed remote multiaddr of each Connection
+     * }
+     * ```
+     */
+    getConnections: (peerId?: PeerId) => Connection[];
+    /**
+     * Return the list of dials currently in progress or queued to start
+     *
+     * @example
+     *
+     * ```js
+     * for (const pendingDial of libp2p.getDialQueue()) {
+     *   console.log(pendingDial)
+     * }
+     * ```
+     */
+    getDialQueue: () => PendingDial[];
+    /**
+     * Return a list of all peers we currently have a connection open to
+     */
+    getPeers: () => PeerId[];
+    /**
+     * Dials to the provided peer. If successful, the known metadata of the
+     * peer will be added to the nodes `peerStore`.
+     *
+     * If a PeerId is passed as the first argument, the peer will need to have known multiaddrs for it in the PeerStore.
+     *
+     * @example
+     *
+     * ```js
+     * const conn = await libp2p.dial(remotePeerId)
+     *
+     * // create a new stream within the connection
+     * const { stream, protocol } = await conn.newStream(['/echo/1.1.0', '/echo/1.0.0'])
+     *
+     * // protocol negotiated: 'echo/1.0.0' means that the other party only supports the older version
+     *
+     * // ...
+     * await conn.close()
+     * ```
+     */
+    dial: (peer: PeerId | Multiaddr | Multiaddr[], options?: AbortOptions) => Promise<Connection>;
+    /**
+     * Dials to the provided peer and tries to handshake with the given protocols in order.
+     * If successful, the known metadata of the peer will be added to the nodes `peerStore`,
+     * and the `MuxedStream` will be returned together with the successful negotiated protocol.
+     *
+     * @example
+     *
+     * ```js
+     * import { pipe } from 'it-pipe'
+     *
+     * const { stream, protocol } = await libp2p.dialProtocol(remotePeerId, protocols)
+     *
+     * // Use this new stream like any other duplex stream
+     * pipe([1, 2, 3], stream, consume)
+     * ```
+     */
+    dialProtocol: (peer: PeerId | Multiaddr | Multiaddr[], protocols: string | string[], options?: AbortOptions) => Promise<Stream>;
+    /**
+     * Attempts to gracefully close an open connection to the given peer. If the connection is not closed in the grace period, it will be forcefully closed.
+     *
+     * @example
+     *
+     * ```js
+     * await libp2p.hangUp(remotePeerId)
+     * ```
+     */
+    hangUp: (peer: PeerId | Multiaddr) => Promise<void>;
+    /**
+     * Sets up [multistream-select routing](https://github.com/multiformats/multistream-select) of protocols to their application handlers. Whenever a stream is opened on one of the provided protocols, the handler will be called. `handle` must be called in order to register a handler and support for a given protocol. This also informs other peers of the protocols you support.
+     *
+     * `libp2p.handle(protocols, handler, options)`
+     *
+     * In the event of a new handler for the same protocol being added, the first one is discarded.
+     *
+     * @example
+     *
+     * ```js
+     * const handler = ({ connection, stream, protocol }) => {
+     *   // use stream or connection according to the needs
+     * }
+     *
+     * libp2p.handle('/echo/1.0.0', handler, {
+     *   maxInboundStreams: 5,
+     *   maxOutboundStreams: 5
+     * })
+     * ```
+     */
+    handle: (protocol: string | string[], handler: StreamHandler, options?: StreamHandlerOptions) => Promise<void>;
+    /**
+     * Removes the handler for each protocol. The protocol
+     * will no longer be supported on streams.
+     *
+     * @example
+     *
+     * ```js
+     * libp2p.unhandle(['/echo/1.0.0'])
+     * ```
+     */
+    unhandle: (protocols: string[] | string) => Promise<void>;
+    /**
+     * Register a topology to be informed when peers are encountered that
+     * support the specified protocol
+     *
+     * @example
+     *
+     * ```js
+     * const id = await libp2p.register('/echo/1.0.0', {
+     *   onConnect: (peer, connection) => {
+     *     // handle connect
+     *   },
+     *   onDisconnect: (peer, connection) => {
+     *     // handle disconnect
+     *   }
+     * })
+     * ```
+     */
+    register: (protocol: string, topology: Topology) => Promise<string>;
+    /**
+     * Unregister topology to no longer be informed when peers connect or
+     * disconnect.
+     *
+     * @example
+     *
+     * ```js
+     * const id = await libp2p.register(...)
+     *
+     * libp2p.unregister(id)
+     * ```
+     */
+    unregister: (id: string) => void;
+    /**
+     * Returns the public key for the passed PeerId. If the PeerId is of the 'RSA' type
+     * this may mean searching the DHT if the key is not present in the KeyStore.
+     * A set of user defined services
+     */
+    getPublicKey: (peer: PeerId, options?: AbortOptions) => Promise<Uint8Array>;
+    /**
+     * A set of user defined services
+     */
+    services: T;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/dist/src/index.js

@@ -0,0 +1,17 @@
+/**
+ * @packageDocumentation
+ *
+ * Exports a `Libp2p` type for modules to use as a type argument.
+ *
+ * @example
+ *
+ * ```typescript
+ * import type { Libp2p } from '@libp2p/interface'
+ *
+ * function doSomethingWithLibp2p (node: Libp2p) {
+ *   // ...
+ * }
+ * ```
+ */
+export {};
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG"}

package/dist/src/record/index.d.ts

@@ -0,0 +1,33 @@
+import type { PeerId } from '@libp2p/interface/peer-id';
+import type { Uint8ArrayList } from 'uint8arraylist';
+/**
+ * Record is the base implementation of a record that can be used as the payload of a libp2p envelope.
+ */
+export interface Record {
+    /**
+     * signature domain.
+     */
+    domain: string;
+    /**
+     * identifier of the type of record
+     */
+    codec: Uint8Array;
+    /**
+     * Marshal a record to be used in an envelope.
+     */
+    marshal: () => Uint8Array;
+    /**
+     * Verifies if the other provided Record is identical to this one.
+     */
+    equals: (other: Record) => boolean;
+}
+export interface Envelope {
+    peerId: PeerId;
+    payloadType: Uint8Array | Uint8ArrayList;
+    payload: Uint8Array;
+    signature: Uint8Array | Uint8ArrayList;
+    marshal: () => Uint8Array;
+    validate: (domain: string) => Promise<boolean>;
+    equals: (other: Envelope) => boolean;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/src/record/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/record/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAA;IACd;;OAEG;IACH,KAAK,EAAE,UAAU,CAAA;IACjB;;OAEG;IACH,OAAO,EAAE,MAAM,UAAU,CAAA;IACzB;;OAEG;IACH,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAA;CACnC;AAED,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,UAAU,GAAG,cAAc,CAAA;IACxC,OAAO,EAAE,UAAU,CAAA;IACnB,SAAS,EAAE,UAAU,GAAG,cAAc,CAAA;IAEtC,OAAO,EAAE,MAAM,UAAU,CAAA;IACzB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC9C,MAAM,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,OAAO,CAAA;CACrC"}

package/dist/src/record/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/src/record/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/record/index.ts"],"names":[],"mappings":""}

package/dist/src/registrar/index.d.ts

@@ -0,0 +1,60 @@
+import type { Connection, Stream } from '@libp2p/interface/connection';
+import type { Topology } from '@libp2p/interface/topology';
+export interface IncomingStreamData {
+    stream: Stream;
+    connection: Connection;
+}
+export interface StreamHandler {
+    (data: IncomingStreamData): void;
+}
+export interface StreamHandlerOptions {
+    /**
+     * How many incoming streams can be open for this protocol at the same time on each connection (default: 32)
+     */
+    maxInboundStreams?: number;
+    /**
+     * How many outgoing streams can be open for this protocol at the same time on each connection (default: 64)
+     */
+    maxOutboundStreams?: number;
+}
+export interface StreamHandlerRecord {
+    handler: StreamHandler;
+    options: StreamHandlerOptions;
+}
+export interface Registrar {
+    /**
+     * Return the list of protocols with registered handlers
+     */
+    getProtocols: () => string[];
+    /**
+     * Add a protocol handler
+     */
+    handle: (protocol: string, handler: StreamHandler, options?: StreamHandlerOptions) => Promise<void>;
+    /**
+     * Remove a protocol handler
+     */
+    unhandle: (protocol: string) => Promise<void>;
+    /**
+     * Return the handler for the passed protocol
+     */
+    getHandler: (protocol: string) => StreamHandlerRecord;
+    /**
+     * Register a topology handler for a protocol - the topology will be
+     * invoked when peers are discovered on the network that support the
+     * passed protocol.
+     *
+     * An id will be returned that can later be used to unregister the
+     * topology.
+     */
+    register: (protocol: string, topology: Topology) => Promise<string>;
+    /**
+     * Remove the topology handler with the passed id.
+     */
+    unregister: (id: string) => void;
+    /**
+     * Return all topology handlers that wish to be informed about peers
+     * that support the passed protocol.
+     */
+    getTopologies: (protocol: string) => Topology[];
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/src/registrar/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/registrar/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAA;AACtE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAA;AAE1D,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,UAAU,CAAA;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,CAAC,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAAA;CACjC;AAED,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAE1B;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,aAAa,CAAA;IACtB,OAAO,EAAE,oBAAoB,CAAA;CAC9B;AAED,MAAM,WAAW,SAAS;IACxB;;OAEG;IACH,YAAY,EAAE,MAAM,MAAM,EAAE,CAAA;IAE5B;;OAEG;IACH,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAEnG;;OAEG;IACH,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAE7C;;OAEG;IACH,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,mBAAmB,CAAA;IAErD;;;;;;;OAOG;IACH,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IAEnE;;OAEG;IACH,UAAU,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IAEhC;;;OAGG;IACH,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,QAAQ,EAAE,CAAA;CAChD"}

package/dist/src/registrar/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/src/registrar/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/registrar/index.ts"],"names":[],"mappings":""}