@suveren/gateway 0.40.0 → 0.41.1

package/node_modules/@hap/core/node_modules/@hpke/core/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Ajitomi Daisuke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@hap/core/node_modules/@hpke/core/README.md

@@ -0,0 +1,263 @@
+<h1 align="center">@hpke/core</h1>
+
+<div align="center">
+<a href="https://www.npmjs.com/package/@hpke/core"><img src="https://img.shields.io/npm/v/@hpke/core" alt="npm"/></a>
+<a href="https://jsr.io/@hpke/core"><img src="https://jsr.io/badges/@hpke/core" alt="JSR"/></a>
+</div>
+
+<div align="center">
+A TypeScript <a href="https://datatracker.ietf.org/doc/html/rfc9180">Hybrid Public Key Encryption (HPKE)</a> core module implemented using only <a href="https://www.w3.org/TR/WebCryptoAPI/">Web Cryptography API</a>. It does not support the X448-based KEM and the ChaCha20Poly1305 AEAD, but it has no external module dependencies. It's small in size and tree-shaking friendly.</div>
+<p></p>
+
+<div align="center">
+
+Documentation: [jsr.io](https://jsr.io/@hpke/core/doc) |
+[pages (only for the latest ver.)](https://dajiaji.github.io/hpke-js/core/docs/)
+
+</div>
+
+## Index
+
+- [Installation](#installation)
+  - [Node.js](#nodejs)
+  - [Deno](#deno)
+  - [Web Browsers](#web-browsers)
+- [Usage](#usage)
+- [Contributing](#contributing)
+
+## Installation
+
+Where possible, it is recommended to use `@hpke/core` along with extension
+modules (such as `@hpke/chacha20poly1305`) instead of `hpke-js`.
+
+### Node.js
+
+You can install the package with npm, yarn or pnpm.
+
+```sh
+# Using npm:
+npm install @hpke/core
+yarn add @hpke/core
+pnpm install @hpke/core
+# Using jsr:
+npx jsr add @hpke/core
+yarn add jsr:@hpke/core
+pnpm add jsr:@hpke/core
+```
+
+The above manner can be used with other JavaScript runtimes that support npm,
+such as Cloudflare Workers and Bun.
+
+Then, you can use the module from code like this:
+
+```ts
+import {
+  Aes128Gcm,
+  CipherSuite,
+  DhkemP256HkdfSha256,
+  HkdfSha256,
+} from "@hpke/core";
+```
+
+### Deno
+
+For Deno, it is recommended to use the jsr.io registry.
+
+```sh
+deno add jsr:@hpke/core
+```
+
+### Web Browsers
+
+Followings are how to use this module with typical CDNs. Other CDNs can be used
+as well.
+
+Using esm.sh:
+
+```html
+<!-- use a specific version -->
+<script type="module">
+  import {
+    Aes128Gcm,
+    CipherSuite,
+    DhkemP256HkdfSha256,
+    HkdfSha256,
+  } from "https://esm.sh/@hpke/core@<SEMVER>";
+  // ...
+</script>
+
+<!-- use the latest stable version -->
+<script type="module">
+  import {
+    Aes128Gcm,
+    CipherSuite,
+    DhkemP256HkdfSha256,
+    HkdfSha256,
+  } from "https://esm.sh/@hpke/core";
+  // ...
+</script>
+```
+
+Using unpkg:
+
+```html
+<!-- use a specific version -->
+<script type="module">
+  import * as hpke from "https://unpkg.com/@hpke/core@<SEMVER>/esm/mod.js";
+  // ...
+</script>
+```
+
+## Usage
+
+This section shows some typical usage examples.
+
+### Node.js
+
+```js
+import {
+  Aes128Gcm,
+  CipherSuite,
+  DhkemP256HkdfSha256,
+  HkdfSha256,
+} from "@hpke/core";
+
+async function doHpke() {
+  // setup
+  const suite = new CipherSuite({
+    kem: new DhkemP256HkdfSha256(),
+    kdf: new HkdfSha256(),
+    aead: new Aes128Gcm(),
+  });
+
+  const rkp = await suite.kem.generateKeyPair();
+
+  const sender = await suite.createSenderContext({
+    recipientPublicKey: rkp.publicKey,
+  });
+
+  const recipient = await suite.createRecipientContext({
+    recipientKey: rkp.privateKey,
+    enc: sender.enc,
+  });
+
+  // encrypt
+  const ct = await sender.seal(new TextEncoder().encode("Hello world!"));
+
+  // decrypt
+  const pt = await recipient.open(ct);
+
+  // Hello world!
+  console.log(new TextDecoder().decode(pt));
+}
+
+try {
+  doHpke();
+} catch (err) {
+  console.log("failed:", err.message);
+}
+```
+
+### Deno
+
+```ts
+import {
+  Aes128Gcm,
+  CipherSuite,
+  DhkemP256HkdfSha256,
+  HkdfSha256,
+} from "@hpke/core";
+
+async function doHpke() {
+  // setup
+  const suite = new CipherSuite({
+    kem: new DhkemP256HkdfSha256(),
+    kdf: new HkdfSha256(),
+    aead: new Aes128Gcm(),
+  });
+
+  const rkp = await suite.kem.generateKeyPair();
+
+  const sender = await suite.createSenderContext({
+    recipientPublicKey: rkp.publicKey,
+  });
+
+  const recipient = await suite.createRecipientContext({
+    recipientKey: rkp.privateKey,
+    enc: sender.enc,
+  });
+
+  // encrypt
+  const ct = await sender.seal(new TextEncoder().encode("Hello world!"));
+
+  // decrypt
+  const pt = await recipient.open(ct);
+
+  // Hello world!
+  console.log(new TextDecoder().decode(pt));
+}
+
+try {
+  doHpke();
+} catch (_err: unknown) {
+  console.log("doHPKE() failed.");
+}
+```
+
+### Web Browsers
+
+```html
+<html>
+  <head></head>
+  <body>
+    <script type="module">
+      import {
+        Aes128Gcm,
+        CipherSuite,
+        DhkemP256HkdfSha256,
+        HkdfSha256,
+      } from "https://esm.sh/@hpke/core";
+
+      globalThis.doHpke = async () => {
+        const suite = new CipherSuite({
+          kem: new DhkemP256HkdfSha256(),
+          kdf: new HkdfSha256(),
+          aead: new Aes128Gcm(),
+        });
+
+        const rkp = await suite.kem.generateKeyPair();
+
+        const sender = await suite.createSenderContext({
+          recipientPublicKey: rkp.publicKey,
+        });
+
+        const recipient = await suite.createRecipientContext({
+          recipientKey: rkp.privateKey, // rkp (CryptoKeyPair) is also acceptable.
+          enc: sender.enc,
+        });
+
+        // encrypt
+        const ct = await sender.seal(
+          new TextEncoder().encode("hello world!"),
+        );
+
+        // decrypt
+        try {
+          const pt = await recipient.open(ct);
+
+          // hello world!
+          alert(new TextDecoder().decode(pt));
+        } catch (err) {
+          alert("failed to decrypt.");
+        }
+      };
+    </script>
+    <button type="button" onclick="doHpke()">do HPKE</button>
+  </body>
+</html>
+```
+
+## Contributing
+
+We welcome all kind of contributions, filing issues, suggesting new features or
+sending PRs.

package/node_modules/@hap/core/node_modules/@hpke/core/esm/mod.d.ts

@@ -0,0 +1,11 @@
+export type { AeadEncryptionContext, AeadInterface, JsonWebKeyExtended, KdfInterface, KemInterface, PreSharedKey, RecipientContextParams, SenderContextParams, } from "@hpke/common";
+export type { CipherSuiteParams } from "./src/interfaces/cipherSuiteParams.js";
+export type { EncryptionContext, RecipientContext, SenderContext, } from "./src/interfaces/encryptionContext.js";
+export type { CipherSuiteSealResponse } from "./src/interfaces/responses.js";
+export { AeadId, DecapError, DeriveKeyPairError, DeserializeError, EncapError, ExportError, HpkeError, InvalidParamError, KdfId, KemId, MessageLimitReachedError, NotSupportedError, OpenError, SealError, SerializeError, ValidationError, } from "@hpke/common";
+export { Aes128Gcm, Aes256Gcm } from "./src/aeads/aesGcm.js";
+export { ExportOnly } from "./src/aeads/exportOnly.js";
+export { CipherSuite, DhkemP256HkdfSha256, DhkemP384HkdfSha384, DhkemP521HkdfSha512, HkdfSha256, HkdfSha384, HkdfSha512, } from "./src/native.js";
+export { DhkemX25519HkdfSha256 } from "./src/kems/dhkemX25519.js";
+export { DhkemX448HkdfSha512 } from "./src/kems/dhkemX448.js";
+//# sourceMappingURL=mod.d.ts.map

package/node_modules/@hap/core/node_modules/@hpke/core/esm/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,qBAAqB,EACrB,aAAa,EACb,kBAAkB,EAClB,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,cAAc,CAAC;AAEtB,YAAY,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,GACd,MAAM,uCAAuC,CAAC;AAC/C,YAAY,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAE7E,OAAO,EACL,MAAM,EACN,UAAU,EACV,kBAAkB,EAClB,gBAAgB,EAChB,UAAU,EACV,WAAW,EACX,SAAS,EACT,iBAAiB,EACjB,KAAK,EACL,KAAK,EACL,wBAAwB,EACxB,iBAAiB,EACjB,SAAS,EACT,SAAS,EACT,cAAc,EACd,eAAe,GAChB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EACL,WAAW,EACX,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,UAAU,EACV,UAAU,EACV,UAAU,GACX,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC"}

package/node_modules/@hap/core/node_modules/@hpke/core/esm/mod.js

@@ -0,0 +1,6 @@
+export { AeadId, DecapError, DeriveKeyPairError, DeserializeError, EncapError, ExportError, HpkeError, InvalidParamError, KdfId, KemId, MessageLimitReachedError, NotSupportedError, OpenError, SealError, SerializeError, ValidationError, } from "@hpke/common";
+export { Aes128Gcm, Aes256Gcm } from "./src/aeads/aesGcm.js";
+export { ExportOnly } from "./src/aeads/exportOnly.js";
+export { CipherSuite, DhkemP256HkdfSha256, DhkemP384HkdfSha384, DhkemP521HkdfSha512, HkdfSha256, HkdfSha384, HkdfSha512, } from "./src/native.js";
+export { DhkemX25519HkdfSha256 } from "./src/kems/dhkemX25519.js";
+export { DhkemX448HkdfSha512 } from "./src/kems/dhkemX448.js";

package/node_modules/@hap/core/node_modules/@hpke/core/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/node_modules/@hap/core/node_modules/@hpke/core/esm/src/aeads/aesGcm.d.ts

@@ -0,0 +1,80 @@
+import type { AeadEncryptionContext, AeadInterface } from "@hpke/common";
+import { AeadId, NativeAlgorithm } from "@hpke/common";
+export declare class AesGcmContext extends NativeAlgorithm implements AeadEncryptionContext {
+    private _rawKey;
+    private _key;
+    constructor(key: ArrayBufferLike | ArrayBufferView);
+    seal(iv: ArrayBufferLike | ArrayBufferView, data: ArrayBufferLike | ArrayBufferView, aad: ArrayBufferLike | ArrayBufferView): Promise<ArrayBuffer>;
+    open(iv: ArrayBufferLike | ArrayBufferView, data: ArrayBufferLike | ArrayBufferView, aad: ArrayBufferLike | ArrayBufferView): Promise<ArrayBuffer>;
+    protected _setupKey(): Promise<void>;
+    private _importKey;
+}
+/**
+ * The AES-128-GCM for HPKE AEAD implementing {@link AeadInterface}.
+ *
+ * When using `@hpke/core`, the instance of this class must be specified
+ * to the `aead` parameter of {@link CipherSuiteParams} instead of `AeadId.Aes128Gcm`.
+ *
+ * @example
+ *
+ * ```ts
+ * import {
+ *   Aes128Gcm,
+ *   CipherSuite,
+ *   DhkemP256HkdfSha256,
+ *   HkdfSha256,
+ * } from "@hpke/core";
+ *
+ * const suite = new CipherSuite({
+ *   kem: new DhkemP256HkdfSha256(),
+ *   kdf: new HkdfSha256(),
+ *   aead: new Aes128Gcm(),
+ * });
+ * ```
+ */
+export declare class Aes128Gcm implements AeadInterface {
+    /** AeadId.Aes128Gcm (0x0001) */
+    readonly id: AeadId;
+    /** 16 */
+    readonly keySize: number;
+    /** 12 */
+    readonly nonceSize: number;
+    /** 16 */
+    readonly tagSize: number;
+    createEncryptionContext(key: ArrayBufferLike | ArrayBufferView): AeadEncryptionContext;
+}
+/**
+ * The AES-256-GCM for HPKE AEAD implementing {@link AeadInterface}.
+ *
+ * When using `@hpke/core`, the instance of this class must be specified
+ * to the `aead` parameter of {@link CipherSuiteParams} instead of `AeadId.Aes256Gcm`
+ * as follows:
+ *
+ * @example
+ *
+ * ```ts
+ * import {
+ *   Aes256Gcm,
+ *   CipherSuite,
+ *   DhkemP256HkdfSha256,
+ *   HkdfSha256,
+ * } from "@hpke/core";
+ *
+ * const suite = new CipherSuite({
+ *   kem: new DhkemP256HkdfSha256(),
+ *   kdf: new HkdfSha256(),
+ *   aead: new Aes256Gcm(),
+ * });
+ * ```
+ */
+export declare class Aes256Gcm extends Aes128Gcm {
+    /** AeadId.Aes256Gcm (0x0002) */
+    id: AeadId;
+    /** 32 */
+    keySize: number;
+    /** 12 */
+    nonceSize: number;
+    /** 16 */
+    tagSize: number;
+}
+//# sourceMappingURL=aesGcm.d.ts.map

package/node_modules/@hap/core/node_modules/@hpke/core/esm/src/aeads/aesGcm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aesGcm.d.ts","sourceRoot":"","sources":["../../../src/src/aeads/aesGcm.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,EAEL,MAAM,EACN,eAAe,EAEhB,MAAM,cAAc,CAAC;AAEtB,qBAAa,aAAc,SAAQ,eACjC,YAAW,qBAAqB;IAChC,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,IAAI,CAAoC;gBAE7B,GAAG,EAAE,eAAe,GAAG,eAAe;IAK5C,IAAI,CACf,EAAE,EAAE,eAAe,GAAG,eAAe,EACrC,IAAI,EAAE,eAAe,GAAG,eAAe,EACvC,GAAG,EAAE,eAAe,GAAG,eAAe,GACrC,OAAO,CAAC,WAAW,CAAC;IAeV,IAAI,CACf,EAAE,EAAE,eAAe,GAAG,eAAe,EACrC,IAAI,EAAE,eAAe,GAAG,eAAe,EACvC,GAAG,EAAE,eAAe,GAAG,eAAe,GACrC,OAAO,CAAC,WAAW,CAAC;cAeP,SAAS;YAWX,UAAU;CASzB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,SAAU,YAAW,aAAa;IAC7C,gCAAgC;IAChC,SAAgB,EAAE,EAAE,MAAM,CAAoB;IAC9C,SAAS;IACT,SAAgB,OAAO,EAAE,MAAM,CAAM;IACrC,SAAS;IACT,SAAgB,SAAS,EAAE,MAAM,CAAM;IACvC,SAAS;IACT,SAAgB,OAAO,EAAE,MAAM,CAAM;IAE9B,uBAAuB,CAC5B,GAAG,EAAE,eAAe,GAAG,eAAe,GACrC,qBAAqB;CAGzB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,SAAU,SAAQ,SAAS;IACtC,gCAAgC;IACvB,EAAE,EAAE,MAAM,CAAoB;IACvC,SAAS;IACA,OAAO,EAAE,MAAM,CAAM;IAC9B,SAAS;IACA,SAAS,EAAE,MAAM,CAAM;IAChC,SAAS;IACA,OAAO,EAAE,MAAM,CAAM;CAC/B"}

package/node_modules/@hap/core/node_modules/@hpke/core/esm/src/aeads/aesGcm.js

@@ -0,0 +1,167 @@
+import { AEAD_USAGES, AeadId, NativeAlgorithm, toArrayBuffer, } from "@hpke/common";
+export class AesGcmContext extends NativeAlgorithm {
+    constructor(key) {
+        super();
+        Object.defineProperty(this, "_rawKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_key", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        this._rawKey = toArrayBuffer(key);
+    }
+    async seal(iv, data, aad) {
+        await this._setupKey();
+        const alg = {
+            name: "AES-GCM",
+            iv: toArrayBuffer(iv),
+            additionalData: toArrayBuffer(aad),
+        };
+        const ct = await this._api.encrypt(alg, this._key, toArrayBuffer(data));
+        return ct;
+    }
+    async open(iv, data, aad) {
+        await this._setupKey();
+        const alg = {
+            name: "AES-GCM",
+            iv: toArrayBuffer(iv),
+            additionalData: toArrayBuffer(aad),
+        };
+        const pt = await this._api.decrypt(alg, this._key, toArrayBuffer(data));
+        return pt;
+    }
+    async _setupKey() {
+        if (this._key !== undefined) {
+            return;
+        }
+        await this._setup();
+        const key = await this._importKey(this._rawKey);
+        (new Uint8Array(this._rawKey)).fill(0);
+        this._key = key;
+        return;
+    }
+    async _importKey(key) {
+        return await this._api.importKey("raw", key, { name: "AES-GCM" }, true, AEAD_USAGES);
+    }
+}
+/**
+ * The AES-128-GCM for HPKE AEAD implementing {@link AeadInterface}.
+ *
+ * When using `@hpke/core`, the instance of this class must be specified
+ * to the `aead` parameter of {@link CipherSuiteParams} instead of `AeadId.Aes128Gcm`.
+ *
+ * @example
+ *
+ * ```ts
+ * import {
+ *   Aes128Gcm,
+ *   CipherSuite,
+ *   DhkemP256HkdfSha256,
+ *   HkdfSha256,
+ * } from "@hpke/core";
+ *
+ * const suite = new CipherSuite({
+ *   kem: new DhkemP256HkdfSha256(),
+ *   kdf: new HkdfSha256(),
+ *   aead: new Aes128Gcm(),
+ * });
+ * ```
+ */
+export class Aes128Gcm {
+    constructor() {
+        /** AeadId.Aes128Gcm (0x0001) */
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: AeadId.Aes128Gcm
+        });
+        /** 16 */
+        Object.defineProperty(this, "keySize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 16
+        });
+        /** 12 */
+        Object.defineProperty(this, "nonceSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 12
+        });
+        /** 16 */
+        Object.defineProperty(this, "tagSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 16
+        });
+    }
+    createEncryptionContext(key) {
+        return new AesGcmContext(key);
+    }
+}
+/**
+ * The AES-256-GCM for HPKE AEAD implementing {@link AeadInterface}.
+ *
+ * When using `@hpke/core`, the instance of this class must be specified
+ * to the `aead` parameter of {@link CipherSuiteParams} instead of `AeadId.Aes256Gcm`
+ * as follows:
+ *
+ * @example
+ *
+ * ```ts
+ * import {
+ *   Aes256Gcm,
+ *   CipherSuite,
+ *   DhkemP256HkdfSha256,
+ *   HkdfSha256,
+ * } from "@hpke/core";
+ *
+ * const suite = new CipherSuite({
+ *   kem: new DhkemP256HkdfSha256(),
+ *   kdf: new HkdfSha256(),
+ *   aead: new Aes256Gcm(),
+ * });
+ * ```
+ */
+export class Aes256Gcm extends Aes128Gcm {
+    constructor() {
+        super(...arguments);
+        /** AeadId.Aes256Gcm (0x0002) */
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: AeadId.Aes256Gcm
+        });
+        /** 32 */
+        Object.defineProperty(this, "keySize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 32
+        });
+        /** 12 */
+        Object.defineProperty(this, "nonceSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 12
+        });
+        /** 16 */
+        Object.defineProperty(this, "tagSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 16
+        });
+    }
+}

