@sd-jwt/utils 0.3.0 → 2.0.4-next.58

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/index.d.mts

@@ -0,0 +1,35 @@
+import { DisclosureData, HasherAndAlg, HasherAndAlgSync } from '@sd-jwt/types';
+
+declare const Base64urlEncode: (src: string) => string;
+declare const Base64urlDecode: (src: string) => string;
+declare const Uint8ArrayToBase64Url: (input: Uint8Array) => string;
+
+declare class SDJWTException extends Error {
+    details?: unknown;
+    constructor(message: string, details?: unknown);
+    getFullMessage(): string;
+}
+
+declare class Disclosure<T = unknown> {
+    salt: string;
+    key?: string;
+    value: T;
+    private _digest;
+    private _encoded;
+    constructor(data: DisclosureData<T>, _meta?: {
+        digest: string;
+        encoded: string;
+    });
+    static fromEncode<T>(s: string, hash: HasherAndAlg): Promise<Disclosure<T>>;
+    static fromEncodeSync<T>(s: string, hash: HasherAndAlgSync): Disclosure<T>;
+    static fromArray<T>(item: DisclosureData<T>, _meta?: {
+        digest: string;
+        encoded: string;
+    }): Disclosure<T>;
+    encode(): string;
+    decode(): DisclosureData<T>;
+    digest(hash: HasherAndAlg): Promise<string>;
+    digestSync(hash: HasherAndAlgSync): string;
+}
+
+export { Base64urlDecode, Base64urlEncode, Disclosure, SDJWTException, Uint8ArrayToBase64Url };

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+import { DisclosureData, HasherAndAlg, HasherAndAlgSync } from '@sd-jwt/types';
+
+declare const Base64urlEncode: (src: string) => string;
+declare const Base64urlDecode: (src: string) => string;
+declare const Uint8ArrayToBase64Url: (input: Uint8Array) => string;
+
+declare class SDJWTException extends Error {
+    details?: unknown;
+    constructor(message: string, details?: unknown);
+    getFullMessage(): string;
+}
+
+declare class Disclosure<T = unknown> {
+    salt: string;
+    key?: string;
+    value: T;
+    private _digest;
+    private _encoded;
+    constructor(data: DisclosureData<T>, _meta?: {
+        digest: string;
+        encoded: string;
+    });
+    static fromEncode<T>(s: string, hash: HasherAndAlg): Promise<Disclosure<T>>;
+    static fromEncodeSync<T>(s: string, hash: HasherAndAlgSync): Disclosure<T>;
+    static fromArray<T>(item: DisclosureData<T>, _meta?: {
+        digest: string;
+        encoded: string;
+    }): Disclosure<T>;
+    encode(): string;
+    decode(): DisclosureData<T>;
+    digest(hash: HasherAndAlg): Promise<string>;
+    digestSync(hash: HasherAndAlgSync): string;
+}
+
+export { Base64urlDecode, Base64urlEncode, Disclosure, SDJWTException, Uint8ArrayToBase64Url };

package/dist/index.js

@@ -0,0 +1,145 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Base64urlDecode: () => Base64urlDecode,
+  Base64urlEncode: () => Base64urlEncode,
+  Disclosure: () => Disclosure,
+  SDJWTException: () => SDJWTException,
+  Uint8ArrayToBase64Url: () => Uint8ArrayToBase64Url
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/base64url.ts
+var import_js_base64 = require("js-base64");
+var Base64urlEncode = import_js_base64.Base64.encodeURI;
+var Base64urlDecode = import_js_base64.Base64.decode;
+var Uint8ArrayToBase64Url = (input) => import_js_base64.Base64.fromUint8Array(input, true);
+
+// src/error.ts
+var SDJWTException = class _SDJWTException extends Error {
+  constructor(message, details) {
+    super(message);
+    Object.setPrototypeOf(this, _SDJWTException.prototype);
+    this.name = "SDJWTException";
+    this.details = details;
+  }
+  getFullMessage() {
+    return `${this.name}: ${this.message} ${this.details ? `- ${JSON.stringify(this.details)}` : ""}`;
+  }
+};
+
+// src/disclosure.ts
+var Disclosure = class _Disclosure {
+  constructor(data, _meta) {
+    this._digest = _meta == null ? void 0 : _meta.digest;
+    this._encoded = _meta == null ? void 0 : _meta.encoded;
+    if (data.length === 2) {
+      this.salt = data[0];
+      this.value = data[1];
+      return;
+    }
+    if (data.length === 3) {
+      this.salt = data[0];
+      this.key = data[1];
+      this.value = data[2];
+      return;
+    }
+    throw new SDJWTException("Invalid disclosure data");
+  }
+  // We need to digest of the original encoded data.
+  // After decode process, we use JSON.stringify to encode the data.
+  // This can be different from the original encoded data.
+  static fromEncode(s, hash) {
+    return __async(this, null, function* () {
+      const { hasher, alg } = hash;
+      const digest = yield hasher(s, alg);
+      const digestStr = Uint8ArrayToBase64Url(digest);
+      const item = JSON.parse(Base64urlDecode(s));
+      return _Disclosure.fromArray(item, { digest: digestStr, encoded: s });
+    });
+  }
+  static fromEncodeSync(s, hash) {
+    const { hasher, alg } = hash;
+    const digest = hasher(s, alg);
+    const digestStr = Uint8ArrayToBase64Url(digest);
+    const item = JSON.parse(Base64urlDecode(s));
+    return _Disclosure.fromArray(item, { digest: digestStr, encoded: s });
+  }
+  static fromArray(item, _meta) {
+    return new _Disclosure(item, _meta);
+  }
+  encode() {
+    if (!this._encoded) {
+      this._encoded = Base64urlEncode(JSON.stringify(this.decode()));
+    }
+    return this._encoded;
+  }
+  decode() {
+    return this.key ? [this.salt, this.key, this.value] : [this.salt, this.value];
+  }
+  digest(hash) {
+    return __async(this, null, function* () {
+      const { hasher, alg } = hash;
+      if (!this._digest) {
+        const hash2 = yield hasher(this.encode(), alg);
+        this._digest = Uint8ArrayToBase64Url(hash2);
+      }
+      return this._digest;
+    });
+  }
+  digestSync(hash) {
+    const { hasher, alg } = hash;
+    if (!this._digest) {
+      const hash2 = hasher(this.encode(), alg);
+      this._digest = Uint8ArrayToBase64Url(hash2);
+    }
+    return this._digest;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Base64urlDecode,
+  Base64urlEncode,
+  Disclosure,
+  SDJWTException,
+  Uint8ArrayToBase64Url
+});

