@icure/cardinal-sdk 2.0.0-PREVIEW-18.1 → 2.0.0-PREVIEW-21

package/core-library-digest.mjs

@@ -0,0 +1,186 @@
+import {
+  hashCodeq5arwsb9dgti as hashCode,
+  isBlank1dvkhjjvox3p0 as isBlank,
+  Unit_instance1fbcbse1fwigr as Unit_instance,
+  toString1pkumu07cwy4m as toString,
+  protoOf180f3jzyo7rfj as protoOf,
+  fill3lmv1pckd4inv as fill,
+  arrayCopytctsywo3h7gj as arrayCopy,
+  equals2au1ep9vhcato as equals,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from './kotlin-kotlin-stdlib.mjs';
+import { InvalidParameterException_init_$Create$1dn8z68oxsdqm as InvalidParameterException_init_$Create$ } from './error-library-error.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+initMetadataForClass(Digest, 'Digest');
+//endregion
+function _Buffer___init__impl__mrnqm7(value) {
+  return value;
+}
+function _Buffer___get_value__impl__xxr8tn($this) {
+  return $this;
+}
+function Buffer__hashCode_impl_3ylui6($this) {
+  return hashCode($this);
+}
+function Digest_init_$Init$(algorithm, blockSize, digestLength, $this) {
+  Digest.call($this);
+  var tmp = $this;
+  // Inline function 'org.kotlincrypto.core.digest.internal.initializeBuffer' call
+  // Inline function 'kotlin.text.isNotBlank' call
+  var tmp0 = !isBlank(algorithm);
+  $l$block: {
+    // Inline function 'org.kotlincrypto.error.requireParam' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (tmp0) {
+      break $l$block;
+    }
+    var message = 'algorithm cannot be blank';
+    throw InvalidParameterException_init_$Create$(toString(message));
+  }
+  var tmp0_0 = blockSize > 0;
+  $l$block_0: {
+    // Inline function 'org.kotlincrypto.error.requireParam' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (tmp0_0) {
+      break $l$block_0;
+    }
+    var message_0 = 'blockSize must be greater than 0';
+    throw InvalidParameterException_init_$Create$(toString(message_0));
+  }
+  var tmp0_1 = (blockSize % 8 | 0) === 0;
+  $l$block_1: {
+    // Inline function 'org.kotlincrypto.error.requireParam' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (tmp0_1) {
+      break $l$block_1;
+    }
+    var message_1 = 'blockSize must be a factor of 8';
+    throw InvalidParameterException_init_$Create$(toString(message_1));
+  }
+  var tmp0_2 = digestLength >= 0;
+  $l$block_2: {
+    // Inline function 'org.kotlincrypto.error.requireParam' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (tmp0_2) {
+      break $l$block_2;
+    }
+    var message_2 = 'digestLength cannot be negative';
+    throw InvalidParameterException_init_$Create$(toString(message_2));
+  }
+  tmp.g6y_1 = _Buffer___init__impl__mrnqm7(new Int8Array(blockSize));
+  $this.e6y_1 = algorithm;
+  $this.f6y_1 = digestLength;
+  $this.h6y_1 = 0;
+  return $this;
+}
+protoOf(Digest).i6y = function () {
+  return this.f6y_1;
+};
+protoOf(Digest).j6y = function () {
+  return this.e6y_1;
+};
+protoOf(Digest).k6y = function (input) {
+  this.l6y(input, 0, input.length);
+};
+protoOf(Digest).m6y = function () {
+  var tmp0 = this.g6y_1;
+  // Inline function 'org.kotlincrypto.core.digest.internal.commonDigest' call
+  var bufPos = this.h6y_1;
+  // Inline function 'kotlin.contracts.contract' call
+  fill(_Buffer___get_value__impl__xxr8tn(tmp0), 0, bufPos);
+  var p0 = _Buffer___get_value__impl__xxr8tn(tmp0);
+  var digest = this.n6y(p0, bufPos);
+  // Inline function 'org.kotlincrypto.core.digest.internal.commonReset' call
+  // Inline function 'kotlin.contracts.contract' call
+  fill(_Buffer___get_value__impl__xxr8tn(tmp0), 0);
+  this.h6y_1 = 0;
+  this.o6y();
+  return digest;
+};
+protoOf(Digest).l6y = function (input, offset, len) {
+  var tmp0 = this.g6y_1;
+  var tmp8 = this.h6y_1;
+  $l$block: {
+    // Inline function 'org.kotlincrypto.core.digest.internal.commonUpdate' call
+    // Inline function 'kotlin.contracts.contract' call
+    var buf = _Buffer___get_value__impl__xxr8tn(tmp0);
+    var blockSize = buf.length;
+    var limitInput = offset + len | 0;
+    var posInput = offset;
+    var posBuf = tmp8;
+    if (posBuf > 0) {
+      if ((posBuf + len | 0) < blockSize) {
+        var tmp4 = posBuf;
+        // Inline function 'kotlin.collections.copyInto' call
+        var startIndex = posInput;
+        // Inline function 'kotlin.js.unsafeCast' call
+        // Inline function 'kotlin.js.asDynamic' call
+        var tmp = input;
+        // Inline function 'kotlin.js.unsafeCast' call
+        // Inline function 'kotlin.js.asDynamic' call
+        arrayCopy(tmp, buf, tmp4, startIndex, limitInput);
+        this.h6y_1 = posBuf + len | 0;
+        break $l$block;
+      }
+      var needed = blockSize - posBuf | 0;
+      var tmp4_0 = posBuf;
+      var tmp6 = posInput;
+      // Inline function 'kotlin.collections.copyInto' call
+      var endIndex = posInput + needed | 0;
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      var tmp_0 = input;
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      arrayCopy(tmp_0, buf, tmp4_0, tmp6, endIndex);
+      this.p6y(buf, 0);
+      posBuf = 0;
+      posInput = posInput + needed | 0;
+    }
+    $l$loop: while (posInput < limitInput) {
+      var posNext = posInput + blockSize | 0;
+      if (posNext > limitInput) {
+        // Inline function 'kotlin.collections.copyInto' call
+        var startIndex_0 = posInput;
+        // Inline function 'kotlin.js.unsafeCast' call
+        // Inline function 'kotlin.js.asDynamic' call
+        var tmp_1 = input;
+        // Inline function 'kotlin.js.unsafeCast' call
+        // Inline function 'kotlin.js.asDynamic' call
+        arrayCopy(tmp_1, buf, 0, startIndex_0, limitInput);
+        posBuf = limitInput - posInput | 0;
+        break $l$loop;
+      }
+      var p1 = posInput;
+      this.p6y(input, p1);
+      posInput = posNext;
+    }
+    this.h6y_1 = posBuf;
+  }
+};
+protoOf(Digest).equals = function (other) {
+  var tmp;
+  if (other instanceof Digest) {
+    tmp = equals(other.g6y_1, this.g6y_1);
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(Digest).hashCode = function () {
+  return Buffer__hashCode_impl_3ylui6(this.g6y_1);
+};
+protoOf(Digest).toString = function () {
+  // Inline function 'org.kotlincrypto.core.digest.internal.commonToString' call
+  return 'Digest[' + this.j6y() + ']@' + this.hashCode();
+};
+function Digest() {
+}
+//region block: exports
+export {
+  Digest_init_$Init$ as Digest_init_$Init$192xwc0pz8fza,
+  Digest as Digest1vc95ftpmqvn1,
+};
+//endregion

package/crypto/CryptoService.d.mts

@@ -16,11 +16,15 @@ export interface XAesKey {
     readonly aesKey?: any;
     readonly algorithm: string;
 }
-export interface XCryptoService {
-    readonly aes: XAesService;
-    readonly digest: XDigestService;
+export interface XCryptoService extends PartialXCryptoService {
     readonly rsa: XRsaService;
     readonly strongRandom: XStrongRandom;
+}
+export interface PartialXCryptoService {
+    readonly aes: XAesService;
+    readonly digest: XDigestService;
+    readonly rsa: PartialXRsaService & Partial<XRsaService>;
+    readonly strongRandom: PartialXStrongRandom & Partial<XStrongRandom>;
     readonly hmac: XHmacService;
 }
 export interface XDigestService {
@@ -54,17 +58,19 @@ export declare enum RsaSignatureAlgorithm {
     PssWithSha256 = "PssWithSha256"
 }
 export type RsaAlgorithm = RsaEncryptionAlgorithm | RsaSignatureAlgorithm;
-export interface XRsaService {
+interface PartialXRsaService {
     generateKeyPair(algorithm: RsaAlgorithm, keySize: RsaKeySize): Promise<XRsaKeypair>;
     exportPrivateKeyPkcs8(key: XPrivateRsaKey): Promise<Int8Array>;
     exportPublicKeySpki(key: XPublicRsaKey): Promise<Int8Array>;
-    loadKeyPairPkcs8(algorithm: RsaAlgorithm, privateKeyPkcs8: Int8Array): Promise<XRsaKeypair>;
     loadPrivateKeyPkcs8(algorithm: RsaAlgorithm, privateKeyPkcs8: Int8Array): Promise<XPrivateRsaKey>;
     loadPublicKeySpki(algorithm: RsaAlgorithm, publicKeySpki: Int8Array): Promise<XPublicRsaKey>;
     encrypt(data: Int8Array, publicKey: XPublicRsaKey): Promise<Int8Array>;
     decrypt(data: Int8Array, privateKey: XPrivateRsaKey): Promise<Int8Array>;
     sign(data: Int8Array, privateKey: XPrivateRsaKey): Promise<Int8Array>;
     verifySignature(signature: Int8Array, data: Int8Array, publicKey: XPublicRsaKey): Promise<boolean>;
+}
+interface XRsaService extends PartialXRsaService {
+    loadKeyPairPkcs8(algorithm: RsaAlgorithm, privateKeyPkcs8: Int8Array): Promise<XRsaKeypair>;
     exportPrivateKeyJwk(key: XPrivateRsaKey): Promise<JsonWebKey>;
     exportPublicKeyJwk(key: XPublicRsaKey): Promise<JsonWebKey>;
     loadPrivateKeyJwk(privateKeyJwk: JsonWebKey): Promise<XPrivateRsaKey>;
@@ -82,7 +88,11 @@ export interface XPublicRsaKey {
     readonly publicKey?: any;
     readonly algorithm: string;
 }
-export interface XStrongRandom {
-    randomBytes(length: number): Int8Array;
+export interface XStrongRandom extends PartialXStrongRandom {
     randomUUID(): string;
+    fill(array: Int8Array): void;
+}
+export interface PartialXStrongRandom {
+    randomBytes(length: number): Int8Array;
 }
+export {};

package/error-library-error.mjs

@@ -0,0 +1,42 @@
+import {
+  IllegalArgumentException_init_$Init$1blytbdgl1fky as IllegalArgumentException_init_$Init$,
+  protoOf180f3jzyo7rfj as protoOf,
+  objectCreate1ve4bgxiu4x98 as objectCreate,
+  captureStack1fzi4aczwc4hg as captureStack,
+  IllegalArgumentException_init_$Init$1ke5df1bctk2y as IllegalArgumentException_init_$Init$_0,
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from './kotlin-kotlin-stdlib.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+initMetadataForClass(InvalidParameterException, 'InvalidParameterException', InvalidParameterException_init_$Create$, IllegalArgumentException);
+//endregion
+function InvalidParameterException_init_$Init$($this) {
+  IllegalArgumentException_init_$Init$($this);
+  InvalidParameterException.call($this);
+  return $this;
+}
+function InvalidParameterException_init_$Create$() {
+  var tmp = InvalidParameterException_init_$Init$(objectCreate(protoOf(InvalidParameterException)));
+  captureStack(tmp, InvalidParameterException_init_$Create$);
+  return tmp;
+}
+function InvalidParameterException_init_$Init$_0(message, $this) {
+  IllegalArgumentException_init_$Init$_0(message, $this);
+  InvalidParameterException.call($this);
+  return $this;
+}
+function InvalidParameterException_init_$Create$_0(message) {
+  var tmp = InvalidParameterException_init_$Init$_0(message, objectCreate(protoOf(InvalidParameterException)));
+  captureStack(tmp, InvalidParameterException_init_$Create$_0);
+  return tmp;
+}
+function InvalidParameterException() {
+  captureStack(this, InvalidParameterException);
+}
+//region block: exports
+export {
+  InvalidParameterException_init_$Create$_0 as InvalidParameterException_init_$Create$1dn8z68oxsdqm,
+};
+//endregion

package/hash-library-sha2.mjs

@@ -0,0 +1,183 @@
+import {
+  Digest_init_$Init$192xwc0pz8fza as Digest_init_$Init$,
+  Digest1vc95ftpmqvn1 as Digest,
+} from './core-library-digest.mjs';
+import { Bit32_init_$Create$3semccfol7xke as Bit32_init_$Create$ } from './bitops-library-bits.mjs';
+import {
+  protoOf180f3jzyo7rfj as protoOf,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  Unit_instance1fbcbse1fwigr as Unit_instance,
+  fill3lmv1pckd4inv as fill,
+  fill2542d4m9l93pn as fill_0,
+  arrayCopytctsywo3h7gj as arrayCopy,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  VOID3gxj6tk5isa35 as VOID,
+  objectCreate1ve4bgxiu4x98 as objectCreate,
+} from './kotlin-kotlin-stdlib.mjs';
+import { Big_getInstancez5126ban219s as Big_getInstance } from './bitops-library-endian.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+initMetadataForCompanion(Companion);
+initMetadataForClass(Bit32Digest, 'Bit32Digest', VOID, Digest);
+initMetadataForCompanion(Companion_0);
+initMetadataForClass(SHA256, 'SHA256', SHA256_init_$Create$, Bit32Digest);
+//endregion
+function Bit32Digest_init_$Init$(bitStrength, h, $this) {
+  Digest_init_$Init$('SHA-' + bitStrength, 64, bitStrength / 8 | 0, $this);
+  Bit32Digest.call($this);
+  $this.s6z_1 = h;
+  $this.t6z_1 = new Int32Array(64);
+  var tmp = $this;
+  // Inline function 'kotlin.collections.copyOf' call
+  // Inline function 'kotlin.js.asDynamic' call
+  tmp.u6z_1 = h.slice();
+  $this.v6z_1 = Bit32_init_$Create$(64);
+  return $this;
+}
+function Companion() {
+  Companion_instance = this;
+  this.w6z_1 = 64;
+  var tmp = this;
+  // Inline function 'kotlin.intArrayOf' call
+  tmp.x6z_1 = new Int32Array([1116352408, 1899447441, -1245643825, -373957723, 961987163, 1508970993, -1841331548, -1424204075, -670586216, 310598401, 607225278, 1426881987, 1925078388, -2132889090, -1680079193, -1046744716, -459576895, -272742522, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, -1740746414, -1473132947, -1341970488, -1084653625, -958395405, -710438585, 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, -2117940946, -1838011259, -1564481375, -1474664885, -1035236496, -949202525, -778901479, -694614492, -200395387, 275423344, 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, 1955562222, 2024104815, -2067236844, -1933114872, -1866530822, -1538233109, -1090935817, -965641998]);
+}
+var Companion_instance;
+function Companion_getInstance() {
+  if (Companion_instance == null)
+    new Companion();
+  return Companion_instance;
+}
+protoOf(Bit32Digest).p6y = function (input, offset) {
+  var x = this.t6z_1;
+  Big_getInstance();
+  // Inline function 'org.kotlincrypto.bitops.endian.Big.bePackIntoUnsafe' call
+  var sourceIndexEnd = offset + 64 | 0;
+  Big_getInstance().n6z(input, x, 0, offset, sourceIndexEnd);
+  var inductionVariable = 16;
+  if (inductionVariable < 64)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      var x15 = x[i - 15 | 0];
+      var s0 = (x15 >>> 7 | 0 | x15 << 25) ^ (x15 >>> 18 | 0 | x15 << 14) ^ (x15 >>> 3 | 0);
+      var x2 = x[i - 2 | 0];
+      var s1 = (x2 >>> 17 | 0 | x2 << 15) ^ (x2 >>> 19 | 0 | x2 << 13) ^ (x2 >>> 10 | 0);
+      var x16 = x[i - 16 | 0];
+      var x7 = x[i - 7 | 0];
+      x[i] = ((x16 + s0 | 0) + x7 | 0) + s1 | 0;
+    }
+     while (inductionVariable < 64);
+  var k = Companion_getInstance().x6z_1;
+  var state = this.u6z_1;
+  var a = state[0];
+  var b = state[1];
+  var c = state[2];
+  var d = state[3];
+  var e = state[4];
+  var f = state[5];
+  var g = state[6];
+  var h = state[7];
+  var inductionVariable_0 = 0;
+  if (inductionVariable_0 < 64)
+    do {
+      var i_0 = inductionVariable_0;
+      inductionVariable_0 = inductionVariable_0 + 1 | 0;
+      var s0_0 = (a >>> 2 | 0 | a << 30) ^ (a >>> 13 | 0 | a << 19) ^ (a >>> 22 | 0 | a << 10);
+      var s1_0 = (e >>> 6 | 0 | e << 26) ^ (e >>> 11 | 0 | e << 21) ^ (e >>> 25 | 0 | e << 7);
+      var ch = e & f ^ ~e & g;
+      var maj = a & b ^ a & c ^ b & c;
+      var t1 = (((h + s1_0 | 0) + ch | 0) + k[i_0] | 0) + x[i_0] | 0;
+      var t2 = s0_0 + maj | 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+     while (inductionVariable_0 < 64);
+  state[0] = state[0] + a | 0;
+  state[1] = state[1] + b | 0;
+  state[2] = state[2] + c | 0;
+  state[3] = state[3] + d | 0;
+  state[4] = state[4] + e | 0;
+  state[5] = state[5] + f | 0;
+  state[6] = state[6] + g | 0;
+  state[7] = state[7] + h | 0;
+  this.v6z_1.a6z();
+};
+protoOf(Bit32Digest).n6y = function (buf, bufPos) {
+  var digest = new Int8Array(this.i6y());
+  this.y6z(digest, 0, buf, bufPos);
+  return digest;
+};
+protoOf(Bit32Digest).y6z = function (dest, destOffset, buf, bufPos) {
+  var tmp0_container = this.v6z_1.b6z(bufPos).y6y();
+  var bitsLo = tmp0_container.na();
+  var bitsHi = tmp0_container.oa();
+  buf[bufPos] = -128;
+  if ((bufPos + 1 | 0) > 56) {
+    this.p6y(buf, 0);
+    fill(buf, 0, 0, 56);
+  }
+  // Inline function 'org.kotlincrypto.bitops.endian.Big.bePackIntoUnsafe' call
+  Big_getInstance();
+  Big_getInstance().l6z(bitsHi, buf, 56);
+  // Inline function 'org.kotlincrypto.bitops.endian.Big.bePackIntoUnsafe' call
+  Big_getInstance();
+  Big_getInstance().l6z(bitsLo, buf, 60);
+  this.p6y(buf, 0);
+  Big_getInstance();
+  var tmp2 = this.u6z_1;
+  // Inline function 'org.kotlincrypto.bitops.endian.Big.bePackIntoUnsafe' call
+  var sourceIndexEnd = this.i6y() / 4 | 0;
+  Big_getInstance().m6z(tmp2, dest, destOffset, 0, sourceIndexEnd);
+};
+protoOf(Bit32Digest).o6y = function () {
+  fill_0(this.t6z_1, 0);
+  var tmp0 = this.s6z_1;
+  // Inline function 'kotlin.collections.copyInto' call
+  var destination = this.u6z_1;
+  var endIndex = tmp0.length;
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp = tmp0;
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  arrayCopy(tmp, destination, 0, 0, endIndex);
+  this.v6z_1.c6z();
+};
+function Bit32Digest() {
+  Companion_getInstance();
+}
+function SHA256_init_$Init$($this) {
+  Bit32Digest_init_$Init$(256, Companion_getInstance_0().z6z_1, $this);
+  SHA256.call($this);
+  return $this;
+}
+function SHA256_init_$Create$() {
+  return SHA256_init_$Init$(objectCreate(protoOf(SHA256)));
+}
+function Companion_0() {
+  Companion_instance_0 = this;
+  var tmp = this;
+  // Inline function 'kotlin.intArrayOf' call
+  tmp.z6z_1 = new Int32Array([1779033703, -1150833019, 1013904242, -1521486534, 1359893119, -1694144372, 528734635, 1541459225]);
+}
+var Companion_instance_0;
+function Companion_getInstance_0() {
+  if (Companion_instance_0 == null)
+    new Companion_0();
+  return Companion_instance_0;
+}
+function SHA256() {
+  Companion_getInstance_0();
+}
+//region block: exports
+export {
+  SHA256_init_$Create$ as SHA256_init_$Create$1g9q29rq575z3,
+};
+//endregion

package/internal/BytesEncoding.d.mts

@@ -0,0 +1,3 @@
+export declare function decodeBase64(s: string, path: string[]): Int8Array;
+export declare function decodeBase64(s: string | undefined, path: string[]): Int8Array | undefined;
+export declare function encodeBase64(bytes: Int8Array): string;

package/internal/BytesEncoding.mjs

@@ -0,0 +1,99 @@
+function bytesAsString(bytes) {
+    let str = '';
+    const ab = new Uint8Array(bytes.buffer);
+    const abLen = ab.length;
+    const CHUNK_SIZE = Math.pow(2, 8);
+    let offset, len, subab;
+    for (offset = 0; offset < abLen; offset += CHUNK_SIZE) {
+        len = Math.min(CHUNK_SIZE, abLen - offset);
+        subab = ab.subarray(offset, offset + len);
+        str += String.fromCharCode.apply(null, subab);
+    }
+    return str;
+}
+function stringAsBytes(s) {
+    const res = new Int8Array(s.length);
+    const asUa = new Uint8Array(res.buffer);
+    for (let i = 0; i < s.length; i++) {
+        asUa[i] = s.charCodeAt(i) & 0xff;
+    }
+    return res;
+}
+function b2a(a) {
+    if (typeof window !== 'undefined') {
+        //Favour btoa in browser
+        if (typeof btoa !== 'undefined') {
+            return btoa(a);
+        }
+        // @ts-ignore
+        if (typeof Buffer !== 'undefined') {
+            // @ts-ignore
+            const buf = Buffer.from(a, 'latin1');
+            return buf.toString('base64');
+        }
+    }
+    else {
+        // @ts-ignore
+        if (typeof Buffer !== 'undefined') {
+            // @ts-ignore
+            const buf = Buffer.from(a, 'latin1');
+            return buf.toString('base64');
+        }
+        if (typeof btoa !== 'undefined') {
+            return btoa(a);
+        }
+    }
+    throw new Error('Unsupported operation b2a');
+}
+// Check if the input is a valid base64 string, returning null if invalid, or the properly padded string otherwise.
+// If the input is already padded but the amount of padding is wrong the method returns null else it is retuned as is
+function validateAndPadBase64(str) {
+    if (str.length % 4 === 1)
+        return null;
+    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(str))
+        return null;
+    const padding = (str.match(/=*$/) || [''])[0].length;
+    if (padding > 2)
+        return null;
+    if (padding > 0 && str.length % 4 !== 0)
+        return null;
+    return (padding > 0) ? str : str + '==='.slice((str.length + 3) % 4);
+}
+function a2b(s) {
+    if (typeof window !== 'undefined') {
+        //Favour atob in browser
+        if (typeof atob !== 'undefined') {
+            return atob(s);
+        }
+        // @ts-ignore
+        if (typeof Buffer !== 'undefined') {
+            // @ts-ignore
+            const buf = new Buffer(s, 'base64');
+            return buf.toString('latin1');
+        }
+    }
+    else {
+        // @ts-ignore
+        if (typeof Buffer !== 'undefined') {
+            // @ts-ignore
+            const buf = new Buffer(s, 'base64');
+            return buf.toString('latin1');
+        }
+        if (typeof atob !== 'undefined') {
+            return atob(s);
+        }
+    }
+    throw new Error('Unsupported operation a2b');
+}
+export function decodeBase64(s, path) {
+    if (s == undefined)
+        return undefined;
+    const padded = validateAndPadBase64(s);
+    if (padded == null)
+        throw new Error(`Invalid base64 string '${s}' at ${path.join()}`);
+    return stringAsBytes(a2b(s));
+}
+// Encode an Int8Array to a base64 string using the url-unsafe alphabet
+export function encodeBase64(bytes) {
+    return b2a(bytesAsString(bytes));
+}

package/internal/JsonDecodeUtils.d.mts

@@ -0,0 +1,20 @@
+export declare function extractEntry(json: any, name: string, required: boolean, path: string[]): any;
+export declare function expectObject<T>(json: any, nullable: true, ignoreUnknown: boolean, path: string[], decoder: (j: any, i: boolean, p: string[]) => T): T | undefined;
+export declare function expectObject<T>(json: any, nullable: false, ignoreUnknown: boolean, path: string[], decoder: (j: any, i: boolean, p: string[]) => T): T;
+export declare function expectNullish(json: any, path: string[]): undefined;
+export declare function expectString(json: any, nullable: true, path: string[]): string | undefined;
+export declare function expectString(json: any, nullable: false, path: string[]): string;
+export declare function expectBoolean(json: any, nullable: true, path: string[]): boolean | undefined;
+export declare function expectBoolean(json: any, nullable: false, path: string[]): boolean;
+export declare function expectNumber(json: any, nullable: true, integer: boolean, path: string[]): number | undefined;
+export declare function expectNumber(json: any, nullable: false, integer: boolean, path: string[]): number;
+export declare function expectArray<T>(json: any, nullable: true, path: string[], transform: (item: any, path: string[]) => T): T[] | undefined;
+export declare function expectArray<T>(json: any, nullable: false, path: string[], transform: (item: any, path: string[]) => T): T[];
+export declare function expectMap<K extends string | number, V>(json: any, nullable: true, path: string[], mapKey: (key: string, path: string[]) => K, mapValue: (value: any, path: string[]) => V): Record<K, V> | undefined;
+export declare function expectMap<K extends string | number, V>(json: any, nullable: false, path: string[], mapKey: (key: string, path: string[]) => K, mapValue: (value: any, path: string[]) => V): Record<K, V>;
+export declare function expectStringEnum<T extends {
+    [key: string]: string;
+}>(json: any, nullable: true, path: string[], enumType: T, enumName: string): T[keyof T] | undefined;
+export declare function expectStringEnum<T extends {
+    [key: string]: string;
+}>(json: any, nullable: false, path: string[], enumType: T, enumName: string): T[keyof T];