@enbox/dids 0.0.1

package/package.json

@@ -0,0 +1,116 @@
+{
+  "name": "@enbox/dids",
+  "version": "0.0.1",
+  "description": "TBD DIDs library",
+  "type": "module",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "scripts": {
+    "clean": "rimraf dist coverage tests/compiled",
+    "build:esm": "rimraf dist/esm dist/types && pnpm tsc -p tsconfig.json",
+    "build:cjs": "rimraf dist/cjs && node build/cjs-bundle.js && echo '{\"type\": \"commonjs\"}' > ./dist/cjs/package.json",
+    "build:browser": "rimraf dist/browser.mjs dist/browser.js && node build/bundles.js",
+    "build:tests:node": "rimraf tests/compiled && pnpm tsc -p tests/tsconfig.json",
+    "build:tests:browser": "rimraf tests/compiled && node build/esbuild-tests.cjs",
+    "build": "pnpm clean && pnpm build:esm && pnpm build:cjs && pnpm build:browser",
+    "lint": "eslint . --max-warnings 0",
+    "lint:fix": "eslint . --fix",
+    "test:node": "pnpm build:tests:node && pnpm c8 mocha",
+    "test:browser": "pnpm build:tests:browser && web-test-runner"
+  },
+  "homepage": "https://github.com/enboxorg/enbox/tree/main/packages/dids#readme",
+  "bugs": "https://github.com/enboxorg/enbox/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/enboxorg/enbox.git",
+    "directory": "packages/dids"
+  },
+  "license": "Apache-2.0",
+  "contributors": [
+    {
+      "name": "Daniel Buchner",
+      "url": "https://github.com/csuwildcat"
+    },
+    {
+      "name": "Frank Hinek",
+      "url": "https://github.com/frankhinek"
+    },
+    {
+      "name": "Moe Jangda",
+      "url": "https://github.com/mistermoe"
+    }
+  ],
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./utils": {
+      "types": "./dist/types/utils.d.ts",
+      "import": "./dist/esm/utils.js",
+      "require": "./dist/cjs/utils.js"
+    }
+  },
+  "react-native": "./dist/esm/index.js",
+  "keywords": [
+    "decentralized",
+    "decentralized-identity",
+    "DID",
+    "did:ion",
+    "did:key",
+    "did-utils",
+    "self-sovereign-identity",
+    "web5"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@decentralized-identity/ion-sdk": "1.0.4",
+    "@dnsquery/dns-packet": "6.1.1",
+    "@enbox/common": "workspace:*",
+    "@enbox/crypto": "workspace:*",
+    "abstract-level": "1.0.4",
+    "bencode": "4.0.0",
+    "buffer": "6.0.3",
+    "level": "8.0.1",
+    "ms": "2.1.3"
+  },
+  "devDependencies": {
+    "@playwright/test": "1.45.3",
+    "@types/bencode": "2.0.4",
+    "@types/chai": "4.3.16",
+    "@types/chai-as-promised": "7.1.8",
+    "@types/eslint": "8.56.10",
+    "@types/mocha": "10.0.7",
+    "@types/ms": "0.7.34",
+    "@types/node": "20.14.8",
+    "@types/sinon": "17.0.3",
+    "@typescript-eslint/eslint-plugin": "7.9.0",
+    "@typescript-eslint/parser": "7.14.1",
+    "@web/test-runner": "0.18.2",
+    "@web/test-runner-playwright": "0.11.0",
+    "c8": "9.1.0",
+    "chai": "5.1.1",
+    "chai-as-promised": "7.1.2",
+    "esbuild": "0.23.0",
+    "eslint": "9.5.0",
+    "eslint-plugin-mocha": "10.4.3",
+    "mocha": "10.7.0",
+    "mocha-junit-reporter": "2.2.1",
+    "playwright": "1.45.3",
+    "rimraf": "5.0.7",
+    "sinon": "18.0.0",
+    "source-map-loader": "5.0.0",
+    "typescript": "5.5.4"
+  }
+}

package/src/bearer-did.ts