package/dist/index.mjs

@@ -0,0 +1,115 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/base64url.ts
+import { Base64 } from "js-base64";
+var Base64urlEncode = Base64.encodeURI;
+var Base64urlDecode = Base64.decode;
+var Uint8ArrayToBase64Url = (input) => Base64.fromUint8Array(input, true);
+
+// src/error.ts
+var SDJWTException = class _SDJWTException extends Error {
+  constructor(message, details) {
+    super(message);
+    Object.setPrototypeOf(this, _SDJWTException.prototype);
+    this.name = "SDJWTException";
+    this.details = details;
+  }
+  getFullMessage() {
+    return `${this.name}: ${this.message} ${this.details ? `- ${JSON.stringify(this.details)}` : ""}`;
+  }
+};
+
+// src/disclosure.ts
+var Disclosure = class _Disclosure {
+  constructor(data, _meta) {
+    this._digest = _meta == null ? void 0 : _meta.digest;
+    this._encoded = _meta == null ? void 0 : _meta.encoded;
+    if (data.length === 2) {
+      this.salt = data[0];
+      this.value = data[1];
+      return;
+    }
+    if (data.length === 3) {
+      this.salt = data[0];
+      this.key = data[1];
+      this.value = data[2];
+      return;
+    }
+    throw new SDJWTException("Invalid disclosure data");
+  }
+  // We need to digest of the original encoded data.
+  // After decode process, we use JSON.stringify to encode the data.
+  // This can be different from the original encoded data.
+  static fromEncode(s, hash) {
+    return __async(this, null, function* () {
+      const { hasher, alg } = hash;
+      const digest = yield hasher(s, alg);
+      const digestStr = Uint8ArrayToBase64Url(digest);
+      const item = JSON.parse(Base64urlDecode(s));
+      return _Disclosure.fromArray(item, { digest: digestStr, encoded: s });
+    });
+  }
+  static fromEncodeSync(s, hash) {
+    const { hasher, alg } = hash;
+    const digest = hasher(s, alg);
+    const digestStr = Uint8ArrayToBase64Url(digest);
+    const item = JSON.parse(Base64urlDecode(s));
+    return _Disclosure.fromArray(item, { digest: digestStr, encoded: s });
+  }
+  static fromArray(item, _meta) {
+    return new _Disclosure(item, _meta);
+  }
+  encode() {
+    if (!this._encoded) {
+      this._encoded = Base64urlEncode(JSON.stringify(this.decode()));
+    }
+    return this._encoded;
+  }
+  decode() {
+    return this.key ? [this.salt, this.key, this.value] : [this.salt, this.value];
+  }
+  digest(hash) {
+    return __async(this, null, function* () {
+      const { hasher, alg } = hash;
+      if (!this._digest) {
+        const hash2 = yield hasher(this.encode(), alg);
+        this._digest = Uint8ArrayToBase64Url(hash2);
+      }
+      return this._digest;
+    });
+  }
+  digestSync(hash) {
+    const { hasher, alg } = hash;
+    if (!this._digest) {
+      const hash2 = hasher(this.encode(), alg);
+      this._digest = Uint8ArrayToBase64Url(hash2);
+    }
+    return this._digest;
+  }
+};
+export {
+  Base64urlDecode,
+  Base64urlEncode,
+  Disclosure,
+  SDJWTException,
+  Uint8ArrayToBase64Url
+};

package/package.json

