@enbox/dids 0.0.1

package/dist/types/methods/did-method.d.ts

@@ -0,0 +1,238 @@
+import type { CryptoApi, LocalKeyManager, InferKeyGeneratorAlgorithm } from '@enbox/crypto';
+import type { BearerDid } from '../bearer-did.js';
+import type { DidMetadata } from '../types/portable-did.js';
+import type { DidDocument, DidResolutionResult, DidResolutionOptions, DidVerificationMethod } from '../types/did-core.js';
+import { DidVerificationRelationship } from '../types/did-core.js';
+/**
+ * Represents options during the creation of a Decentralized Identifier (DID).
+ *
+ * Implementations of this interface may contain properties and methods that provide specific
+ * options or metadata during the DID creation processes following specific DID method
+ * specifications.
+ */
+export interface DidCreateOptions<TKms> {
+    /**
+     * Optional. An array of verification methods to be included in the DID document.
+     */
+    verificationMethods?: DidCreateVerificationMethod<TKms>[];
+}
+/**
+ * Options for additional verification methods added to the DID Document during the creation of a
+ * new Decentralized Identifier (DID).
+ */
+export interface DidCreateVerificationMethod<TKms> extends Pick<Partial<DidVerificationMethod>, 'controller' | 'id' | 'type'> {
+    /**
+     * The name of the cryptographic algorithm to be used for key generation.
+     *
+     * Examples might include `Ed25519` and `ES256K` but will vary depending on the DID method
+     * specification and the key management system in use.
+     *
+     * @example
+     * ```ts
+     * const verificationMethod: DidCreateVerificationMethod = {
+     *   algorithm: 'Ed25519'
+     * };
+     * ```
+     */
+    algorithm: TKms extends CryptoApi ? InferKeyGeneratorAlgorithm<TKms> : InferKeyGeneratorAlgorithm<LocalKeyManager>;
+    /**
+     * Optionally specify the purposes for which a verification method is intended to be used in a DID
+     * document.
+     *
+     * The `purposes` property defines the specific
+     * {@link DidVerificationRelationship | verification relationships} between the DID subject and
+     * the verification method. This enables the verification method to be utilized for distinct
+     * actions such as authentication, assertion, key agreement, capability delegation, and others. It
+     * is important for verifiers to recognize that a verification method must be associated with the
+     * relevant purpose in the DID document to be valid for that specific use case.
+     *
+     * @example
+     * ```ts
+     * const verificationMethod: DidCreateVerificationMethod = {
+     *   algorithm: 'Ed25519',
+     *   controller: 'did:example:1234',
+     *   purposes: ['authentication', 'assertionMethod']
+     * };
+     * ```
+     */
+    purposes?: (DidVerificationRelationship | keyof typeof DidVerificationRelationship)[];
+}
+/**
+ * Defines the API for a specific DID method. It includes functionalities for creating and resolving
+ * DIDs.
+ *
+ * @typeparam T - The type of the DID instance associated with this method.
+ * @typeparam O - The type of the options used for creating the DID.
+ */
+export interface DidMethodApi<TKms extends CryptoApi | undefined = CryptoApi, TDid extends BearerDid = BearerDid, TOptions extends DidCreateOptions<TKms> = DidCreateOptions<TKms>> extends DidMethodResolver {
+    /**
+     * The name of the DID method.
+     *
+     * For example, in the DID `did:example:123456`, "example" would be the method name.
+     */
+    methodName: string;
+    new (): DidMethod;
+    /**
+     * Creates a new DID.
+     *
+     * This function should generate a new DID in accordance with the DID method specification being
+     * implemented, using the provided `keyManager`, and optionally, any provided `options`.
+     *
+     * @param params - The parameters used to create the DID.
+     * @param params.keyManager - Optional. The cryptographic API used for key management.
+     * @param params.options - Optional. The options used for creating the DID.
+     * @returns A promise that resolves to the newly created DID instance.
+     */
+    create(params: {
+        keyManager?: TKms;
+        options?: TOptions;
+    }): Promise<TDid>;
+    /**
+     * Given a DID Document, return the verification method that will be used for signing messages and
+     * credentials.
+     *
+     * If given, the `methodId` parameter is used to select the verification method. If not given, a
+     * DID method specific approach is taken to selecting the verification method to return.
+     *
+     * @param params - The parameters for the `getSigningMethod` operation.
+     * @param params.didDocument - DID Document to get the verification method from.
+     * @param params.methodId - ID of the verification method to use for signing.
+     * @returns A promise that resolves to the erification method to use for signing.
+     */
+    getSigningMethod(params: {
+        didDocument: DidDocument;
+        methodId?: string;
+    }): Promise<DidVerificationMethod>;
+}
+/**
+ * Defines the interface for resolving a DID using a specific DID method.
+ *
+ * A DID resolver takes a DID URI as input and returns a {@link DidResolutionResult} object.
+ *
+ * @property {string} methodName - The name of the DID method.
+ * @method resolve - Asynchronous method to resolve a DID URI. Takes the DID URI and optional resolution options.
+ */
+export interface DidMethodResolver {
+    /**
+     * The name of the DID method.
+     *
+     * For example, in the DID `did:example:123456`, "example" would be the method name.
+     */
+    methodName: string;
+    new (): DidMethod;
+    /**
+     * Resolves a DID URI.
+     *
+     * This function should resolve the DID URI in accordance with the DID method specification being
+     * implemented, using the provided `options`.
+     *
+     * @param didUri - The DID URI to be resolved.
+     * @param options - Optional. The options used for resolving the DID.
+     * @returns A {@link DidResolutionResult} object containing the DID document and metadata or an error.
+     */
+    resolve(didUri: string, options?: DidResolutionOptions): Promise<DidResolutionResult>;
+}
+/**
+ * Represents the result of a Decentralized Identifier (DID) registration operation.
+ *
+ * This type encapsulates the complete outcome of registering a DID, including the registration
+ * metadata, the DID document (if registration is successful), and metadata about the DID document.
+ */
+export interface DidRegistrationResult {
+    /**
+     * The DID document resulting from the registration process, if successful.
+     *
+     * If the registration operation was successful, this MUST contain a DID document
+     * corresponding to the DID. If the registration is unsuccessful, this value MUST be empty.
+     *
+     * @see {@link https://www.w3.org/TR/did-core/#dfn-diddocument | DID Core Specification, § DID Document}
+     */
+    didDocument: DidDocument | null;
+    /**
+     * Metadata about the DID Document.
+     *
+     * This structure contains information about the DID Document like creation and update timestamps,
+     * deactivation status, versioning information, and other details relevant to the DID Document.
+     *
+     * @see {@link https://www.w3.org/TR/did-core/#dfn-diddocumentmetadata | DID Core Specification, § DID Document Metadata}
+     */
+    didDocumentMetadata: DidMetadata;
+    /**
+     * A metadata structure consisting of values relating to the results of the DID registration
+     * process.
+     *
+     * This structure is REQUIRED, and in the case of an error in the registration process,
+     * this MUST NOT be empty. If the registration is not successful, this structure MUST contain an
+     * `error` property describing the error.
+     */
+    didRegistrationMetadata: DidRegistrationMetadata;
+}
+/**
+ * Represents metadata related to the result of a DID registration operation.
+ *
+ * This type includes fields that provide information about the outcome of a DID registration
+ * process (e.g., create, update, deactivate), including any errors that occurred.
+ *
+ * This metadata typically changes between invocations of the `create`, `update`, and `deactivate`
+ * functions, as it represents data about the registration process itself.
+ */
+export type DidRegistrationMetadata = {
+    /**
+     * An error code indicating issues encountered during the DID registration process.
+     *
+     * While the DID Core specification does not define a specific set of error codes for the result
+     * returned by the `create`, `update`, or `deactivate` functions, it is recommended to use the
+     * error codes defined in the DID Specification Registries for
+     * {@link https://www.w3.org/TR/did-spec-registries/#error | DID Resolution Metadata }.
+     *
+     * Recommended error codes include:
+     *   - `internalError`: An unexpected error occurred during DID registration process.
+     *   - `invalidDid`: The provided DID is invalid.
+     *   - `invalidDidDocument`: The provided DID document does not conform to valid syntax.
+     *   - `invalidDidDocumentLength`: The byte length of the provided DID document does not match the expected value.
+     *   - `invalidSignature`: Verification of a signature failed.
+     *   - `methodNotSupported`: The DID method specified is not supported.
+     *   - Custom error codes can also be provided as strings.
+     */
+    error?: string;
+    [key: string]: any;
+};
+/**
+ * Base abstraction for all Decentralized Identifier (DID) method implementations.
+ *
+ * This base class serves as a foundational structure upon which specific DID methods
+ * can be implemented. Subclasses should furnish particular method and data models adherent
+ * to various DID methods, taking care to adhere to the
+ * {@link https://www.w3.org/TR/did-core/ | W3C DID Core specification} and the
+ * respective DID method specifications.
+ */
+export declare class DidMethod {
+    /**
+     * MUST be implemented by all DID method implementations that extend {@link DidMethod}.
+     *
+     * Given the W3C DID Document of a DID, return the verification method that will be used for
+     * signing messages and credentials. If given, the `methodId` parameter is used to select the
+     * verification method. If not given, each DID method implementation will select a default
+     * verification method from the DID Document.
+     *
+     * @param _params - The parameters for the `getSigningMethod` operation.
+     * @param _params.didDocument - DID Document to get the verification method from.
+     * @param _params.methodId - ID of the verification method to use for signing.
+     * @returns Verification method to use for signing.
+     */
+    static getSigningMethod(_params: {
+        didDocument: DidDocument;
+        methodId?: string;
+    }): Promise<DidVerificationMethod | undefined>;
+    /**
+     * MUST be implemented by all DID method implementations that extend {@link DidMethod}.
+     *
+     * Resolves a DID URI to a DID Document.
+     *
+     * @param _didUri - The DID to be resolved.
+     * @param _options - Optional parameters for resolving the DID.
+     * @returns A Promise resolving to a {@link DidResolutionResult} object representing the result of the resolution.
+     */
+    static resolve(_didUri: string, _options?: DidResolutionOptions): Promise<DidResolutionResult>;
+}
+//# sourceMappingURL=did-method.d.ts.map