package/node_modules/@hap/core/node_modules/@hpke/core/esm/src/aeads/exportOnly.d.ts

@@ -0,0 +1,34 @@
+import type { AeadEncryptionContext, AeadInterface } from "@hpke/common";
+import { AeadId } from "@hpke/common";
+/**
+ * The ExportOnly mode for HPKE AEAD implementing {@link AeadInterface}.
+ *
+ * When using `@hpke/core`, the instance of this class must be specified
+ * to the `aead` parameter of {@link CipherSuiteParams} instead of `AeadId.ExportOnly`
+ * as follows:
+ *
+ * @example
+ *
+ * ```ts
+ * import {
+ *   CipherSuite,
+ *   DhkemP256HkdfSha256,
+ *   ExportOnly,
+ *   HkdfSha256,
+ * } from "@hpke/core";
+ *
+ * const suite = new CipherSuite({
+ *   kem: new DhkemP256HkdfSha256(),
+ *   kdf: new HkdfSha256(),
+ *   aead: new ExportOnly(),
+ * });
+ * ```
+ */
+export declare class ExportOnly implements AeadInterface {
+    readonly id: AeadId;
+    readonly keySize: number;
+    readonly nonceSize: number;
+    readonly tagSize: number;
+    createEncryptionContext(_key: ArrayBufferLike | ArrayBufferView): AeadEncryptionContext;
+}
+//# sourceMappingURL=exportOnly.d.ts.map