@@ -1,49 +1,61 @@
 {
-    "name": "@sd-jwt/utils",
-    "version": "0.3.0",
-    "description": "Utility functions for sd-jwt Draft 06 and sd-jwt-vc Draft 01",
-    "license": "(MIT OR Apache-2.0)",
-    "author": "Berend Sliedrecht <sliedrecht@berend.io>",
-    "readme": "../../README.md",
-    "keywords": [
-        "jwt",
-        "jwt-sd",
-        "sd-jwt",
-        "sd-jwt-vc",
-        "decentralized-identity",
-        "ssi",
-        "oauth",
-        "oauth2",
-        "openid-connect"
+  "name": "@sd-jwt/utils",
+  "version": "2.0.4-next.58+99e0161",
+  "description": "sd-jwt draft 7 implementation in typescript",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf **/dist && tsup",
+    "lint": "biome lint ./src",
+    "test": "pnpm run test:node && pnpm run test:browser && pnpm run test:cov",
+    "test:node": "vitest run ./src/test/*.spec.ts",
+    "test:browser": "vitest run ./src/test/*.spec.ts --environment jsdom",
+    "test:cov": "vitest run --coverage"
+  },
+  "keywords": [
+    "sd-jwt",
+    "sdjwt",
+    "sd-jwt-vc"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openwallet-foundation-labs/sd-jwt-js"
+  },
+  "author": "Lukas.J.Han <lukas.j.han@gmail.com>",
+  "homepage": "https://github.com/openwallet-foundation-labs/sd-jwt-js/wiki",
+  "bugs": {
+    "url": "https://github.com/openwallet-foundation-labs/sd-jwt-js/issues"
+  },
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@sd-jwt/crypto-nodejs": "2.0.4-next.58+99e0161"
+  },
+  "dependencies": {
+    "@sd-jwt/types": "2.0.4-next.58+99e0161",
+    "js-base64": "^3.7.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "tsup": {
+    "entry": [
+      "./src/index.ts"
     ],
-    "repository": {
-        "url": "https://github.com/berendsliedrecht/sd-jwt-ts",
-        "type": "git"
-    },
-    "homepage": "https://github.com/berendsliedrecht/sd-jwt-ts",
-    "bugs": {
-        "url": "https://github.com/berendsliedrecht/sd-jwt-ts/issues",
-        "email": "sliedrecht@berend.io"
-    },
-    "publishConfig": {
-        "access": "public"
-    },
-    "main": "build/index.js",
-    "files": [
-        "build"
-    ],
-    "scripts": {
-        "build": "tsc",
-        "test": "node --require ts-node/register --test ./tests/*.test.ts"
-    },
-    "dependencies": {
-        "@sd-jwt/types": "0.3.0",
-        "buffer": "*"
-    },
-    "devDependencies": {
-        "@types/node": "*",
-        "ts-node": "*",
-        "typescript": "*"
-    },
-    "gitHead": "38e6729c173b08d2b6adb437efa72e8bbb21cb2c"
+    "sourceMap": true,
+    "splitting": false,
+    "clean": true,
+    "dts": true,
+    "format": [
+      "cjs",
+      "esm"
+    ]
+  },
+  "gitHead": "99e0161ecb2c3e79d835afdc047a7b93d0509d41"
 }

package/src/base64url.ts

@@ -0,0 +1,8 @@
+import { Base64 } from 'js-base64';
+
+export const Base64urlEncode = Base64.encodeURI;
+
+export const Base64urlDecode = Base64.decode;
+
+export const Uint8ArrayToBase64Url = (input: Uint8Array): string =>
+  Base64.fromUint8Array(input, true);

package/src/disclosure.ts

