@sphereon/did-provider-oyd 0.28.1-feature.jose.vcdm.52 → 0.28.1-feature.oyd.cmsm.improv.20

package/src/oyd-did-provider.ts

@@ -1,4 +1,3 @@
-import { importProvidedOrGeneratedKey } from '@sphereon/ssi-sdk-ext.key-utils'
 import { IAgentContext, IIdentifier, IKey, IKeyManager, IService, TKeyType } from '@veramo/core'
 import { AbstractIdentifierProvider } from '@veramo/did-manager'
 import { KeyManager } from '@veramo/key-manager'
@@ -6,7 +5,6 @@ import fetch from 'cross-fetch'
 import Multibase from 'multibase'
 import Multicodec from 'multicodec'
 
-// @ts-ignore
 import * as u8a from 'uint8arrays'
 
 import Debug from 'debug'
@@ -14,9 +12,9 @@ import type {
   CMSMCallbackOpts,
   OydConstructorOptions,
   OydCreateIdentifierOptions,
-  // OydDidHoldKeysArgs,
+  OydDidHoldKeysArgs,
   OydDidSupportedKeyTypes,
-} from './types/oyd-provider-types'
+} from './types/oyd-provider-types.js'
 
 const debug = Debug('veramo:oyd-did:identifier-provider')
 const OYDID_REGISTRAR_URL = 'https://oydid-registrar.data-container.net/1.0/createIdentifier'