package/node_modules/@hap/core/node_modules/@hpke/core/esm/src/aeads/exportOnly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exportOnly.d.ts","sourceRoot":"","sources":["../../../src/src/aeads/exportOnly.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,EAAE,MAAM,EAAqB,MAAM,cAAc,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,UAAW,YAAW,aAAa;IAC9C,SAAgB,EAAE,EAAE,MAAM,CAAqB;IAC/C,SAAgB,OAAO,EAAE,MAAM,CAAK;IACpC,SAAgB,SAAS,EAAE,MAAM,CAAK;IACtC,SAAgB,OAAO,EAAE,MAAM,CAAK;IAE7B,uBAAuB,CAC5B,IAAI,EAAE,eAAe,GAAG,eAAe,GACtC,qBAAqB;CAGzB"}

package/node_modules/@hap/core/node_modules/@hpke/core/esm/src/aeads/exportOnly.js

@@ -0,0 +1,56 @@
+import { AeadId, NotSupportedError } from "@hpke/common";
+/**
+ * The ExportOnly mode for HPKE AEAD implementing {@link AeadInterface}.
+ *
+ * When using `@hpke/core`, the instance of this class must be specified
+ * to the `aead` parameter of {@link CipherSuiteParams} instead of `AeadId.ExportOnly`
+ * as follows:
+ *
+ * @example
+ *
+ * ```ts
+ * import {
+ *   CipherSuite,
+ *   DhkemP256HkdfSha256,
+ *   ExportOnly,
+ *   HkdfSha256,
+ * } from "@hpke/core";
+ *
+ * const suite = new CipherSuite({
+ *   kem: new DhkemP256HkdfSha256(),
+ *   kdf: new HkdfSha256(),
+ *   aead: new ExportOnly(),
+ * });
+ * ```
+ */
+export class ExportOnly {
+    constructor() {
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: AeadId.ExportOnly
+        });
+        Object.defineProperty(this, "keySize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "nonceSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "tagSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    createEncryptionContext(_key) {
+        throw new NotSupportedError("Export only");
+    }
+}