@@ -0,0 +1,98 @@
+import {
+  Uint8ArrayToBase64Url,
+  Base64urlDecode,
+  Base64urlEncode,
+} from './base64url';
+import { SDJWTException } from './error';
+import { HasherAndAlg, DisclosureData, HasherAndAlgSync } from '@sd-jwt/types';
+
+export class Disclosure<T = unknown> {
+  public salt: string;
+  public key?: string;
+  public value: T;
+  private _digest: string | undefined;
+  private _encoded: string | undefined;
+
+  public constructor(
+    data: DisclosureData<T>,
+    _meta?: { digest: string; encoded: string },
+  ) {
+    // If the meta is provided, then we assume that the data is already encoded and digested
+    this._digest = _meta?.digest;
+    this._encoded = _meta?.encoded;
+
+    if (data.length === 2) {
+      this.salt = data[0];
+      this.value = data[1];
+      return;
+    }
+    if (data.length === 3) {
+      this.salt = data[0];
+      this.key = data[1] as string;
+      this.value = data[2];
+      return;
+    }
+    throw new SDJWTException('Invalid disclosure data');
+  }
+
+  // We need to digest of the original encoded data.
+  // After decode process, we use JSON.stringify to encode the data.
+  // This can be different from the original encoded data.
+  public static async fromEncode<T>(s: string, hash: HasherAndAlg) {
+    const { hasher, alg } = hash;
+    const digest = await hasher(s, alg);
+    const digestStr = Uint8ArrayToBase64Url(digest);
+    const item = JSON.parse(Base64urlDecode(s)) as DisclosureData<T>;
+    return Disclosure.fromArray<T>(item, { digest: digestStr, encoded: s });
+  }
+
+  public static fromEncodeSync<T>(s: string, hash: HasherAndAlgSync) {
+    const { hasher, alg } = hash;
+    const digest = hasher(s, alg);
+    const digestStr = Uint8ArrayToBase64Url(digest);
+    const item = JSON.parse(Base64urlDecode(s)) as DisclosureData<T>;
+    return Disclosure.fromArray<T>(item, { digest: digestStr, encoded: s });
+  }
+
+  public static fromArray<T>(
+    item: DisclosureData<T>,
+    _meta?: { digest: string; encoded: string },
+  ) {
+    return new Disclosure(item, _meta);
+  }
+
+  public encode() {
+    if (!this._encoded) {
+      // we use JSON.stringify to encode the data
+      // It's the most reliable and universal way to encode JSON object
+      this._encoded = Base64urlEncode(JSON.stringify(this.decode()));
+    }
+    return this._encoded;
+  }
+
+  public decode(): DisclosureData<T> {
+    return this.key
+      ? [this.salt, this.key, this.value]
+      : [this.salt, this.value];
+  }
+
+  public async digest(hash: HasherAndAlg): Promise<string> {
+    const { hasher, alg } = hash;
+    if (!this._digest) {
+      const hash = await hasher(this.encode(), alg);
+      this._digest = Uint8ArrayToBase64Url(hash);
+    }
+
+    return this._digest;
+  }
+
+  public digestSync(hash: HasherAndAlgSync): string {
+    const { hasher, alg } = hash;
+    if (!this._digest) {
+      const hash = hasher(this.encode(), alg);
+      this._digest = Uint8ArrayToBase64Url(hash);
+    }
+
+    return this._digest;
+  }
+}

package/src/error.ts