@@ -0,0 +1,287 @@
+import type {
+  Jwk,
+  Signer,
+  CryptoApi,
+  KeyIdentifier,
+  EnclosedSignParams,
+  KmsExportKeyParams,
+  KmsImportKeyParams,
+  KeyImporterExporter,
+  EnclosedVerifyParams,
+} from '@enbox/crypto';
+
+import { LocalKeyManager, CryptoUtils } from '@enbox/crypto';
+
+import type { DidDocument } from './types/did-core.js';
+import type { DidMetadata, PortableDid } from './types/portable-did.js';
+
+import { DidError, DidErrorCode } from './did-error.js';
+import { extractDidFragment, getVerificationMethods } from './utils.js';
+
+/**
+ * A `BearerDidSigner` extends the {@link Signer} interface to include specific properties for
+ * signing with a Decentralized Identifier (DID). It encapsulates the algorithm and key identifier,
+ * which are often needed when signing JWTs, JWSs, JWEs, and other data structures.
+ *
+ * Typically, the algorithm and key identifier are used to populate the `alg` and `kid` fields of a
+ * JWT or JWS header.
+ */
+export interface BearerDidSigner extends Signer {
+  /**
+   * The cryptographic algorithm identifier used for signing operations.
+   *
+   * Typically, this value is used to populate the `alg` field of a JWT or JWS header. The
+   * registered algorithm names are defined in the
+   * {@link https://www.iana.org/assignments/jose/jose.xhtml#web-signature-encryption-algorithms | IANA JSON Web Signature and Encryption Algorithms registry}.
+   *
+   * @example
+   * "ES256" // ECDSA using P-256 and SHA-256
+   */
+  algorithm: string;
+
+  /**
+   * The unique identifier of the key within the DID document that is used for signing and
+   * verification operations.
+   *
+   * This identifier must be a DID URI with a fragment (e.g., did:method:123#key-0) that references
+   * a specific verification method in the DID document. It allows users of a `BearerDidSigner` to
+   * determine the DID and key that will be used for signing and verification operations.
+   *
+   * @example
+   * "did:dht:123#key-1" // A fragment identifier referring to a key in the DID document
+   */
+  keyId: string;
+}
+
+/**
+ * Represents a Decentralized Identifier (DID) along with its DID document, key manager, metadata,
+ * and convenience functions.
+ */
+export class BearerDid {
+  /** {@inheritDoc Did#uri} */
+  uri: string;
+
+  /**
+   * The DID document associated with this DID.
+   *
+   * @see {@link https://www.w3.org/TR/did-core/#dfn-diddocument | DID Core Specification, § DID Document}
+   */
+  document: DidDocument;
+
+  /** {@inheritDoc DidMetadata} */
+  metadata: DidMetadata;
+
+  /**
+   * Key Management System (KMS) used to manage the DIDs keys and sign data.
+   *
+   * Each DID method requires at least one key be present in the provided `keyManager`.
+   */
+  keyManager: CryptoApi;
+
+  constructor({ uri, document, metadata, keyManager }: {
+    uri: string,
+    document: DidDocument,
+    metadata: DidMetadata,
+    keyManager: CryptoApi
+  }) {
+    this.uri = uri;
+    this.document = document;
+    this.metadata = metadata;
+    this.keyManager = keyManager;
+  }
+
+  /**
+   * Converts a `BearerDid` object to a portable format containing the URI and verification methods
+   * associated with the DID.
+   *
+   * This method is useful when you need to represent the key material and metadata associated with
+   * a DID in format that can be used independently of the specific DID method implementation. It
+   * extracts both public and private keys from the DID's key manager and organizes them into a
+   * `PortableDid` structure.
+   *
+   * @remarks
+   * If the DID's key manager does not allow private keys to be exported, the `PortableDid` returned
+   * will not contain a `privateKeys` property. This enables the importing and exporting DIDs that
+   * use the same underlying KMS even if the KMS does not support exporting private keys. Examples
+   * include hardware security modules (HSMs) and cloud-based KMS services like AWS KMS.
+   *
+   * If the DID's key manager does support exporting private keys, the resulting `PortableDid` will
+   * include a `privateKeys` property which contains the same number of entries as there are
+   * verification methods as the DID document, each with its associated private key and the
+   * purpose(s) for which the key can be used (e.g., `authentication`, `assertionMethod`, etc.).
+   *
+   * @example
+   * ```ts
+   * // Assuming `did` is an instance of BearerDid
+   * const portableDid = await did.export();
+   * // portableDid now contains the DID URI, document, metadata, and optionally, private keys.
+   * ```
+   *
+   * @returns A `PortableDid` containing the URI, DID document, metadata, and optionally private
+   *          keys associated with the `BearerDid`.
+   * @throws An error if the DID document does not contain any verification methods or the keys for
+   *         any verification method are missing in the key manager.
+   */
+  public async export(): Promise<PortableDid> {
+    // Verify the DID document contains at least one verification method.
+    if (!(Array.isArray(this.document.verificationMethod) && this.document.verificationMethod.length > 0)) {
+      throw new Error(`DID document for '${this.uri}' is missing verification methods`);
+    }
+
+    // Create a new `PortableDid` copy object to store the exported data.
+    let portableDid: PortableDid = JSON.parse(JSON.stringify({
+      uri      : this.uri,
+      document : this.document,
+      metadata : this.metadata
+    }));
+
+    // If the BearerDid's key manager supports exporting private keys, add them to the portable DID.
+    if ('exportKey' in this.keyManager && typeof this.keyManager.exportKey === 'function') {
+      const privateKeys: Jwk[] = [];
+      for (let vm of this.document.verificationMethod) {
+        if (!vm.publicKeyJwk) {
+          throw new Error(`Verification method '${vm.id}' does not contain a public key in JWK format`);
+        }
+
+        // Compute the key URI of the verification method's public key.
+        const keyUri = await this.keyManager.getKeyUri({ key: vm.publicKeyJwk });
+
+        // Retrieve the private key from the key manager.
+        const privateKey = await this.keyManager.exportKey({ keyUri }) as Jwk;
+
+        // Add the verification method to the key set.
+        privateKeys.push({ ...privateKey });
+      }
+      portableDid.privateKeys = privateKeys;
+    }
+
+    return portableDid;
+  }
+
+  /**
+   * Return a {@link Signer} that can be used to sign messages, credentials, or arbitrary data.
+   *
+   * If given, the `methodId` parameter is used to select a key from the verification methods
+   * present in the DID Document.
+   *
+   * If `methodID` is not given, the first verification method intended for signing claims is used.
+   *
+   * @param params - The parameters for the `getSigner` operation.
+   * @param params.methodId - ID of the verification method key that will be used for sign and
+   *                          verify operations. Optional.
+   * @returns An instantiated {@link Signer} that can be used to sign and verify data.
+   */
+  public async getSigner(params?: { methodId: string }): Promise<BearerDidSigner> {
+    // Attempt to find a verification method that matches the given method ID, or if not given,
+    // find the first verification method intended for signing claims.
+    const verificationMethod = this.document.verificationMethod?.find(
+      vm => extractDidFragment(vm.id) === (extractDidFragment(params?.methodId) ?? extractDidFragment(this.document.assertionMethod?.[0]))
+    );
+
+    if (!(verificationMethod && verificationMethod.publicKeyJwk)) {
+      throw new DidError(DidErrorCode.InternalError, 'A verification method intended for signing could not be determined from the DID Document');
+    }
+
+    // Compute the expected key URI of the signing key.
+    const keyUri = await this.keyManager.getKeyUri({ key: verificationMethod.publicKeyJwk });
+
+    // Get the public key to be used for verify operations, which also verifies that the key is
+    // present in the key manager's store.
+    const publicKey = await this.keyManager.getPublicKey({ keyUri });
+
+    // Bind the DID's key manager to the signer.
+    const keyManager = this.keyManager;
+
+    // Determine the signing algorithm.
+    const algorithm = CryptoUtils.getJoseSignatureAlgorithmFromPublicKey(publicKey);
+
+    return {
+      algorithm : algorithm,
+      keyId     : verificationMethod.id,
+
+      async sign({ data }: EnclosedSignParams): Promise<Uint8Array> {
+        const signature = await keyManager.sign({ data, keyUri: keyUri! }); // `keyUri` is guaranteed to be defined at this point.
+        return signature;
+      },
+
+      async verify({ data, signature }: EnclosedVerifyParams): Promise<boolean> {
+        const isValid = await keyManager.verify({ data, key: publicKey!, signature }); // `publicKey` is guaranteed to be defined at this point.
+        return isValid;
+      }
+    };
+  }
+
+  /**
+   * Instantiates a {@link BearerDid} object from a given {@link PortableDid}.
+   *
+   * This method allows for the creation of a `BearerDid` object using a previously created DID's
+   * key material, DID document, and metadata.
+   *
+   * @example
+   * ```ts
+   * // Export an existing BearerDid to PortableDid format.
+   * const portableDid = await did.export();
+   * // Reconstruct a BearerDid object from the PortableDid.
+   * const did = await BearerDid.import({ portableDid });
+   * ```
+   *
+   * @param params - The parameters for the import operation.
+   * @param params.portableDid - The PortableDid object to import.
+   * @param params.keyManager - Optionally specify an external Key Management System (KMS) used to
+   *                            generate keys and sign data. If not given, a new
+   *                            {@link LocalKeyManager} instance will be created and
+   *                            used.
+   * @returns A Promise resolving to a `BearerDid` object representing the DID formed from the
+   *          provided PortableDid.
+   * @throws An error if the PortableDid document does not contain any verification methods or the
+   *         keys for any verification method are missing in the key manager.
+   */
+  public static async import({ portableDid, keyManager = new LocalKeyManager() }: {
+    keyManager?: CryptoApi & KeyImporterExporter<KmsImportKeyParams, KeyIdentifier, KmsExportKeyParams>;
+    portableDid: PortableDid;
+  }): Promise<BearerDid> {
+
+    // Get all verification methods from the given DID document, including embedded methods.
+    const verificationMethods = getVerificationMethods({ didDocument: portableDid.document });
+
+    // Validate that the DID document contains at least one verification method.
+    if (verificationMethods.length === 0) {
+      throw new DidError(DidErrorCode.InvalidDidDocument, `At least one verification method is required but 0 were given`);
+    }
+
+    // If given, import the private key material into the key manager.
+    for (let key of portableDid.privateKeys ?? []) {
+
+      // confirm th key does not already exist before importing it to avoid failures from the key manager
+      const keyUri = await keyManager.getKeyUri({ key });
+      const keyExists = await keyManager.getPublicKey({ keyUri }).then(() => true).catch(() => false);
+      if (!keyExists) {
+        await keyManager.importKey({ key });
+      }
+    }
+
+    // Validate that the key material for every verification method in the DID document is present
+    // in the key manager.
+    for (let vm of verificationMethods) {
+      if (!vm.publicKeyJwk) {
+        throw new Error(`Verification method '${vm.id}' does not contain a public key in JWK format`);
+      }
+
+      // Compute the key URI of the verification method's public key.
+      const keyUri = await keyManager.getKeyUri({ key: vm.publicKeyJwk });
+
+      // Verify that the key is present in the key manager. If not, an error is thrown.
+      await keyManager.getPublicKey({ keyUri });
+    }
+
+    // Use the given PortableDid to construct the BearerDid object.
+    const did = new BearerDid({
+      uri      : portableDid.uri,
+      document : portableDid.document,
+      metadata : portableDid.metadata,
+      keyManager
+    });
+
+    return did;
+  }
+}