package/dist/types/methods/did-method.d.ts.map

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

package/dist/types/methods/did-web.d.ts

@@ -0,0 +1,37 @@
+import type { DidResolutionOptions, DidResolutionResult } from '../types/did-core.js';
+import { DidMethod } from './did-method.js';
+/**
+ * The `DidWeb` class provides an implementation of the `did:web` DID method.
+ *
+ * Features:
+ * - DID Resolution: Resolve a `did:web` to its corresponding DID Document.
+ *
+ * @remarks
+ * The `did:web` method uses a web domain's existing reputation and aims to integrate decentralized
+ * identities with the existing web infrastructure to drive adoption. It leverages familiar web
+ * security models and domain ownership to provide accessible, interoperable digital identity
+ * management.
+ *
+ * @see {@link https://w3c-ccg.github.io/did-method-web/ | DID Web Specification}
+ *
+ * @example
+ * ```ts
+ * // DID Resolution
+ * const resolutionResult = await DidWeb.resolve({ did: did.uri });
+ * ```
+ */
+export declare class DidWeb extends DidMethod {
+    /**
+     * Name of the DID method, as defined in the DID Web specification.
+     */
+    static methodName: string;
+    /**
+     * Resolves a `did:web` identifier to a DID Document.
+     *
+     * @param didUri - The DID to be resolved.
+     * @param _options - Optional parameters for resolving the DID. Unused by this DID method.
+     * @returns A Promise resolving to a {@link DidResolutionResult} object representing the result of the resolution.
+     */
+    static resolve(didUri: string, _options?: DidResolutionOptions): Promise<DidResolutionResult>;
+}
+//# sourceMappingURL=did-web.d.ts.map