@@ -0,0 +1,16 @@
+export class SDJWTException extends Error {
+  public details?: unknown;
+
+  constructor(message: string, details?: unknown) {
+    super(message);
+    Object.setPrototypeOf(this, SDJWTException.prototype);
+    this.name = 'SDJWTException';
+    this.details = details;
+  }
+
+  getFullMessage(): string {
+    return `${this.name}: ${this.message} ${
+      this.details ? `- ${JSON.stringify(this.details)}` : ''
+    }`;
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './base64url';
+export * from './error';
+export * from './disclosure';

package/src/test/base64url.spec.ts

@@ -0,0 +1,26 @@
+import { describe, expect, test } from 'vitest';
+import {
+  Base64urlDecode,
+  Base64urlEncode,
+  Uint8ArrayToBase64Url,
+} from '../base64url';
+
+describe('Base64url', () => {
+  const raw = 'abcdefghijklmnopqrstuvwxyz';
+  const encoded = 'YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXo';
+  test('Encode', () => {
+    expect(Base64urlEncode(raw)).toStrictEqual(encoded);
+  });
+  test('Decode', () => {
+    expect(Base64urlDecode(encoded)).toStrictEqual(raw);
+  });
+  test('Encode and decode', () => {
+    const str = 'hello world';
+    expect(Base64urlDecode(Base64urlEncode(str))).toStrictEqual(str);
+  });
+  test('Uint8Array', () => {
+    const str = 'hello world';
+    const uint8 = new TextEncoder().encode(str);
+    expect(Uint8ArrayToBase64Url(uint8)).toStrictEqual(Base64urlEncode(str));
+  });
+});

package/src/test/disclosure.spec.ts

@@ -0,0 +1,141 @@
+import { generateSalt, digest as hasher } from '@sd-jwt/crypto-nodejs';
+import { Disclosure } from '../disclosure';
+import { describe, expect, test } from 'vitest';
+import { Base64urlEncode, SDJWTException } from '../index';
+
+const hash = { alg: 'SHA256', hasher };
+
+/* 
+  ref draft-ietf-oauth-selective-disclosure-jwt-07
+  Claim given_name:
+  SHA-256 Hash: jsu9yVulwQQlhFlM_3JlzMaSFzglhQG0DpfayQwLUK4
+  Disclosure: WyIyR0xDNDJzS1F2ZUNmR2ZyeU5STjl3IiwgImdpdmVuX25hbWUiLCAiSm9obiJd
+  Contents: ["2GLC42sKQveCfGfryNRN9w", "given_name", "John"]
+  For example, the SHA-256 digest of the Disclosure
+  WyI2cU1RdlJMNWhhaiIsICJmYW1pbHlfbmFtZSIsICJNw7ZiaXVzIl0 would be uutlBuYeMDyjLLTpf6Jxi7yNkEF35jdyWMn9U7b_RYY.
+  The SHA-256 digest of the Disclosure
+  WyJsa2x4RjVqTVlsR1RQVW92TU5JdkNBIiwgIkZSIl0 would be w0I8EKcdCtUPkGCNUrfwVp2xEgNjtoIDlOxc9-PlOhs.
+*/
+const TestDataDraft7 = {
+  claimTests: [
+    {
+      contents: '["2GLC42sKQveCfGfryNRN9w", "given_name", "John"]',
+      digest: 'jsu9yVulwQQlhFlM_3JlzMaSFzglhQG0DpfayQwLUK4',
+      disclosure:
+        'WyIyR0xDNDJzS1F2ZUNmR2ZyeU5STjl3IiwgImdpdmVuX25hbWUiLCAiSm9obiJd',
+    },
+  ],
+  sha256Tests: [
+    {
+      digest: 'uutlBuYeMDyjLLTpf6Jxi7yNkEF35jdyWMn9U7b_RYY',
+      disclosure: 'WyI2cU1RdlJMNWhhaiIsICJmYW1pbHlfbmFtZSIsICJNw7ZiaXVzIl0',
+    },
+    {
+      digest: 'w0I8EKcdCtUPkGCNUrfwVp2xEgNjtoIDlOxc9-PlOhs',
+      disclosure: 'WyJsa2x4RjVqTVlsR1RQVW92TU5JdkNBIiwgIkZSIl0',
+    },
+  ],
+};
+
+describe('Disclosure', () => {
+  test('create object disclosure', async () => {
+    const salt = generateSalt(16);
+    const disclosure = new Disclosure([salt, 'name', 'James']);
+    expect(disclosure).toBeDefined();
+    expect(disclosure.key).toBe('name');
+    expect(disclosure.value).toBe('James');
+    expect(disclosure.salt).toBe(salt);
+  });
+
+  test('create array disclosure', async () => {
+    const salt = generateSalt(16);
+    const disclosure = new Disclosure([salt, 'US']);
+    expect(disclosure).toBeDefined();
+    expect(disclosure.key).toBe(undefined);
+    expect(disclosure.value).toBe('US');
+    expect(disclosure.salt).toBe(salt);
+  });
+
+  test('create disclosure error', async () => {
+    const salt = generateSalt(16);
+    const data: [string, string, string] = [salt, 'name', 'James'];
+    data.push('any');
+    expect(() => new Disclosure(data)).toThrow();
+    try {
+      new Disclosure(data);
+    } catch (e: unknown) {
+      const error = e as SDJWTException;
+      expect(typeof error.getFullMessage()).toBe('string');
+    }
+  });
+
+  test('encode disclosure', async () => {
+    const salt = generateSalt(16);
+    const disclosure = new Disclosure([salt, 'name', 'James']);
+    const encodedDisclosure = disclosure.encode();
+    expect(encodedDisclosure).toBeDefined();
+    expect(typeof encodedDisclosure).toBe('string');
+  });
+
+  test('decode disclosure', async () => {
+    const salt = generateSalt(16);
+    const disclosure = new Disclosure([salt, 'name', 'James']);
+    const encodedDisclosure = disclosure.encode();
+    const newDisclosure = await Disclosure.fromEncode(encodedDisclosure, {
+      alg: 'SHA256',
+      hasher,
+    });
+
+    expect(newDisclosure).toBeDefined();
+    expect(newDisclosure.key).toBe('name');
+    expect(newDisclosure.value).toBe('James');
+    expect(newDisclosure.salt).toBe(salt);
+  });
+
+  test('digest disclosure #1', async () => {
+    const salt = generateSalt(16);
+    const disclosure = new Disclosure([salt, 'name', 'James']);
+    const digest = await disclosure.digest({ alg: 'SHA256', hasher });
+    expect(digest).toBeDefined();
+    expect(typeof digest).toBe('string');
+  });
+
+  test('digest disclosure #2', async () => {
+    const disclosure = new Disclosure([
+      '2GLC42sKQveCfGfryNRN9w',
+      'given_name',
+      'John',
+    ]);
+    const encode = disclosure.encode();
+    expect(encode).toBe(
+      'WyIyR0xDNDJzS1F2ZUNmR2ZyeU5STjl3IiwiZ2l2ZW5fbmFtZSIsIkpvaG4iXQ',
+    );
+    const digest = await disclosure.digest(hash);
+    expect(digest).toBe('8VHiz7qTXavxvpiTYDCSr_shkUO6qRcVXjkhEnt1os4');
+  });
+
+  test('digest disclosure #2', async () => {
+    const encoded = Base64urlEncode(TestDataDraft7.claimTests[0].contents);
+    expect(encoded).toStrictEqual(TestDataDraft7.claimTests[0].disclosure);
+
+    const disclosure = await Disclosure.fromEncode(
+      TestDataDraft7.claimTests[0].disclosure,
+      hash,
+    );
+
+    const digest = await disclosure.digest(hash);
+    expect(digest).toBe(TestDataDraft7.claimTests[0].digest);
+  });
+
+  test('digest disclosure #3', async () => {
+    for (const sha256Test of TestDataDraft7.sha256Tests) {
+      const disclosure = await Disclosure.fromEncode(
+        sha256Test.disclosure,
+        hash,
+      );
+
+      const digest = await disclosure.digest(hash);
+      expect(digest).toBe(sha256Test.digest);
+    }
+  });
+});

package/src/test/error.spec.ts

@@ -0,0 +1,15 @@
+import { SDJWTException } from '../error';
+import { describe, expect, test } from 'vitest';
+
+describe('Error tests', () => {
+  test('Detail', () => {
+    try {
+      throw new SDJWTException('msg', { info: 'details' });
+    } catch (e: unknown) {
+      const exception = e as SDJWTException;
+      expect(exception.getFullMessage()).toEqual(
+        'SDJWTException: msg - {"info":"details"}',
+      );
+    }
+  });
+});

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  }
+}