@@ -49,7 +47,7 @@ export class OydDIDProvider extends AbstractIdentifierProvider {
   }
 
   async createIdentifier(
-    { kms, alias, options }: { kms?: string; alias?: string; options: OydCreateIdentifierOptions },
+    { kms, options }: { kms?: string; options: OydCreateIdentifierOptions },
     context: IContext
   ): Promise<Omit<IIdentifier, 'provider'>> {
     const resolvedKms = await this.assertedKms(kms, this.defaultKms)
@@ -64,7 +62,7 @@ export class OydDIDProvider extends AbstractIdentifierProvider {
     const body = {
       options: {
         cmsm: false,
-        key_type: options.type ?? 'Secp256r1',
+        key_type: options.keyType ?? 'Secp256r1',
       },
     }
     let didDoc: any | undefined
@@ -86,18 +84,15 @@ export class OydDIDProvider extends AbstractIdentifierProvider {
       return Promise.reject(Error('There has been a problem with the fetch operation: ' + error.toString()))
     }
 
-    const keyType: OydDidSupportedKeyTypes = options?.type ?? 'Secp256r1'
-    const key = await importProvidedOrGeneratedKey(
+    const keyType: OydDidSupportedKeyTypes = options?.keyType ?? 'Secp256r1'
+    const key = await this.importOrCreateKey(
       {
         kms: resolvedKms,
-        alias: alias ?? options.alias ?? options.kid ?? `${didDoc.did}#key-doc`,
         options: {
-          key: {
-            kid: `${didDoc.did}#key-doc`,
-            type: keyType,
-            publicKeyHex: didDoc.keys[0].publicKeyHex,
-            privateKeyHex: didDoc.keys[0].privateKeyHex,
-          },
+          keyType,
+          kid: didDoc.did + '#key-doc',
+          publicKeyHex: didDoc.keys[0].publicKeyHex,
+          privateKeyHex: didDoc.keys[0].privateKeyHex,
         },
       },
       context
@@ -124,10 +119,11 @@ export class OydDIDProvider extends AbstractIdentifierProvider {
 
     const assertedKms = await this.assertedKms(kms, this.defaultKms)
     const pubKey =
-      options.key ?? (await cmsmCallbackOpts.publicKeyCallback(options.kid ?? 'default', assertedKms, options.cmsm?.create !== false, options.type)) // "default" is probably not right, TODO!!
+      options.key ??
+      (await cmsmCallbackOpts.publicKeyCallback(options.kid ?? 'default', assertedKms, options.cmsm?.create !== false, options.keyType)) // "default" is probably not right, TODO!!
     const kid = pubKey.kid
     const keyType = pubKey.type
-    const key = base58btc({ publicKeyHex: pubKey.publicKeyHex, keyType })
+    const key = base58btc({publicKeyHex: pubKey.publicKeyHex, keyType})
 
     console.log(`Bae58 pubkey key: ${key}`)
     let signValue: any | undefined // do the request
@@ -165,6 +161,8 @@ export class OydDIDProvider extends AbstractIdentifierProvider {
 
     console.log(`Signature: ${signature}`)
 
+
+
     const body_signed = {
       key,
       options: {
@@ -197,6 +195,24 @@ export class OydDIDProvider extends AbstractIdentifierProvider {
       return Promise.reject(Error('There has been a problem with the fetch operation: ' + error.toString()))
     }
 
+    /*    let oydKeyType: OydDidSupportedKeyTypes = "Secp256r1";
+
+        const key = await this.holdKeys(
+          {
+            kms: assertedKms,
+            options: {
+              keyType: oydKeyType,
+              kid: kid,
+              publicKeyHex: pubKey.publicKeyHex,
+            },
+          },
+          context
+        );*/
+
+
+
+
+
     const identifier: Omit<IIdentifier, 'provider'> = {
       did: didDoc.did,
       controllerKeyId: pubKey.kid,
@@ -236,6 +252,31 @@ export class OydDIDProvider extends AbstractIdentifierProvider {
   async removeService(args: { identifier: IIdentifier; id: string; options?: any }, context: IContext): Promise<any> {
     return { success: true }
   }
+
+  private async importOrCreateKey(args: OydDidHoldKeysArgs, context: IContext): Promise<IKey> {
+    const kms = await this.assertedKms(args.kms, this.defaultKms)
+    if (args.options.privateKeyHex) {
+      return context.agent.keyManagerImport({
+        kms,
+        type: args.options.keyType,
+        kid: args.options.kid,
+        privateKeyHex: args.options.privateKeyHex,
+        /*meta: {
+          algorithms: ['Secp256r1'],
+        },*/
+      })
+    }
+    return context.agent.keyManagerCreate({
+      type: args.options.keyType,
+      kms,
+      meta: {
+        algorithms: ['Secp256r1'],
+      },
+    })
+  }
+
+
+
 }
 
 const keyCodecs = {
@@ -248,15 +289,17 @@ const keyCodecs = {
   Bls12381G2: 'bls12_381-g2-pub',
 } as const
 
-const base58btc = ({ publicKeyHex, keyType = 'Secp256r1' }: { publicKeyHex: string; keyType?: TKeyType }): string => {
+const base58btc = ({publicKeyHex, keyType = 'Secp256r1'}:{publicKeyHex: string, keyType?: TKeyType}): string => {
   const codecName = keyCodecs[keyType]
 
+
   // methodSpecificId  = bytesToMultibase({bytes: u8a.fromString(key.publicKeyHex, 'hex'), codecName})
   return u8a
-    .toString(Multibase.encode('base58btc', Multicodec.addPrefix(codecName as Multicodec.CodecName, u8a.fromString(publicKeyHex, 'hex'))))
+    .toString(
+      Multibase.encode('base58btc', Multicodec.addPrefix(codecName as Multicodec.CodecName, u8a.fromString(publicKeyHex, 'hex')))
+    )
     .toString()
 }
-
 export function defaultOydCmsmPublicKeyCallback(
   keyManager: KeyManager
 ): (kid: string, kms?: string, create?: boolean, createKeyType?: TKeyType) => Promise<IKey> {
@@ -271,27 +314,7 @@ export function defaultOydCmsmPublicKeyCallback(
       if (!kms) {
         return Promise.reject(Error('No KMS provided, whilst creating a new key!'))
       }
-      const alias = kid ?? `oyd-${new Date().toISOString()}`
-
-      const agent = keyManager
-      const key = await importProvidedOrGeneratedKey(
-        {
-          kms,
-          alias,
-          options: {
-            key: {
-              type: createKeyType ?? 'Secp256r1',
-            },
-          },
-        },
-        {
-          //@ts-ignore
-          agent,
-        }
-      )
-      return key
-
-      // return await keyManager.keyManagerCreate({ kms, type: createKeyType ?? 'Secp256r1' })
+      return await keyManager.keyManagerCreate({ kms, type: createKeyType ?? 'Secp256r1' })
     }
     return Promise.reject(Error('No existing key found, and create is false!'))
   }
@@ -304,17 +327,11 @@ export function defaultOydCmsmSignCallback(keyManager: KeyManager): (kid: string
 }
 
 export class DefaultOydCmsmCallbacks implements CMSMCallbackOpts {
-  private readonly keyManager: KeyManager
+  constructor(private keyManager: KeyManager) {}
 
-  constructor(keyManager: KeyManager) {
-    this.keyManager = keyManager
-  }
+  publicKeyCallback: (kid: string, kms?: string, create?: boolean, createKeyType?: TKeyType) => Promise<IKey> = defaultOydCmsmPublicKeyCallback(
+    this.keyManager
+  )
 
-  publicKeyCallback(kid: string, kms?: string, create?: boolean, createKeyType?: TKeyType): Promise<IKey> {
-    return defaultOydCmsmPublicKeyCallback(this.keyManager)(kid, kms, create, createKeyType)
-  }
-
-  signCallback(kid: string, value: string): Promise<string> {
-    return defaultOydCmsmSignCallback(this.keyManager)(kid, value)
-  }
+  signCallback: (kid: string, value: string) => Promise<string> = defaultOydCmsmSignCallback(this.keyManager)
 }

package/src/types/oyd-provider-types.ts

@@ -1,49 +1,49 @@
 import { IKey, TKeyType } from '@veramo/core'
 
 export type OydConstructorOptions = {
-  defaultKms?: string
-  clientManagedSecretMode?: CMSMCallbackOpts
+  defaultKms?: string;
+  clientManagedSecretMode?: CMSMCallbackOpts;
 }
 
 export type OydCreateIdentifierOptions = {
-  type?: OydDidSupportedKeyTypes
-  privateKeyHex?: string
-  kid?: string
-  alias?: string
-  keyUse?: KeyUse
-  cmsm?: CmsmOptions
+  keyType?: OydDidSupportedKeyTypes;
+  privateKeyHex?: string;
+  kid?: string;
+  keyUse?: KeyUse;
+  cmsm?: CmsmOptions;
   key?: IKey // Use the supplied key instead of looking it up in the KMS or creating a new one
 }
 
+
 export type CmsmOptions = {
   enabled: boolean
   create?: boolean
 }
 
 export type OydDidHoldKeysArgs = {
-  kms?: string
-  options: HoldKeysOpts
+  kms?: string;
+  options: HoldKeysOpts;
 }
 
 type HoldKeysOpts = {
-  keyType: OydDidSupportedKeyTypes
-  kid: string
-  publicKeyHex?: string
-  privateKeyHex?: string
+  keyType: OydDidSupportedKeyTypes;
+  kid: string;
+  publicKeyHex?: string;
+  privateKeyHex?: string;
 }
 
 export type CMSMCallbackOpts = {
-  publicKeyCallback: (kid: string, kms?: string, create?: boolean, createKeyType?: TKeyType) => Promise<IKey>
-  signCallback: (kid: string, value: string) => Promise<string>
+  publicKeyCallback: (kid: string, kms?: string, create?: boolean, createKeyType?: TKeyType) => Promise<IKey>;
+  signCallback: (kid: string, value: string) => Promise<string>;
 }
 
-enum SupportedKeyTypes {
+export enum SupportedKeyTypes {
   Secp256r1 = 'Secp256r1',
   Secp256k1 = 'Secp256k1',
   Ed25519 = 'Ed25519',
   X25519 = 'X25519',
 }
 
-export type OydDidSupportedKeyTypes = keyof typeof SupportedKeyTypes
+export type OydDidSupportedKeyTypes = keyof typeof SupportedKeyTypes;
 
-export type KeyUse = 'sig' | 'enc'
+export type KeyUse = 'sig' | 'enc';

package/dist/index.cjs

@@ -1,356 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  DefaultOydCmsmCallbacks: () => DefaultOydCmsmCallbacks,
-  OydDIDProvider: () => OydDIDProvider,
-  defaultOydCmsmPublicKeyCallback: () => defaultOydCmsmPublicKeyCallback,
-  defaultOydCmsmSignCallback: () => defaultOydCmsmSignCallback,
-  getDidOydResolver: () => getDidOydResolver
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/oyd-did-provider.ts
-var import_ssi_sdk_ext = require("@sphereon/ssi-sdk-ext.key-utils");
-var import_did_manager = require("@veramo/did-manager");
-var import_cross_fetch = __toESM(require("cross-fetch"), 1);
-var import_multibase = __toESM(require("multibase"), 1);
-var import_multicodec = __toESM(require("multicodec"), 1);
-var u8a = __toESM(require("uint8arrays"), 1);
-var import_debug = __toESM(require("debug"), 1);
-var debug = (0, import_debug.default)("veramo:oyd-did:identifier-provider");
-var OYDID_REGISTRAR_URL = "https://oydid-registrar.data-container.net/1.0/createIdentifier";
-var OydDIDProvider = class extends import_did_manager.AbstractIdentifierProvider {
-  static {
-    __name(this, "OydDIDProvider");
-  }
-  defaultKms;
-  cmsmCallbackOpts;
-  constructor(options) {
-    super();
-    this.defaultKms = options?.defaultKms;
-    this.cmsmCallbackOpts = options?.clientManagedSecretMode;
-  }
-  async assertedKms(...kms) {
-    if (!kms || kms.length === 0) {
-      return Promise.reject(Error("KMS must be provided either as a parameter or via defaultKms."));
-    }
-    const result = kms.find((k) => !!k);
-    if (!result) {
-      return Promise.reject(Error("KMS must be provided either as a parameter or via defaultKms."));
-    }
-    return result;
-  }
-  async createIdentifier({ kms, alias, options }, context) {
-    const resolvedKms = await this.assertedKms(kms, this.defaultKms);
-    if (this.cmsmCallbackOpts && !options.cmsm || options.cmsm && options.cmsm.enabled !== false) {
-      if (!this.cmsmCallbackOpts) {
-        return Promise.reject(Error("did:oyd: no cmsm options defined on oyd did provider, but cmsm was enabled on the call!"));
-      }
-      return await this.createIdentifierWithCMSM({
-        kms: resolvedKms,
-        options
-      }, context);
-    }
-    const body = {
-      options: {
-        cmsm: false,
-        key_type: options.type ?? "Secp256r1"
-      }
-    };
-    let didDoc;
-    try {
-      const response = await (0, import_cross_fetch.default)(OYDID_REGISTRAR_URL, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(body)
-      });
-      if (!response.ok) {
-        debug("Error response from OydDID Registrar: ", response);
-        return Promise.reject(Error("Network response was not ok: " + response.statusText));
-      }
-      didDoc = await response.json();
-    } catch (error) {
-      debug("Unexpected error from OydDID Registrar: ", error);
-      return Promise.reject(Error("There has been a problem with the fetch operation: " + error.toString()));
-    }
-    const keyType = options?.type ?? "Secp256r1";
-    const key = await (0, import_ssi_sdk_ext.importProvidedOrGeneratedKey)({
-      kms: resolvedKms,
-      alias: alias ?? options.alias ?? options.kid ?? `${didDoc.did}#key-doc`,
-      options: {
-        key: {
-          kid: `${didDoc.did}#key-doc`,
-          type: keyType,
-          publicKeyHex: didDoc.keys[0].publicKeyHex,
-          privateKeyHex: didDoc.keys[0].privateKeyHex
-        }
-      }
-    }, context);
-    const identifier = {
-      did: didDoc.did,
-      controllerKeyId: key.kid,
-      keys: [
-        key
-      ],
-      services: []
-    };
-    debug("Created", identifier.did);
-    return identifier;
-  }
-  async createIdentifierWithCMSM({ kms, options }, context) {
-    const cmsmCallbackOpts = this.cmsmCallbackOpts;
-    if (!cmsmCallbackOpts) {
-      return Promise.reject(Error("did:oyd: no cmsm options defined!"));
-    }
-    const assertedKms = await this.assertedKms(kms, this.defaultKms);
-    const pubKey = options.key ?? await cmsmCallbackOpts.publicKeyCallback(options.kid ?? "default", assertedKms, options.cmsm?.create !== false, options.type);
-    const kid = pubKey.kid;
-    const keyType = pubKey.type;
-    const key = base58btc({
-      publicKeyHex: pubKey.publicKeyHex,
-      keyType
-    });
-    console.log(`Bae58 pubkey key: ${key}`);
-    let signValue;
-    try {
-      const body_create = {
-        // specify the Identifier options for the registrar
-        key,
-        options: {
-          cmsm: true,
-          key_type: keyType
-        }
-      };
-      console.log(`Create request:
-${JSON.stringify(body_create, null, 2)}
-`);
-      const response = await (0, import_cross_fetch.default)(OYDID_REGISTRAR_URL, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(body_create)
-      });
-      if (!response.ok) {
-        debug("Error response from OydDID Registrar: ", body_create, response);
-        return Promise.reject(Error("Network response was not ok: " + response.statusText));
-      }
-      signValue = await response.json();
-      console.log(`Create response:
-${JSON.stringify(signValue, null, 2)}
-`);
-    } catch (error) {
-      console.log("Unexpected error from OydDID Registrar: ", error);
-      return Promise.reject(Error("There has been a problem with the fetch operation: " + error.toString()));
-    }
-    const { sign } = signValue;
-    const signature = await cmsmCallbackOpts.signCallback(kid, sign);
-    console.log(`Signature: ${signature}`);
-    const body_signed = {
-      key,
-      options: {
-        cmsm: true,
-        key_type: keyType,
-        sig: signature
-      }
-    };
-    console.log(`Signed request:
-${JSON.stringify(body_signed, null, 2)}
-`);
-    let didDoc;
-    try {
-      const response = await (0, import_cross_fetch.default)(OYDID_REGISTRAR_URL, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(body_signed)
-      });
-      if (!response.ok) {
-        console.log(`Error response from OydDID Registrar: ${JSON.stringify(response.text)}${response.statusText}`, response);
-        debug("Error response from OydDID Registrar: ", response);
-        return Promise.reject(Error("Network response was not ok: " + response.statusText));
-      }
-      didDoc = await response.json();
-    } catch (error) {
-      debug("Unexpected error from OydDID Registrar: ", error);
-      return Promise.reject(Error("There has been a problem with the fetch operation: " + error.toString()));
-    }
-    const identifier = {
-      did: didDoc.did,
-      controllerKeyId: pubKey.kid,
-      keys: [
-        pubKey
-      ],
-      services: []
-    };
-    debug("Created", identifier.did);
-    return identifier;
-  }
-  async updateIdentifier(args, context) {
-    throw new Error("OydDIDProvider updateIdentifier not supported yet.");
-  }
-  async deleteIdentifier(identifier, context) {
-    for (const { kid } of identifier.keys) {
-      await context.agent.keyManagerDelete({
-        kid
-      });
-    }
-    return true;
-  }
-  async addKey({ identifier, key, options }, context) {
-    return {
-      success: true
-    };
-  }
-  async addService({ identifier, service, options }, context) {
-    return {
-      success: true
-    };
-  }
-  async removeKey(args, context) {
-    return {
-      success: true
-    };
-  }
-  async removeService(args, context) {
-    return {
-      success: true
-    };
-  }
-};
-var keyCodecs = {
-  RSA: "rsa-pub",
-  Ed25519: "ed25519-pub",
-  X25519: "x25519-pub",
-  Secp256k1: "secp256k1-pub",
-  Secp256r1: "p256-pub",
-  Bls12381G1: "bls12_381-g1-pub",
-  Bls12381G2: "bls12_381-g2-pub"
-};
-var base58btc = /* @__PURE__ */ __name(({ publicKeyHex, keyType = "Secp256r1" }) => {
-  const codecName = keyCodecs[keyType];
-  return u8a.toString(import_multibase.default.encode("base58btc", import_multicodec.default.addPrefix(codecName, u8a.fromString(publicKeyHex, "hex")))).toString();
-}, "base58btc");
-function defaultOydCmsmPublicKeyCallback(keyManager) {
-  return async (kid, kms, create, createKeyType) => {
-    try {
-      const existing = await keyManager.keyManagerGet({
-        kid
-      });
-      if (existing) {
-        return existing;
-      }
-    } catch (error) {
-    }
-    if (create) {
-      if (!kms) {
-        return Promise.reject(Error("No KMS provided, whilst creating a new key!"));
-      }
-      const alias = kid ?? `oyd-${(/* @__PURE__ */ new Date()).toISOString()}`;
-      const agent = keyManager;
-      const key = await (0, import_ssi_sdk_ext.importProvidedOrGeneratedKey)({
-        kms,
-        alias,
-        options: {
-          key: {
-            type: createKeyType ?? "Secp256r1"
-          }
-        }
-      }, {
-        //@ts-ignore
-        agent
-      });
-      return key;
-    }
-    return Promise.reject(Error("No existing key found, and create is false!"));
-  };
-}
-__name(defaultOydCmsmPublicKeyCallback, "defaultOydCmsmPublicKeyCallback");
-function defaultOydCmsmSignCallback(keyManager) {
-  return async (kid, data) => {
-    return keyManager.keyManagerSign({
-      keyRef: kid,
-      data,
-      encoding: "utf-8"
-    });
-  };
-}
-__name(defaultOydCmsmSignCallback, "defaultOydCmsmSignCallback");
-var DefaultOydCmsmCallbacks = class {
-  static {
-    __name(this, "DefaultOydCmsmCallbacks");
-  }
-  keyManager;
-  constructor(keyManager) {
-    this.keyManager = keyManager;
-  }
-  publicKeyCallback(kid, kms, create, createKeyType) {
-    return defaultOydCmsmPublicKeyCallback(this.keyManager)(kid, kms, create, createKeyType);
-  }
-  signCallback(kid, value) {
-    return defaultOydCmsmSignCallback(this.keyManager)(kid, value);
-  }
-};
-
-// src/resolver.ts
-var import_cross_fetch2 = __toESM(require("cross-fetch"), 1);
-var resolveDidOyd = /* @__PURE__ */ __name(async (didUrl, _parsed, _resolver, options) => {
-  try {
-    const baseUrl = "https://oydid-resolver.data-container.net";
-    const response = await (0, import_cross_fetch2.default)(`${baseUrl}/1.0/identifiers/${didUrl}`);
-    if (!response.ok) {
-      throw new Error("Network response was not ok: " + response.statusText);
-    }
-    const didDoc = await response.json();
-    return didDoc;
-  } catch (err) {
-    return {
-      didDocumentMetadata: {},
-      didResolutionMetadata: {
-        error: "invalidDid",
-        message: err.toString()
-      },
-      didDocument: null
-    };
-  }
-}, "resolveDidOyd");
-function getDidOydResolver() {
-  return {
-    oyd: resolveDidOyd
-  };
-}
-__name(getDidOydResolver, "getDidOydResolver");
-//# sourceMappingURL=index.cjs.map