package/src/did-error.ts

@@ -0,0 +1,75 @@
+/**
+ * A custom error class for DID-related errors.
+ */
+export class DidError extends Error {
+  /**
+   * Constructs an instance of DidError, a custom error class for handling DID-related errors.
+   *
+   * @param code - A {@link DidErrorCode} representing the specific type of error encountered.
+   * @param message - A human-readable description of the error.
+   */
+  constructor(public code: DidErrorCode, message: string) {
+    super(`${code}: ${message}`);
+    this.name = 'DidError';
+
+    // Ensures that instanceof works properly, the correct prototype chain when using inheritance,
+    // and that V8 stack traces (like Chrome, Edge, and Node.js) are more readable and relevant.
+    Object.setPrototypeOf(this, new.target.prototype);
+
+    // Captures the stack trace in V8 engines (like Chrome, Edge, and Node.js).
+    // In non-V8 environments, the stack trace will still be captured.
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, DidError);
+    }
+  }
+}
+
+/**
+ * An enumeration of possible DID error codes.
+ */
+export enum DidErrorCode {
+  /** The DID supplied does not conform to valid syntax. */
+  InvalidDid = 'invalidDid',
+
+  /** The supplied method name is not supported by the DID method and/or DID resolver implementation. */
+  MethodNotSupported = 'methodNotSupported',
+
+  /** An unexpected error occurred during the requested DID operation. */
+  InternalError = 'internalError',
+
+  /** The DID document supplied does not conform to valid syntax. */
+  InvalidDidDocument = 'invalidDidDocument',
+
+  /** The byte length of a DID document does not match the expected value. */
+  InvalidDidDocumentLength = 'invalidDidDocumentLength',
+
+  /** The DID URL supplied to the dereferencing function does not conform to valid syntax. */
+  InvalidDidUrl = 'invalidDidUrl',
+
+  /** The given proof of a previous DID is invalid */
+  InvalidPreviousDidProof = 'invalidPreviousDidProof',
+
+  /** An invalid public key is detected during a DID operation. */
+  InvalidPublicKey = 'invalidPublicKey',
+
+  /** The byte length of a public key does not match the expected value. */
+  InvalidPublicKeyLength = 'invalidPublicKeyLength',
+
+  /** An invalid public key type was detected during a DID operation. */
+  InvalidPublicKeyType = 'invalidPublicKeyType',
+
+  /** Verification of a signature failed during a DID operation. */
+  InvalidSignature = 'invalidSignature',
+
+  /** The DID resolver was unable to find the DID document resulting from the resolution request. */
+  NotFound = 'notFound',
+
+  /**
+   * The representation requested via the `accept` input metadata property is not supported by the
+   * DID method and/or DID resolver implementation.
+   */
+  RepresentationNotSupported = 'representationNotSupported',
+
+  /** The type of a public key is not supported by the DID method and/or DID resolver implementation. */
+  UnsupportedPublicKeyType = 'unsupportedPublicKeyType',
+}