package/vitest.config.mts

@@ -0,0 +1,4 @@
+// vite.config.ts
+import { allEnvs } from '../../vitest.shared';
+
+export default allEnvs;

package/build/assert.d.ts

@@ -1 +0,0 @@
-export declare const assertClaimInObject: (object: Record<string, unknown>, claimKey: string, claimValue?: unknown) => void;

package/build/assert.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertClaimInObject = void 0;
-const getValueByKeyAnyLevel_1 = require("./getValueByKeyAnyLevel");
-const simpleDeepEqual_1 = require("./simpleDeepEqual");
-const assertClaimInObject = (object, claimKey, claimValue) => {
-    const value = (0, getValueByKeyAnyLevel_1.getValueByKeyAnyLevel)(object, claimKey);
-    if (!value) {
-        throw new Error(`Claim key '${claimKey}' not found in any level`);
-    }
-    if (claimValue && !(0, simpleDeepEqual_1.simpleDeepEqual)(value, claimValue)) {
-        throw new Error(`Claim key '${claimKey}' was found, but values did not match`);
-    }
-};
-exports.assertClaimInObject = assertClaimInObject;
-//# sourceMappingURL=assert.js.map

package/build/assert.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"assert.js","sourceRoot":"","sources":["../src/assert.ts"],"names":[],"mappings":";;;AAAA,mEAA+D;AAC/D,uDAAmD;AAE5C,MAAM,mBAAmB,GAAG,CAC/B,MAA+B,EAC/B,QAAgB,EAChB,UAAoB,EACtB,EAAE;IACA,MAAM,KAAK,GAAG,IAAA,6CAAqB,EAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IAErD,IAAI,CAAC,KAAK,EAAE,CAAC;QACT,MAAM,IAAI,KAAK,CAAC,cAAc,QAAQ,0BAA0B,CAAC,CAAA;IACrE,CAAC;IAED,IAAI,UAAU,IAAI,CAAC,IAAA,iCAAe,EAAC,KAAK,EAAE,UAAU,CAAC,EAAE,CAAC;QACpD,MAAM,IAAI,KAAK,CACX,cAAc,QAAQ,uCAAuC,CAChE,CAAA;IACL,CAAC;AACL,CAAC,CAAA;AAhBY,QAAA,mBAAmB,uBAgB/B"}

package/build/base64url.d.ts

@@ -1,29 +0,0 @@
-/// <reference types="node" />
-import { Buffer } from 'buffer';
-export declare class Base64url {
-    /**
-     *
-     * Encode into base64url string
-     *
-     */
-    static encode(input: string | Uint8Array | Buffer): string;
-    /**
-     *
-     * Encode from JSON into a base64url string
-     *
-     */
-    static encodeFromJson(input: Record<string, unknown> | Array<unknown>): string;
-    /**
-     *
-     * Decode from base64url into JSON
-     *
-     */
-    static decodeToJson<T extends Record<string, unknown> | Array<unknown> = Record<string, unknown>>(input: string): T;
-    /**
-     *
-     * Decode from base64url into a byte array
-     *
-     */
-    static decode(input: string): Uint8Array;
-}
-export declare function base64ToBase64URL(base64: string): string;

package/build/base64url.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.base64ToBase64URL = exports.Base64url = void 0;
-const buffer_1 = require("buffer");
-class Base64url {
-    /**
-     *
-     * Encode into base64url string
-     *
-     */
-    static encode(input) {
-        return base64ToBase64URL(buffer_1.Buffer.from(input).toString('base64'));
-    }
-    /**
-     *
-     * Encode from JSON into a base64url string
-     *
-     */
-    static encodeFromJson(input) {
-        return base64ToBase64URL(buffer_1.Buffer.from(JSON.stringify(input)).toString('base64'));
-    }
-    /**
-     *
-     * Decode from base64url into JSON
-     *
-     */
-    static decodeToJson(input) {
-        return JSON.parse(buffer_1.Buffer.from(input, 'base64').toString());
-    }
-    /**
-     *
-     * Decode from base64url into a byte array
-     *
-     */
-    static decode(input) {
-        return Uint8Array.from(buffer_1.Buffer.from(input, 'base64'));
-    }
-}
-exports.Base64url = Base64url;
-function base64ToBase64URL(base64) {
-    return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
-}
-exports.base64ToBase64URL = base64ToBase64URL;
-//# sourceMappingURL=base64url.js.map