package/dist/types/methods/did-web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"did-web.d.ts","sourceRoot":"","sources":["../../../src/methods/did-web.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAGnG,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG5C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,MAAO,SAAQ,SAAS;IAEnC;;OAEG;IACH,OAAc,UAAU,SAAS;IAEjC;;;;;;OAMG;WACiB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,CAAC;CAuD3G"}

package/dist/types/resolver/resolver-cache-level.d.ts

@@ -0,0 +1,86 @@
+import type { AbstractLevel } from 'abstract-level';
+import type { DidResolutionResult } from '../types/did-core.js';
+import type { DidResolverCache } from '../types/did-resolution.js';
+/**
+ * Configuration parameters for creating a LevelDB-based cache for DID resolution results.
+ *
+ * Allows customization of the underlying database instance, storage location, and cache
+ * time-to-live (TTL) settings.
+ */
+export type DidResolverCacheLevelParams = {
+    /**
+     * Optional. An instance of `AbstractLevel` to use as the database. If not provided, a new
+     * LevelDB instance will be created at the specified `location`.
+     */
+    db?: AbstractLevel<string | Buffer | Uint8Array, string, string>;
+    /**
+     * Optional. The file system path or IndexedDB name where the LevelDB store will be created.
+     * Defaults to 'DATA/DID_RESOLVERCACHE' if not specified.
+     */
+    location?: string;
+    /**
+     * Optional. The time-to-live for cache entries, expressed as a string (e.g., '1h', '15m').
+     * Determines how long a cache entry should remain valid before being considered expired. Defaults
+     * to '15m' if not specified.
+     */
+    ttl?: string;
+};
+/**
+ * A Level-based cache implementation for storing and retrieving DID resolution results.
+ *
+ * This cache uses LevelDB for storage, allowing data persistence across process restarts or
+ * browser refreshes. It's suitable for both Node.js and browser environments.
+ *
+ * @remarks
+ * The LevelDB cache keeps data in memory for fast access and also writes to the filesystem in
+ * Node.js or indexedDB in browsers. Time-to-live (TTL) for cache entries is configurable.
+ *
+ * @example
+ * ```
+ * const cache = new DidResolverCacheLevel({ ttl: '15m' });
+ * ```
+ */
+export declare class DidResolverCacheLevel implements DidResolverCache {
+    /** The underlying LevelDB store used for caching. */
+    protected cache: AbstractLevel<string | Uint8Array | Buffer, string, string>;
+    /** The time-to-live for cache entries in milliseconds. */
+    protected ttl: number;
+    constructor({ db, location, ttl }?: DidResolverCacheLevelParams);
+    /**
+     * Retrieves a DID resolution result from the cache.
+     *
+     * If the cached item has exceeded its TTL, it's scheduled for deletion and undefined is returned.
+     *
+     * @param did - The DID string used as the key for retrieving the cached result.
+     * @returns The cached DID resolution result or undefined if not found or expired.
+     */
+    get(did: string): Promise<DidResolutionResult | void>;
+    /**
+     * Stores a DID resolution result in the cache with a TTL.
+     *
+     * @param did - The DID string used as the key for storing the result.
+     * @param value - The DID resolution result to be cached.
+     * @returns A promise that resolves when the operation is complete.
+     */
+    set(did: string, value: DidResolutionResult): Promise<void>;
+    /**
+     * Deletes a DID resolution result from the cache.
+     *
+     * @param did - The DID string used as the key for deletion.
+     * @returns A promise that resolves when the operation is complete.
+     */
+    delete(did: string): Promise<void>;
+    /**
+     * Clears all entries from the cache.
+     *
+     * @returns A promise that resolves when the operation is complete.
+     */
+    clear(): Promise<void>;
+    /**
+     * Closes the underlying LevelDB store.
+     *
+     * @returns A promise that resolves when the store is closed.
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=resolver-cache-level.d.ts.map

package/dist/types/resolver/resolver-cache-level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver-cache-level.d.ts","sourceRoot":"","sources":["../../../src/resolver/resolver-cache-level.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAKpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE;;;;;GAKG;AACH,MAAM,MAAM,2BAA2B,GAAG;IACxC;;;OAGG;IACH,EAAE,CAAC,EAAE,aAAa,CAAC,MAAM,GAAG,MAAM,GAAG,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjE;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAA;AAyBD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,qBAAsB,YAAW,gBAAgB;IAC5D,qDAAqD;IACrD,SAAS,CAAC,KAAK,8DAAC;IAEhB,0DAA0D;IAC1D,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC;gBAEV,EACV,EAAE,EACF,QAAmC,EACnC,GAAW,EACZ,GAAE,2BAAgC;IAKnC;;;;;;;OAOG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAwB3D;;;;;;OAMG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAO3D;;;;;OAKG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlC;;;;OAIG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB;;;;OAIG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAGvB"}

package/dist/types/resolver/resolver-cache-noop.d.ts

@@ -0,0 +1,9 @@
+import type { DidResolverCache } from '../types/did-resolution.js';
+/**
+ * No-op cache that is used as the default cache for did-resolver.
+ *
+ * The motivation behind using a no-op cache as the default stems from the desire to maximize the
+ * potential for this library to be used in as many JS runtimes as possible.
+ */
+export declare const DidResolverCacheNoop: DidResolverCache;
+//# sourceMappingURL=resolver-cache-noop.d.ts.map

package/dist/types/resolver/resolver-cache-noop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver-cache-noop.d.ts","sourceRoot":"","sources":["../../../src/resolver/resolver-cache-noop.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,EAAE,gBAgBlC,CAAC"}

package/dist/types/resolver/universal-resolver.d.ts

@@ -0,0 +1,109 @@
+import type { DidMethodResolver } from '../methods/did-method.js';
+import type { DidResolver, DidResolverCache, DidUrlDereferencer } from '../types/did-resolution.js';
+import type { DidDereferencingOptions, DidDereferencingResult, DidResolutionOptions, DidResolutionResult } from '../types/did-core.js';
+/**
+ * Parameters for configuring the `UniversalResolver` class, which is responsible for resolving
+ * decentralized identifiers (DIDs) to their corresponding DID documents.
+ *
+ * This type specifies the essential components required by the `UniversalResolver` to perform
+ * DID resolution and dereferencing. It includes an array of `DidMethodResolver` instances,
+ * each capable of resolving DIDs for a specific method, and optionally, a cache for storing
+ * resolved DID documents to improve resolution efficiency.
+ */
+export type UniversalResolverParams = {
+    /**
+     * An array of `DidMethodResolver` instances.
+     *
+     * Each resolver in this array is designed to handle a specific DID method, enabling the
+     * `DidResolver` to support multiple DID methods simultaneously.
+     */
+    didResolvers: DidMethodResolver[];
+    /**
+     * An optional `DidResolverCache` instance used for caching resolved DID documents.
+     *
+     * Providing a cache implementation can significantly enhance resolution performance by avoiding
+     * redundant resolutions for previously resolved DIDs. If omitted, a no-operation cache is used,
+     * which effectively disables caching.
+     */
+    cache?: DidResolverCache;
+};
+/**
+ * The `DidResolver` class provides mechanisms for resolving Decentralized Identifiers (DIDs) to
+ * their corresponding DID documents.
+ *
+ * The class is designed to handle various DID methods by utilizing an array of `DidMethodResolver`
+ * instances, each responsible for a specific DID method.
+ *
+ * Providing a cache implementation can significantly enhance resolution performance by avoiding
+ * redundant resolutions for previously resolved DIDs. If omitted, a no-operation cache is used,
+ * which effectively disables caching.
+ *
+ * Usage:
+ * - Construct the `DidResolver` with an array of `DidMethodResolver` instances and an optional cache.
+ * - Use `resolve` to resolve a DID to its DID Resolution Result.
+ * - Use `dereference` to extract specific resources from a DID URL, like service endpoints or verification methods.
+ *
+ * @example
+ * ```ts
+ * const resolver = new DidResolver({
+ *   didResolvers: [<array of DidMethodResolver instances>],
+ *   cache: new DidResolverCacheNoop()
+ * });
+ *
+ * const resolutionResult = await resolver.resolve('did:example:123456');
+ * const dereferenceResult = await resolver.dereference({ didUri: 'did:example:123456#key-1' });
+ * ```
+ */
+export declare class UniversalResolver implements DidResolver, DidUrlDereferencer {
+    /**
+     * A cache for storing resolved DID documents.
+     */
+    protected cache: DidResolverCache;
+    /**
+     * A map to store method resolvers against method names.
+     */
+    private didResolvers;
+    /**
+     * Constructs a new `DidResolver`.
+     *
+     * @param params - The parameters for constructing the `DidResolver`.
+     */
+    constructor({ cache, didResolvers }: UniversalResolverParams);
+    /**
+     * Resolves a DID to a DID Resolution Result.
+     *
+     * If the DID Resolution Result is present in the cache, it returns the cached result. Otherwise,
+     * it uses the appropriate method resolver to resolve the DID, stores the resolution result in the
+     * cache, and returns the resolultion result.
+     *
+     * @param didUri - The DID or DID URL to resolve.
+     * @returns A promise that resolves to the DID Resolution Result.
+     */
+    resolve(didUri: string, options?: DidResolutionOptions): Promise<DidResolutionResult>;
+    /**
+     * Dereferences a DID (Decentralized Identifier) URL to a corresponding DID resource.
+     *
+     * This method interprets the DID URL's components, which include the DID method, method-specific
+     * identifier, path, query, and fragment, and retrieves the related resource as per the DID Core
+     * specifications.
+     *
+     * The dereferencing process involves resolving the DID contained in the DID URL to a DID document,
+     * and then extracting the specific part of the document identified by the fragment in the DID URL.
+     * If no fragment is specified, the entire DID document is returned.
+     *
+     * This method supports resolution of different components within a DID document such as service
+     * endpoints and verification methods, based on their IDs. It accommodates both full and
+     * DID URLs as specified in the DID Core specification.
+     *
+     * More information on DID URL dereferencing can be found in the
+     * {@link https://www.w3.org/TR/did-core/#did-url-dereferencing | DID Core specification}.
+     *
+     * TODO: This is a partial implementation and does not fully implement DID URL dereferencing. (https://github.com/TBD54566975/web5-js/issues/387)
+     *
+     * @param didUrl - The DID URL string to dereference.
+     * @param [_options] - Input options to the dereference function. Optional.
+     * @returns a {@link DidDereferencingResult}
+     */
+    dereference(didUrl: string, _options?: DidDereferencingOptions): Promise<DidDereferencingResult>;
+}
+//# sourceMappingURL=universal-resolver.d.ts.map

package/dist/types/resolver/universal-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"universal-resolver.d.ts","sourceRoot":"","sources":["../../../src/resolver/universal-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACpG,OAAO,KAAK,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,mBAAmB,EAAe,MAAM,sBAAsB,CAAC;AAOpJ;;;;;;;;GAQG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC;;;;;OAKG;IACH,YAAY,EAAE,iBAAiB,EAAE,CAAC;IAElC;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,gBAAgB,CAAC;CAC1B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,iBAAkB,YAAW,WAAW,EAAE,kBAAkB;IACvE;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,gBAAgB,CAAC;IAElC;;OAEG;IACH,OAAO,CAAC,YAAY,CAA6C;IAEjE;;;;OAIG;gBACS,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE,uBAAuB;IAQ5D;;;;;;;;;OASG;IACU,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAuClG;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,WAAW,CACf,MAAM,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,uBAAuB,GACjC,OAAO,CAAC,sBAAsB,CAAC;CAyEnC"}