@pagopa/io-react-native-iso18013 0.1.0

package/ios/IoReactNativeIso18013.swift

@@ -0,0 +1,491 @@
+import Foundation
+import IOWalletProximity
+import React
+
+@objc(IoReactNativeIso18013)
+class IoReactNativeProximity: RCTEventEmitter {
+  
+  private typealias ME = ModuleException
+  
+  @objc
+  override static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+  
+  override init() {
+    super.init()
+    setupProximityHandler()
+  }
+  
+  /**
+   Specifies supported events which will be emitted.
+   - `onDeviceConnecting`: Emitted when the device is connecting to the verifier app.
+   - `onDeviceConnected`: Emitted when the device is connected to the verifier app.
+   - `onDocumentRequestReceived`: Emitted when a document request is received from the verifier app. Carries a payload containing the request data.
+   - `onDeviceDisconnected`: Emitted when the device is disconnected from the verifier app.
+   - `onError`: Emitted when an error occurs. Carries a payload containing the error data.
+   */
+  override func supportedEvents() -> [String]! {
+    return ["onDeviceConnected", "onDeviceConnecting", "onDeviceDisconnected", "onDocumentRequestReceived", "onError", "unknown"]
+  }
+  
+  /**
+   Type alias for the accepted fields during the presentation. These are the fields which the user accepted to share.
+   It can be fed to the ``IOWalletProximity.generateResponse`` function.
+   An example might be:
+   `["org.iso.18013.5.1.mDL": ["org.iso.18013.5.1": ["hair_colour": true, "given_name_national_character": true, "family_name_national_character": true, "given_name": true]]]`
+   */
+  typealias AcceptedFieldsDict = [String: [String: [String: Bool]]]
+  
+  /**
+   Starts the proximity flow by allocating the necessary resources and initializing the Bluetooth stack.
+   Resolves to true or rejects if an error occurs.
+    
+   - Parameters:
+      - certificates: Array of base64 representing DER encoded X.509 certificate which are used to authenticate the verifier app
+      - resolve: The promise to be resolved
+      - reject: The promise to be rejected
+  */
+  @objc(start:withResolver:withRejecter:)
+  func start(
+    certificates: Array<Any>,
+    _ resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
+  ){
+    do {
+      let certsData = parseCertificates(certificates)
+      try Proximity.shared.start(certsData.isEmpty ? nil : certsData)
+      resolve(true)
+    } catch let error {
+      ME.startError.reject(reject: reject, ("error", error.localizedDescription))
+    }
+  }
+  
+  /**
+   Utility function to parse an array coming from the React Native Bridge into an array of Data representing DER encoded X.509 certificates.
+   
+   - Parameters:
+      - certificates:Array of base64 strings representing DER encoded X.509 certificate
+   
+    - Returns: An array of Data containing DER ecnoded X.509 certificates.
+  */
+  private func parseCertificates(_ certificates: [Any]) -> [Data] {
+    return certificates.compactMap { item in
+      guard let certString = item as? String,
+            let data = Data(base64Encoded: certString) else {
+        return nil
+      }
+      return data
+    }
+  }
+  
+  /**
+   Creates a QR code to be scanned in order to initialize the presentation.
+   Resolves with the QR code strings.
+
+   - Parameters:
+      - resolve: The promise to be resolved
+      - reject: The promise to be rejected
+  */
+  @objc(getQrCodeString:withRejecter:)
+  func getQrCodeString(
+    _ resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
+  ) {
+    do{
+      let qrCodeString = try Proximity.shared.getQrCode()
+      resolve(qrCodeString)
+    } catch let error {
+      ME.qrCodeError.reject(reject: reject, ("error", error.localizedDescription))
+    }
+  }
+  
+  /**
+   Parses an array of documents from the React Native bridge which doesn't have any typing to an array of ``IOWalletProximity.ProximityDocument``.
+   It checks if each element in the array has  `issuerSignedContent`, `alias` and `docType` properties in order to build a ``IOWalletProximity.ProximityDocument``, then it appens it to the array.
+   The result can be fed to ``IOWalletProximity.generateResponse``.
+   
+   - Parameters:
+      - documents: An array containing documents. Each document is defined as a map containing:
+         - issuerSignedContent which is a base64 or base64url encoded string representing the credential;
+         - alias which is the alias of the key used to sign the credential;
+         - docType which is the document type.
+   
+   - Throws: `ModuleException.invalidDocRequested.error()` and `ModuleException.invalidDocRequested.error()` iif an error occurs while parsing the document
+   
+   - Returns: An array of `ProximityDocument` containg the documents to be presented
+   */
+  private func parseDocuments(documents: [Any]) throws -> [ProximityDocument] {
+    return try documents.compactMap{ (element) -> ProximityDocument in
+      guard let dict : [String: Any] = element as? [String: Any] else { throw ModuleException.unableToDecode.error() }
+      guard
+        let issuerSignedContent = dict["issuerSignedContent"] as? String,
+        let alias = dict["alias"] as? String,
+        let docType = dict["docType"] as? String,
+        let decodedIssuerSignedContent = try? Base64Utils.decodeBase64OrBase64URL(base: issuerSignedContent)
+      else { throw ModuleException.invalidDocRequested.error() }
+      
+      guard let document = ProximityDocument(
+        docType: docType,
+        issuerSigned: [UInt8](decodedIssuerSignedContent),
+        deviceKeyTag: alias
+      ) else {
+        throw ModuleException.invalidDocRequested.error()
+      }
+      return document
+    }
+  }
+  
+  /**
+   Parses a dictionary of accepted fields for the presentation from the React Native bridge which doesn't have any typing to a ``AcceptedFieldsDict`` dictionary.
+   It checks if each element in the array is a dictionary where the key is a string, and the value is another dictionary. This nested dictionary has a string as its key and a boolean as its value, then it appens it to the array.
+   The result can be fed to ``IOWalletProximity.generateResponse``.
+   
+   - Parameters:
+      - acceptedFields: A dictionary of any elements. In order to be added to the result dictionary each element must be shaped as ``AcceptedFieldsDict`` thus as [String: [String: [String: Bool]]]
+   
+   - Throws: `NSError` if a value doesn't has the ``AcceptedFieldsDict`` shape or the result dictionary is empty
+   
+   - Returns: An ``AcceptedFieldsDict`` containg the accepted fields to be presented
+   
+   */
+  private func parseAcceptedFields(acceptedFields: [AnyHashable: Any]) throws -> AcceptedFieldsDict {
+    var result: AcceptedFieldsDict = [:]
+    
+    for (key, value) in acceptedFields {
+      guard let keyString = key as? String else {
+        throw NSError(domain: "ParseAcceptedFields", code: -1, userInfo: [NSLocalizedDescriptionKey: "Key must be a String."])
+      }
+      guard let valueDict = value as? [String: [String: Bool]] else {
+        throw NSError(domain: "ParseAcceptedFields", code: -1, userInfo: [NSLocalizedDescriptionKey: "Value must be of type [String: [String: Bool]]."])
+      }
+      result[keyString] = valueDict
+    }
+    
+    if(result.isEmpty){
+      throw NSError(domain: "ParseAcceptedFields", code: -1, userInfo: [NSLocalizedDescriptionKey: "Error parsing documents"])
+    }
+    
+    return result
+  }
+  
+  /**
+     Generates a response containing the documents and the fields which the user decided to present.
+     It parses the untyped ``documents`` and ``acceptedFields`` parameters and feeds them to the ``IOWalletProximity.generateDeviceResponse`` function.
+     It resolves the promise with the response as a base64 encoded string.
+     It rejects the promise if an error occurs during the parameters parsing or while generating the device response.
+     
+     - Parameters:
+       - documents: An array containing documents. Each document is defined as a map containing:
+           - issuerSignedContent which is a base64 or base64url encoded string representing the credential;
+           - alias which is the alias of the key used to sign the credential;
+           - docType which is the document type.
+       - issuerSignedContent which is a base64 or base64url encoded string representing the credential;
+       - alias which is the alias of the key used to sign the credential;
+       - docType which is the document type.
+       - acceptedFields: A dictionary of elements, where each element must adhere to the structure of AcceptedFieldsDict—specifically, a [String: [String: [String: Bool]]]. The outermost key represents the credentia doctypel. The inner dictionary contains namespaces, and for each namespace, there is another dictionary mapping requested claims to a boolean value, which indicates whether the user is willing to present the corresponding claim. Example:
+        
+         
+             {
+                "org.iso.18013.5.1.mDL": {
+                  "org.iso.18013.5.1": {
+                    "hair_colour": true,
+                    "given_name_national_character": true,
+                    "family_name_national_character": true,
+                    "given_name": true,
+                  }
+                }
+             }
+    
+       - resolve: The promise to be resolved
+       - reject: The promise to be rejected
+     
+     */
+  @objc(generateResponse:withAcceptedFields:withResolver:withRejecter:)
+  func generateResponse(
+    documents: Array<Any>,
+    acceptedFields: [AnyHashable: Any],
+    _ resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
+  ){
+    do {
+      let parsedDocuments = try parseDocuments(documents: documents)
+      let items = try parseAcceptedFields(acceptedFields: acceptedFields)
+      let deviceResponse = try Proximity.shared.generateDeviceResponse(items: items, documents: parsedDocuments, sessionTranscript: nil)
+      let strDeviceResponse = Data(deviceResponse).base64EncodedString()
+      resolve(strDeviceResponse)
+    }catch{
+      ME.generateDeviceResponseError.reject(reject: reject, ("error", error.localizedDescription))
+    }
+  }
+  
+  /**
+   Sends a response containing the documents and the fields which the user decided to present generated by ``generateResponse``.
+   It resolves to true after sending the response, otherwise it rejects if an error occurs while decoding the response.
+   Currently there's not evidence of the verifier app responding to this request, thus we don't handle the response.
+   
+   - Parameters:
+     - response: A base64 encoded string containing the response generated by ``generateResponse``
+     - resolve: The promise to be resolved
+     - reject: The promise to be rejected
+   */
+  @objc(sendResponse:withResolver:withRejecter:)
+  func sendResponse(
+    response: String,
+    _ resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
+  ){
+    do{
+      if let responseData = Data(base64Encoded: response) {
+        let decodedResponse = [UInt8](responseData)
+        try Proximity.shared.dataPresentation(decodedResponse)
+        resolve(true)
+      }
+    }catch let error {
+      ME.sendResponseError.reject(reject: reject, ("error", error.localizedDescription))
+    }
+  }
+  
+  /**
+   Sends an error response during the presentation according to the SessionData status codes defined in table 20 of the ISO18013-5 standard.
+   - Parameters:
+     - status: The status error to be sent is an integer of type ``SessionDataStatus``:
+       ```
+         10 -> Error: session encryption
+         11 -> Error: CBOR decoding
+         20 -> Session termination
+       ```
+     - resolve: The promise to be resolved
+     - reject: The promise to be rejected
+   */
+  @objc(sendErrorResponse:withResolver:withRejecter:)
+  func sendErrorResponse(status: UInt64, _ resolve: @escaping RCTPromiseResolveBlock,
+                               reject: @escaping RCTPromiseRejectBlock){
+    do{
+      if let statusEnum = SessionDataStatus(rawValue: status) {
+        try Proximity.shared.errorPresentation(statusEnum)
+      } else {
+        ME.sendResponseError.reject(reject: reject, ("error", "Invalid status code"))
+      }
+      resolve(true)
+    }catch let error{
+      ME.sendResponseError.reject(reject: reject, ("error", error.localizedDescription))
+    }
+  }
+  
+  
+  /**
+   Closes the bluetooth connection and clears any resource.
+   It resolves to true after closing the connection.
+   
+   - Parameters:
+     - resolve: The promise to be resolved
+     - reject:  The promise to be rejected
+   
+   */
+  @objc(close:withRejecter:)
+  func close(
+    _ resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
+  ) {
+    Proximity.shared.stop()
+    resolve(true)
+  }
+  
+  /**
+     Converts a device requested from the `onDocumentRequestReceived` callback into a serializable JSON.
+     
+     - Parameters:
+        - request: The request returned from `onDocumentRequestReceived` which contains an array of tuples consists of a doctype, namespaces and the requested claims with a boolean value indicating wether or not the device which is making the request has an intent to retain the dataß
+     
+     - Returns: A JSON string representing the device request or nil if an error occurs
+    */
+  private func deviceRequestToJson(request: [(docType: String, nameSpaces: [String: [String: Bool]], isAuthenticated: Bool)]?) -> String? {
+    var jsonRequest : [String: AnyHashable] = [:]
+    request?.forEach({
+      item in
+      var subReq: [String: AnyHashable] = [:]
+      item.nameSpaces.keys.forEach({
+        nameSpace in
+        subReq[nameSpace] = item.nameSpaces[nameSpace]
+      })
+      
+      subReq["isAuthenticated"] = item.isAuthenticated
+      
+      jsonRequest[item.docType] = subReq
+    })
+    
+    let json: [String: AnyHashable] = [
+      "request": jsonRequest
+    ]
+    
+    if let jsonData = try? JSONSerialization.data(withJSONObject: json, options: .prettyPrinted),
+       let jsonString = String(data: jsonData, encoding: .utf8) {
+      return jsonString
+    } else {
+      return nil
+    }
+  }
+  
+  /**
+   Sets the proximity handler along with the possible dispatched events and their callbacks.
+   The events are then sent to React Native via `RCTEventEmitter`.
+   */
+  private func setupProximityHandler() {
+    Proximity.shared.proximityHandler = { [weak self] event in
+      guard let self = self else { return }
+      var eventName: String
+      var eventBody: [String: Any] = [:]
+      
+      switch event {
+      case .onDeviceConnecting:
+        eventName = "onDeviceConnecting"
+      case .onDeviceConnected:
+        eventName = "onDeviceConnected"
+      case .onDocumentRequestReceived(let request):
+        eventName = "onDocumentRequestReceived"
+        if let request = request {
+          /**
+           The outermost key represents the credential doctype, the inner key represents the namespace and the innermost key represents the requested fields with a boolean value. Example:
+           {
+             "org.iso.18013.5.1.mDL": {
+               "isAuthenticated": true,
+               "org.iso.18013.5.1": {
+                 "hair_colour": true,
+                 "given_name_national_character": true,
+                 "family_name_national_character": true,
+                 "given_name": true,
+               }
+             }
+           }
+           */
+          let jsonString = deviceRequestToJson(request: request)
+          // Here we either send the request or an empty string which signals that something went wrong.
+          eventBody = ["data": jsonString ?? ""]
+        }
+      case .onDeviceDisconnected:
+        eventName = "onDeviceDisconnected"
+      case .onError(let error):
+        eventName = "onError"
+        eventBody = ["error": error.localizedDescription]
+      default:
+        eventName = "unknown"
+        eventBody = ["error": "Received an unknown event"]
+      }
+      
+      self.sendEvent(withName: eventName, body: eventBody)
+    }
+  }
+  
+  @objc func generateOID4VPDeviceResponse(
+    _ clientId: String,
+    responseUri: String,
+    authorizationRequestNonce: String,
+    mdocGeneratedNonce: String,
+    documents: [Any],
+    fieldRequestedAndAccepted: String,
+    resolver resolve: RCTPromiseResolveBlock,
+    rejecter reject: RCTPromiseRejectBlock
+  ) {
+    
+    do {
+      let sessionTranscript = Proximity.shared.generateOID4VPSessionTranscriptCBOR(
+          clientId: clientId,
+          responseUri: responseUri,
+          authorizationRequestNonce: authorizationRequestNonce,
+          mdocGeneratedNonce: mdocGeneratedNonce
+      )
+
+      let documentsAsProximityDocument = try parseDocuments(documents: documents)
+      
+      let items = try JSONDecoder().decode([String : [String : [String : Bool]]].self, from: Data(fieldRequestedAndAccepted.utf8))
+      
+      do {
+        let response = try Proximity.shared.generateDeviceResponse(items: items, documents: documentsAsProximityDocument, sessionTranscript: sessionTranscript)
+        resolve(Data(response).base64EncodedString())
+      } catch {
+        ME.unableToGenerateResponse.reject(reject: reject)
+        return
+      }
+    } catch let error as NSError where error.domain == ME.invalidDocRequested.rawValue {
+      ME.invalidDocRequested.reject(reject: reject)
+    } catch _ as DecodingError {
+      ME.invalidItems.reject(reject: reject)
+    } catch {
+      ME.unexpected.reject(reject: reject)
+    }
+  }
+  
+  private class DocRequested {
+    var issuerSignedContent : [UInt8]
+    var alias : String
+    var docType : String
+    
+    public init(issuerSignedContent: [UInt8], alias: String, docType: String) {
+      self.issuerSignedContent = issuerSignedContent
+      self.alias = alias
+      self.docType = docType
+    }
+  }
+  
+  /**
+   Wrapper for rejecting with an error.
+   Add a new case in order to extend the possible errors.
+   */
+  private enum ModuleException: String, CaseIterable {
+    case startError = "START_ERROR"
+    case qrCodeError = "QR_CODE_ERROR"
+    case generateDeviceResponseError = "GENERATE_DEVICE_RESPONSE_ERROR"
+    case sendResponseError = "SEND_RESPONSE_ERROR"
+    case sendErrorResponse = "SEND_ERROR_RESPONSE_ERROR"
+    case invalidDocRequested = "DOC_REQUESTED_PARSING_ERROR"
+    case unableToGenerateResponse = "UNABLE_TO_GENERATE_RESPONSE_ERROR"
+    case invalidItems = "REQUESTED_ITEMS_PARSING_ERROR"
+    case unexpected = "UNEXPECTED_ERROR"
+    case unableToDecode = "UNABLE_TO_DECODE"
+    
+    func error(
+      userInfo: [String : Any]? = nil
+    ) -> NSError {
+      switch self {
+      case .startError:
+        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
+      case .qrCodeError:
+        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
+      case .generateDeviceResponseError:
+        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
+      case .sendResponseError:
+        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
+      case .sendErrorResponse:
+        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
+      case .invalidDocRequested:
+        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
+      case .unableToGenerateResponse:
+        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
+      case .invalidItems:
+        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
+      case .unexpected:
+        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
+      case .unableToDecode:
+        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
+      }
+    }
+    
+     /**
+      Rejects the provided promise with the appropriate error message and additional data.
+      
+      - Parameters:
+        - reject:  the promise to be rejected.
+        - moreUserInfo: additional key-value pairs of data to be passed along with the error.
+      
+      */
+    func reject(
+      reject: RCTPromiseRejectBlock,
+      _ moreUserInfo: (String, Any)...
+    ) {
+      let userInfo = [String: Any](uniqueKeysWithValues: moreUserInfo)
+      let error = error(userInfo: userInfo)
+      reject("\(error.code)", error.domain, error)
+    }
+  }
+}