package/build/base64url.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"base64url.js","sourceRoot":"","sources":["../src/base64url.ts"],"names":[],"mappings":";;;AAAA,mCAA+B;AAE/B,MAAa,SAAS;IAClB;;;;OAIG;IACI,MAAM,CAAC,MAAM,CAAC,KAAmC;QACpD,OAAO,iBAAiB,CAAC,eAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAA;IACnE,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,cAAc,CACxB,KAA+C;QAE/C,OAAO,iBAAiB,CACpB,eAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CACxD,CAAA;IACL,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,YAAY,CAKxB,KAAa;QACX,OAAO,IAAI,CAAC,KAAK,CAAC,eAAM,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,QAAQ,EAAE,CAAM,CAAA;IACnE,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,MAAM,CAAC,KAAa;QAC9B,OAAO,UAAU,CAAC,IAAI,CAAC,eAAM,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAA;IACxD,CAAC;CACJ;AA7CD,8BA6CC;AAED,SAAgB,iBAAiB,CAAC,MAAc;IAC5C,OAAO,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;AAC3E,CAAC;AAFD,8CAEC"}

package/build/getValueByKeyAnyLevel.d.ts

@@ -1 +0,0 @@
-export declare const getValueByKeyAnyLevel: <T = unknown>(obj: Record<string, unknown>, key: string) => T | undefined;

package/build/getValueByKeyAnyLevel.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getValueByKeyAnyLevel = void 0;
-const getValueByKeyAnyLevel = (obj, key) => {
-    // Check if the current object has the key
-    if (obj && obj.hasOwnProperty(key)) {
-        return obj[key];
-    }
-    // If not found in the current object, iterate over its properties
-    for (const prop in obj) {
-        if (obj.hasOwnProperty(prop) && typeof obj[prop] === 'object') {
-            const result = (0, exports.getValueByKeyAnyLevel)(obj[prop], key);
-            if (result !== undefined) {
-                return result;
-            }
-        }
-    }
-};
-exports.getValueByKeyAnyLevel = getValueByKeyAnyLevel;
-//# sourceMappingURL=getValueByKeyAnyLevel.js.map

package/build/getValueByKeyAnyLevel.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getValueByKeyAnyLevel.js","sourceRoot":"","sources":["../src/getValueByKeyAnyLevel.ts"],"names":[],"mappings":";;;AAAO,MAAM,qBAAqB,GAAG,CACjC,GAA4B,EAC5B,GAAW,EACE,EAAE;IACf,0CAA0C;IAC1C,IAAI,GAAG,IAAI,GAAG,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC;QACjC,OAAO,GAAG,CAAC,GAAG,CAAM,CAAA;IACxB,CAAC;IAED,kEAAkE;IAClE,KAAK,MAAM,IAAI,IAAI,GAAG,EAAE,CAAC;QACrB,IAAI,GAAG,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,OAAO,GAAG,CAAC,IAAI,CAAC,KAAK,QAAQ,EAAE,CAAC;YAC5D,MAAM,MAAM,GAAG,IAAA,6BAAqB,EAChC,GAAG,CAAC,IAAI,CAA4B,EACpC,GAAG,CACN,CAAA;YACD,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACvB,OAAO,MAAW,CAAA;YACtB,CAAC;QACL,CAAC;IACL,CAAC;AACL,CAAC,CAAA;AArBY,QAAA,qBAAqB,yBAqBjC"}

package/build/index.d.ts

@@ -1,6 +0,0 @@
-export * from './base64url';
-export * from './assert';
-export * from './getValueByKeyAnyLevel';
-export * from './isPromise';
-export * from './object';
-export * from './simpleDeepEqual';

package/build/index.js

@@ -1,23 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./base64url"), exports);
-__exportStar(require("./assert"), exports);
-__exportStar(require("./getValueByKeyAnyLevel"), exports);
-__exportStar(require("./isPromise"), exports);
-__exportStar(require("./object"), exports);
-__exportStar(require("./simpleDeepEqual"), exports);
-//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAA2B;AAC3B,2CAAwB;AACxB,0DAAuC;AACvC,8CAA2B;AAC3B,2CAAwB;AACxB,oDAAiC"}

package/build/isPromise.d.ts

@@ -1 +0,0 @@
-export declare const isPromise: <T>(value: T | Promise<T>) => value is Promise<T>;

package/build/isPromise.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPromise = void 0;
-const isPromise = (value) => value instanceof Promise ||
-    (value &&
-        typeof value === 'object' &&
-        value !== null &&
-        'then' in value &&
-        value.then === 'function');
-exports.isPromise = isPromise;
-//# sourceMappingURL=isPromise.js.map

package/build/isPromise.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isPromise.js","sourceRoot":"","sources":["../src/isPromise.ts"],"names":[],"mappings":";;;AAAO,MAAM,SAAS,GAAG,CAAI,KAAqB,EAAuB,EAAE,CACvE,KAAK,YAAY,OAAO;IACxB,CAAC,KAAK;QACF,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,MAAM,IAAI,KAAK;QACf,KAAK,CAAC,IAAI,KAAK,UAAU,CAAC,CAAA;AANrB,QAAA,SAAS,aAMY"}