package/src/did.ts

@@ -0,0 +1,186 @@
+/**
+ * The `Did` class represents a Decentralized Identifier (DID) Uniform Resource Identifier (URI).
+ *
+ * This class provides a method for parsing a DID URI string into its component parts, as well as a
+ * method for serializing a DID URI object into a string.
+ *
+ * A DID URI is composed of the following components:
+ * - scheme
+ * - method
+ * - id
+ * - path
+ * - query
+ * - fragment
+ * - params
+ *
+ * @see {@link https://www.w3.org/TR/did-core/#did-syntax | DID Core Specification, § DID Syntax}
+ */
+export class Did {
+  /** Regular expression pattern for matching the method component of a DID URI. */
+  static readonly METHOD_PATTERN = '([a-z0-9]+)';
+  /** Regular expression pattern for matching percent-encoded characters in a method identifier. */
+  static readonly PCT_ENCODED_PATTERN = '(?:%[0-9a-fA-F]{2})';
+  /** Regular expression pattern for matching the characters allowed in a method identifier. */
+  static readonly ID_CHAR_PATTERN = `(?:[a-zA-Z0-9._-]|${Did.PCT_ENCODED_PATTERN})`;
+  /** Regular expression pattern for matching the method identifier component of a DID URI. */
+  static readonly METHOD_ID_PATTERN = `((?:${Did.ID_CHAR_PATTERN}*:)*(${Did.ID_CHAR_PATTERN}+))`;
+  /** Regular expression pattern for matching the path component of a DID URI. */
+  static readonly PATH_PATTERN = `(/[^#?]*)?`;
+  /** Regular expression pattern for matching the query component of a DID URI. */
+  static readonly QUERY_PATTERN = `([?][^#]*)?`;
+  /** Regular expression pattern for matching the fragment component of a DID URI. */
+  static readonly FRAGMENT_PATTERN = `(#.*)?`;
+  /** Regular expression pattern for matching all of the components of a DID URI. */
+  static readonly DID_URI_PATTERN = new RegExp(
+    `^did:(?<method>${Did.METHOD_PATTERN}):(?<id>${Did.METHOD_ID_PATTERN})(?<path>${Did.PATH_PATTERN})(?<query>${Did.QUERY_PATTERN})(?<fragment>${Did.FRAGMENT_PATTERN})$`
+  );
+
+  /**
+   * A string representation of the DID.
+   *
+   * A DID is a URI composed of three parts: the scheme `did:`, a method identifier, and a unique,
+   * method-specific identifier specified by the DID method.
+   *
+   * @example
+   * did:dht:h4d3ixkwt6q5a455tucw7j14jmqyghdtbr6cpiz6on5oxj5bpr3o
+   */
+  uri: string;
+
+  /**
+   * The name of the DID method.
+   *
+   * Examples of DID method names are `dht`, `jwk`, and `web`, among others.
+   */
+  method: string;
+
+  /**
+   * The DID method identifier.
+   *
+   * @example
+   * h4d3ixkwt6q5a455tucw7j14jmqyghdtbr6cpiz6on5oxj5bpr3o
+   */
+  id: string;
+
+  /**
+      * Optional path component of the DID URI.
+      *
+      * @example
+      * did:web:tbd.website/path
+      */
+  path?: string;
+
+  /**
+      * Optional query component of the DID URI.
+      *
+      * @example
+      * did:web:tbd.website?versionId=1
+      */
+  query?: string;
+
+  /**
+   * Optional fragment component of the DID URI.
+   *
+   * @example
+   * did:web:tbd.website#key-1
+   */
+  fragment?: string;
+
+  /**
+    * Optional query parameters in the DID URI.
+    *
+    * @example
+    * did:web:tbd.website?service=files&relativeRef=/whitepaper.pdf
+    */
+  params?: Record<string, string>;
+
+  /**
+   * Constructs a new `Did` instance from individual components.
+   *
+   * @param params - An object containing the parameters to be included in the DID URI.
+   * @param params.method - The name of the DID method.
+   * @param params.id - The DID method identifier.
+   * @param params.path - Optional. The path component of the DID URI.
+   * @param params.query - Optional. The query component of the DID URI.
+   * @param params.fragment - Optional. The fragment component of the DID URI.
+   * @param params.params - Optional. The query parameters in the DID URI.
+   */
+  constructor({ method, id, path, query, fragment, params }: {
+    method: string,
+    id: string,
+    path?: string,
+    query?: string,
+    fragment?: string,
+    params?: Record<string, string>
+  }) {
+    this.uri = `did:${method}:${id}`;
+    this.method = method;
+    this.id = id;
+    this.path = path;
+    this.query = query;
+    this.fragment = fragment;
+    this.params = params;
+  }
+
+  /**
+   * Parses a DID URI string into its individual components.
+   *
+   * @example
+   * ```ts
+   * const did = Did.parse('did:example:123?service=agent&relativeRef=/credentials#degree');
+   *
+   * console.log(did.uri)      // Output: 'did:example:123'
+   * console.log(did.method)   // Output: 'example'
+   * console.log(did.id)       // Output: '123'
+   * console.log(did.query)    // Output: 'service=agent&relativeRef=/credentials'
+   * console.log(did.fragment) // Output: 'degree'
+   * console.log(did.params)   // Output: { service: 'agent', relativeRef: '/credentials' }
+   * ```
+   *
+   * @params didUri - The DID URI string to be parsed.
+   * @returns A `Did` object representing the parsed DID URI, or `null` if the input string is not a valid DID URI.
+   */
+  static parse(didUri: string): Did | null {
+    // Return null if the input string is empty or not provided.
+    if (!didUri) return null;
+
+    // Execute the regex pattern on the input string to extract URI components.
+    const match = Did.DID_URI_PATTERN.exec(didUri);
+
+    // If the pattern does not match, or if the required groups are not found, return null.
+    if (!match || !match.groups) return null;
+
+    // Extract the method, id, params, path, query, and fragment from the regex match groups.
+    const { method, id, path, query, fragment } = match.groups;
+
+    // Initialize a new Did object with the uri, method and id.
+    const did: Did = {
+      uri: `did:${method}:${id}`,
+      method,
+      id,
+    };
+
+    // If path is present, add it to the Did object.
+    if (path) did.path = path;
+
+    // If query is present, add it to the Did object, removing the leading '?'.
+    if (query) did.query = query.slice(1);
+
+    // If fragment is present, add it to the Did object, removing the leading '#'.
+    if (fragment) did.fragment = fragment.slice(1);
+
+    // If query params are present, parse them into a key-value object and add to the Did object.
+    if (query) {
+      const parsedParams = {} as Record<string, string>;
+      // Split the query string by '&' to get individual parameter strings.
+      const paramPairs = query.slice(1).split('&');
+      for (const pair of paramPairs) {
+        // Split each parameter string by '=' to separate keys and values.
+        const [key, value] = pair.split('=');
+        parsedParams[key] = value;
+      }
+      did.params = parsedParams;
+    }
+
+    return did;
+  }
+}

package/src/index.ts

@@ -0,0 +1,21 @@
+export * from './types/did-core.js';
+export * from './types/did-resolution.js';
+export type * from './types/multibase.js';
+export type * from './types/portable-did.js';
+
+export * from './did.js';
+export * from './did-error.js';
+export * from './bearer-did.js';
+
+export * from './methods/did-dht.js';
+export * from './methods/did-ion.js';
+export * from './methods/did-jwk.js';
+export * from './methods/did-key.js';
+export * from './methods/did-method.js';
+export * from './methods/did-web.js';
+
+export * from './resolver/resolver-cache-level.js';
+export * from './resolver/resolver-cache-noop.js';
+export * from './resolver/universal-resolver.js';
+
+export * as utils from './utils.js';