package/lib/module/cbor/cbor/README.md

@@ -0,0 +1,95 @@
+## CBOR
+
+This module provides methods to decode CBOR data into readable objects.
+
+```typescript
+import { CBOR } from '@pagopa/io-react-native-cbor';
+```
+
+### Methods
+
+#### `decode`
+
+This method allows to decode CBOR data into readable JSON objects.
+Returns a `Promise` which resolves to a JSON object, or rejects with an instance of `CborFailure` in case of failure.
+
+**Note**: this method does not decode nested CBOR objects and therefore complex objects needs additional manual decoding
+
+```typescript
+try {
+  const decoded = await CBOR.decode('...');
+} catch (e) {
+  const { message, userInfo } = e as CborFailure;
+}
+```
+
+#### `decodeDocuments`
+
+This metod allows the decoding of CBOR data which contains MDOC objects.
+Returns a promise wich resolves to a [Documents](#documents) object, or rejects with an instance of `CborFailure` in case of failure.
+
+```typescript
+try {
+  const decoded = await CBOR.decodeDocuments('...');
+} catch (e) {
+  const { message, userInfo } = e as CborFailure;
+}
+```
+
+### Types
+
+#### `Documents`
+
+```typescript
+type Documents = {
+  status?: number;
+  version?: string;
+  documents?: Array<MDOC>;
+};
+```
+
+#### `MDOC`
+
+```typescript
+type MDOC = {
+  docType?: DocumentType;
+  issuerSigned?: IssuerSigned;
+};
+```
+
+#### `IssuerSigned`
+
+```typescript
+type IssuerSigned = {
+  nameSpaces?: Record<string, Array<DocumentValue>>;
+  issuerAuth?: string;
+};
+```
+
+#### `DocumentValue`
+
+```typescript
+type DocumentValue = {
+  digestID?: number;
+  random?: string;
+  elementIdentifier?: string;
+  elementValue?: string;
+};
+```
+
+#### `DocumentType`
+
+```typescript
+enum DocumentTypeEnum {
+  MDL = 'org.iso.18013.5.1.mDL',
+  EU_PID = 'eu.europa.ec.eudi.pid.1',
+}
+```
+
+### Error Codes
+
+| Type              | Platform    | Description                                   |
+| ----------------- | ----------- | --------------------------------------------- |
+| INVALID_ENCODING  | Android/iOS | Provided payload has incorrect encoding       |
+| UNABLE_TO_DECODE  | Android/iOS | The data does not contain a valid CBOR object |
+| UNKNOWN_EXCEPTION | Android/iOS | Unexpected failure                            |

package/lib/module/cbor/cbor/decoder.js

@@ -0,0 +1,51 @@
+"use strict";
+
+import { IoReactNativeCbor } from "../index.js";
+import { DocumentsFromString, IssuerSignedFromString } from "./schema.js";
+import { coerceToJSON } from "./schema.utils.js";
+
+/**
+ * Decode base64 encoded CBOR data to JSON object.
+ *
+ * If it is not possibile to decode the provided data, the promise will be rejected with
+ * an instance of {@link CborFailure}.
+ *
+ * **NOTE**: this method does not handle nested CBOR data, which will need additional
+ * parsing.
+ *
+ * @param data - The base64 or base64url encoded CBOR data
+ * @returns The decoded data as JSON object
+ */
+export const decode = async data => {
+  const jsonString = await IoReactNativeCbor.decode(data);
+  return await coerceToJSON.parseAsync(jsonString);
+};
+
+/**
+ * Decode base64 or base64url encoded CBOR data to mDOC object
+ *
+ * If it is not possibile to decode the provided data, the promise will be rejected with
+ * an instance of {@link CborFailure}.
+ *
+ * @param data - The base64 encoded MDOC data
+ * @returns The decoded data as mDOC object
+ */
+export const decodeDocuments = async data => {
+  const documentsString = await IoReactNativeCbor.decodeDocuments(data);
+  return await DocumentsFromString.parseAsync(documentsString);
+};
+
+/**
+ * Extract and decode the {@link IssuerSigned} with the {@link IssuerAuth} decoded from base64 encoded CBOR
+ *
+ * If it is not possibile to decode the provided data, the promise will be rejected with
+ * an instance of {@link CborFailure}.
+ *
+ * @param issuerSigned - The base64 or base64url encoded MDOC data
+ * @returns The decoded {@link IssuerSigned} contained in the mDOC object
+ */
+export const decodeIssuerSigned = async issuerSigned => {
+  const decodedIssuerSignedString = await IoReactNativeCbor.decodeIssuerSigned(issuerSigned);
+  return await IssuerSignedFromString.parseAsync(decodedIssuerSignedString);
+};
+//# sourceMappingURL=decoder.js.map

package/lib/module/cbor/cbor/decoder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["IoReactNativeCbor","DocumentsFromString","IssuerSignedFromString","coerceToJSON","decode","data","jsonString","parseAsync","decodeDocuments","documentsString","decodeIssuerSigned","issuerSigned","decodedIssuerSignedString"],"sourceRoot":"../../../../src","sources":["cbor/cbor/decoder.ts"],"mappings":";;AAAA,SAASA,iBAAiB,QAAQ,aAAI;AACtC,SAEEC,mBAAmB,EAEnBC,sBAAsB,QACjB,aAAU;AACjB,SAASC,YAAY,QAAQ,mBAAgB;;AAE7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,MAAM,GAAG,MAAOC,IAAY,IAAmB;EAC1D,MAAMC,UAAU,GAAG,MAAMN,iBAAiB,CAACI,MAAM,CAACC,IAAI,CAAC;EACvD,OAAO,MAAMF,YAAY,CAACI,UAAU,CAACD,UAAU,CAAC;AAClD,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAME,eAAe,GAAG,MAAOH,IAAY,IAAyB;EACzE,MAAMI,eAAe,GAAG,MAAMT,iBAAiB,CAACQ,eAAe,CAACH,IAAI,CAAC;EACrE,OAAO,MAAMJ,mBAAmB,CAACM,UAAU,CAACE,eAAe,CAAC;AAC9D,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,kBAAkB,GAAG,MAChCC,YAAoB,IACM;EAC1B,MAAMC,yBAAyB,GAC7B,MAAMZ,iBAAiB,CAACU,kBAAkB,CAACC,YAAY,CAAC;EAC1D,OAAO,MAAMT,sBAAsB,CAACK,UAAU,CAACK,yBAAyB,CAAC;AAC3E,CAAC","ignoreList":[]}

package/lib/module/cbor/cbor/failure.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=failure.js.map

package/lib/module/cbor/cbor/failure.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../../src","sources":["cbor/cbor/failure.ts"],"mappings":"","ignoreList":[]}

package/lib/module/cbor/cbor/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export { decode, decodeDocuments, decodeIssuerSigned } from "./decoder.js";
+export { DocumentValue, Documents, DocumentsFromString, IssuerSigned, MDOC } from "./schema.js";
+//# sourceMappingURL=index.js.map

package/lib/module/cbor/cbor/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["decode","decodeDocuments","decodeIssuerSigned","DocumentValue","Documents","DocumentsFromString","IssuerSigned","MDOC"],"sourceRoot":"../../../../src","sources":["cbor/cbor/index.ts"],"mappings":";;AAAA,SAASA,MAAM,EAAEC,eAAe,EAAEC,kBAAkB,QAAQ,cAAW;AACvE,SACEC,aAAa,EACbC,SAAS,EACTC,mBAAmB,EACnBC,YAAY,EACZC,IAAI,QACC,aAAU","ignoreList":[]}