package/build/object.d.ts

@@ -1,5 +0,0 @@
-export declare function isObject(input: any): boolean;
-export declare function getAllKeys(object: unknown, keys?: Array<string>): Array<string>;
-export declare function deleteByPath(object: Record<string, unknown>, path: string[]): void;
-export declare function getByPath(item: any[] | Record<string, unknown>, path: Array<string | number>): unknown;
-export declare function hasByPath(item: any[] | Record<string, unknown>, path: Array<string | number>): boolean;

package/build/object.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasByPath = exports.getByPath = exports.deleteByPath = exports.getAllKeys = exports.isObject = void 0;
-function isObject(input) {
-    return typeof input === 'object' && input !== null && !Array.isArray(input);
-}
-exports.isObject = isObject;
-function getAllKeys(object, keys = []) {
-    if (typeof object !== 'object' || typeof object === null)
-        return keys;
-    const record = object;
-    const objectKeys = Object.keys(record);
-    const objectValues = Object.values(record);
-    keys.push(...objectKeys);
-    for (const objectValue of objectValues) {
-        if (typeof objectValue === 'object' &&
-            objectValue !== null &&
-            !Array.isArray(objectValue)) {
-            getAllKeys(objectValue, keys);
-        }
-    }
-    return keys;
-}
-exports.getAllKeys = getAllKeys;
-function deleteByPath(object, path) {
-    let currentObject = object;
-    const parts = [...path];
-    const last = parts.pop();
-    for (const part of parts) {
-        currentObject = currentObject[part];
-        if (!currentObject) {
-            return;
-        }
-    }
-    if (last) {
-        delete currentObject[last];
-    }
-}
-exports.deleteByPath = deleteByPath;
-function getByPath(item, path) {
-    let current = item;
-    for (const key of path) {
-        if (Array.isArray(current)) {
-            const keyAsNumber = Number(key);
-            if (isNaN(keyAsNumber)) {
-                throw new Error(`Unable to get ${path.join('.')} from array ${item}. ${key} is not a number.`);
-            }
-            if (keyAsNumber >= current.length) {
-                throw new Error(`Unable to get ${path.join('.')} from array ${item}. ${key} is out of bounds.`);
-            }
-            current = current[keyAsNumber];
-        }
-        else if (typeof current === 'object' && current !== null) {
-            if (!(key in current)) {
-                throw new Error(`Unable to get ${path.join('.')} from ${item}. ${key} does not exists in ${current}.`);
-            }
-            current = current[key];
-        }
-        else {
-            throw new Error(`Unable to get ${path.join('.')} from ${item}. ${key} is not an object or array.`);
-        }
-    }
-    return current;
-}
-exports.getByPath = getByPath;
-function hasByPath(item, path) {
-    try {
-        getByPath(item, path);
-        return true;
-    }
-    catch (_a) {
-        return false;
-    }
-}
-exports.hasByPath = hasByPath;
-//# sourceMappingURL=object.js.map

package/build/object.js.map

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

package/build/simpleDeepEqual.d.ts

@@ -1 +0,0 @@
-export declare function simpleDeepEqual(lhs: unknown, rhs: unknown): boolean;

package/build/simpleDeepEqual.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.simpleDeepEqual = void 0;
-function simpleDeepEqual(lhs, rhs) {
-    if (lhs === rhs)
-        return true;
-    if (typeof lhs !== 'object' || typeof rhs !== 'object')
-        return false;
-    const l = Object.assign({}, lhs);
-    const r = Object.assign({}, rhs);
-    Object.keys(l).forEach((key) => l[key] === undefined && delete l[key]);
-    Object.keys(r).forEach((key) => r[key] === undefined && delete r[key]);
-    const keys1 = Object.keys(l);
-    const keys2 = Object.keys(r);
-    if (keys1.length !== keys2.length)
-        return false;
-    return keys1.every((key) => simpleDeepEqual(l[key], r[key]));
-}
-exports.simpleDeepEqual = simpleDeepEqual;
-//# sourceMappingURL=simpleDeepEqual.js.map

package/build/simpleDeepEqual.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"simpleDeepEqual.js","sourceRoot":"","sources":["../src/simpleDeepEqual.ts"],"names":[],"mappings":";;;AAAA,SAAgB,eAAe,CAAC,GAAY,EAAE,GAAY;IACtD,IAAI,GAAG,KAAK,GAAG;QAAE,OAAO,IAAI,CAAA;IAE5B,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAA;IAEpE,MAAM,CAAC,GAAG,kBAAK,GAAG,CAA6B,CAAA;IAC/C,MAAM,CAAC,GAAG,kBAAK,GAAG,CAA6B,CAAA;IAE/C,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,SAAS,IAAI,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAA;IACtE,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,SAAS,IAAI,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAA;IAEtE,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;IAC5B,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;IAE5B,IAAI,KAAK,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM;QAAE,OAAO,KAAK,CAAA;IAE/C,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;AAChE,CAAC;AAjBD,0CAiBC"}