zeed 1.3.0 → 1.4.0

package/dist/common/crypto/xaes.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"xaes.cjs","names":["ensureUint8Array"],"sources":["../../../src/common/crypto/xaes.ts"],"sourcesContent":["// Original at https://github.com/dchest/xaes MIT License as of 2024-07-02\n// More at https://words.filippo.io/dispatches/xaes-256-gcm/\n\nimport { ensureUint8Array } from '../data/bin'\n\n/**\n * Implementation of XAES-256-GCM as defined in https://c2sp.org/XAES-256-GCM\n * based on the Web Cryptography API (https://www.w3.org/TR/WebCryptoAPI/).\n *\n * It uses a 256-bit AES-CBC CryptoKey and a 192-bit nonce to derive\n * a 256-bit key and a 96-bit nonce for AES-GCM.\n *\n * Due to the use of the standard CryptoKey and Web Cryptography API operations,\n * this implementation is fully compatible with other parts of the Web Cryptography API.\n * For example, keys can be stored in IndexedDB and be non-extractable. The only\n * additional requirement is that the key must have 'encrypt' usage even for decryption,\n * however, there's no real distinction between encryption and decryption operations\n * for AES-GCM anyway (you can simulate decryption by encrypting the ciphertext).\n */\n\n/**\n * Generates an AES block using the given key and data xored with the given xor.\n */\nasync function aesBlock(key: CryptoKey, data: BufferSource, xor: BufferSource): Promise<Uint8Array> {\n  const block = await crypto.subtle.encrypt(\n    { name: 'AES-CBC', iv: xor },\n    key,\n    data,\n  )\n  return new Uint8Array(block, 0, 16)\n}\n\n/**\n * Derives a half key.\n */\nasync function halfKey(index: number, key: CryptoKey, iv: Uint8Array, k1: Uint8Array): Promise<Uint8Array> {\n  const m = new Uint8Array(16)\n  m[1] = index\n  m[2] = 0x58 // 'X'\n  m.set(ensureUint8Array(iv.subarray(0, 12)), 4)\n  return await aesBlock(key, m, ensureUint8Array(k1))\n}\n\n/**\n * Derives a 256-bit key and 96-bit nonce from the given 256-bit key and a 192-bit nonce.\n */\nasync function deriveKeyNonce(key: CryptoKey, iv: BufferSource): Promise<{ key: CryptoKey, iv: Uint8Array }> {\n  if (key.algorithm.name !== 'AES-CBC') {\n    throw new Error('key must be for AES-CBC')\n  }\n  if (!key.usages.includes('encrypt')) {\n    throw new Error('key must have \\'encrypt\\' usage')\n  }\n  // @ts-expect-error todo\n  if (key.algorithm.length !== 256) {\n    throw new Error('key must be 256 bits')\n  }\n  if (iv == null || iv.byteLength !== 24) {\n    throw new Error('iv must be 24 bytes')\n  }\n  const ivBytes = ArrayBuffer.isView(iv)\n    ? new Uint8Array(iv.buffer, iv.byteOffset, iv.byteLength)\n    : new Uint8Array(iv)\n  const k1 = await aesBlock(key, new Uint8Array(16), new Uint8Array(16))\n\n  let msb = 0\n  for (let i = k1.length - 1; i >= 0; i--) {\n    [msb, k1[i]] = [(k1[i] >>> 7) & 0xFF, ((k1[i] << 1) | msb) & 0xFF]\n  }\n  k1[k1.length - 1] ^= (msb * 0b10000111) & 0xFF\n\n  const kxBytes = new Uint8Array(32)\n  kxBytes.set(await halfKey(0x01, key, ivBytes, k1), 0)\n  kxBytes.set(await halfKey(0x02, key, ivBytes, k1), 16)\n\n  const kx = await crypto.subtle.importKey(\n    'raw',\n    kxBytes,\n    { name: 'AES-GCM', length: 256 },\n    false,\n    [...key.usages],\n  )\n  return {\n    key: kx,\n    iv: ensureUint8Array(ivBytes.subarray(12)),\n  }\n}\n/**\n * Encrypts data using XAES-256-GCM with the given key and iv.\n * Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' usage.\n */\nexport async function encryptXAES(params: {\n  iv: BufferSource\n  additionalData?: BufferSource\n}, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer> {\n  const derived = await deriveKeyNonce(key, params.iv)\n  return await crypto.subtle.encrypt(\n    {\n      name: 'AES-GCM',\n      iv: derived.iv as BufferSource,\n      tagLength: 128,\n      additionalData: params.additionalData ?? new Uint8Array(),\n    },\n    derived.key,\n    data,\n  )\n}\n\n/**\n * Decrypts data using XAES-256-GCM with the given key and iv.\n * Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' and 'decrypt' usages.\n */\nexport async function decryptXAES(params: {\n  iv: BufferSource\n  additionalData?: BufferSource\n}, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer> {\n  const derived = await deriveKeyNonce(key, params.iv)\n  return await crypto.subtle.decrypt(\n    {\n      name: 'AES-GCM',\n      iv: derived.iv as BufferSource,\n      tagLength: 128,\n      additionalData: params.additionalData ?? new Uint8Array(),\n    },\n    derived.key,\n    data,\n  )\n}\n\n/**\n * Generate a random key suitable for XAES-256-GCM.\n * The actual key is an AES-CBC CryptoKey with 256-bit length.\n *\n * This function is not necessary, as you can use crypto.subtle.generateKey with AES-CBC directly.\n */\nexport async function generateKeyXAES(extractable?: boolean): Promise<CryptoKey> {\n  return await crypto.subtle.generateKey(\n    {\n      name: 'AES-CBC',\n      // @ts-expect-error todo\n      length: 256,\n    },\n    extractable,\n    ['encrypt', 'decrypt'],\n  )\n}\n\n/**\n * Import a key suitable for XAES-256-GCM.\n * The actual key must be an AES-CBC CryptoKey with 256-bit length.\n *\n * This function is not necessary, as you can use crypto.subtle.importKey with AES-CBC directly.\n */\nexport async function importKeyXAES(format: 'jwk' | 'raw' | 'pkcs8' | 'spki', keyData: BufferSource | JsonWebKey, extractable?: boolean): Promise<CryptoKey> {\n  return await crypto.subtle.importKey( // @ts-expect-error-next-line\n    format,\n    keyData,\n    { name: 'AES-CBC', length: 256 },\n    extractable,\n    ['encrypt', 'decrypt'],\n  )\n}\n\n/**\n * Export a key.\n * The resulting export will have AES-CBC algorithm specified.\n *\n * This function is not necessary, as you can use crypto.subtle.exportKey directly.\n */\nexport async function exportKeyXAES(format: 'jwk' | 'pkcs8' | 'raw' | 'spki', key: CryptoKey): Promise<ArrayBuffer | JsonWebKey> {\n  return await crypto.subtle.exportKey(format, key)\n}\n"],"mappings":"6GAuBA,eAAe,EAAS,EAAgB,EAAoB,EAAwC,CAClG,IAAM,EAAQ,MAAM,OAAO,OAAO,QAChC,CAAE,KAAM,UAAW,GAAI,EAAK,CAC5B,EACA,EACD,CACD,OAAO,IAAI,WAAW,EAAO,EAAG,GAAG,CAMrC,eAAe,EAAQ,EAAe,EAAgB,EAAgB,EAAqC,CACzG,IAAM,EAAI,IAAI,WAAW,GAAG,CAI5B,MAHA,GAAE,GAAK,EACP,EAAE,GAAK,GACP,EAAE,IAAIA,EAAAA,EAAiB,EAAG,SAAS,EAAG,GAAG,CAAC,CAAE,EAAE,CACvC,MAAM,EAAS,EAAK,EAAGA,EAAAA,EAAiB,EAAG,CAAC,CAMrD,eAAe,EAAe,EAAgB,EAA+D,CAC3G,GAAI,EAAI,UAAU,OAAS,UACzB,MAAU,MAAM,0BAA0B,CAE5C,GAAI,CAAC,EAAI,OAAO,SAAS,UAAU,CACjC,MAAU,MAAM,gCAAkC,CAGpD,GAAI,EAAI,UAAU,SAAW,IAC3B,MAAU,MAAM,uBAAuB,CAEzC,GAAI,GAAM,MAAQ,EAAG,aAAe,GAClC,MAAU,MAAM,sBAAsB,CAExC,IAAM,EAAU,YAAY,OAAO,EAAG,CAClC,IAAI,WAAW,EAAG,OAAQ,EAAG,WAAY,EAAG,WAAW,CACvD,IAAI,WAAW,EAAG,CAChB,EAAK,MAAM,EAAS,EAAK,IAAI,WAAW,GAAG,CAAE,IAAI,WAAW,GAAG,CAAC,CAElE,EAAM,EACV,IAAK,IAAI,EAAI,EAAG,OAAS,EAAG,GAAK,EAAG,IAClC,CAAC,EAAK,EAAG,IAAM,CAAE,EAAG,KAAO,EAAK,KAAQ,EAAG,IAAM,EAAK,GAAO,IAAK,CAEpE,EAAG,EAAG,OAAS,IAAO,EAAM,IAAc,IAE1C,IAAM,EAAU,IAAI,WAAW,GAAG,CAWlC,OAVA,EAAQ,IAAI,MAAM,EAAQ,EAAM,EAAK,EAAS,EAAG,CAAE,EAAE,CACrD,EAAQ,IAAI,MAAM,EAAQ,EAAM,EAAK,EAAS,EAAG,CAAE,GAAG,CAS/C,CACL,IARS,MAAM,OAAO,OAAO,UAC7B,MACA,EACA,CAAE,KAAM,UAAW,OAAQ,IAAK,CAChC,GACA,CAAC,GAAG,EAAI,OAAO,CAChB,CAGC,GAAIA,EAAAA,EAAiB,EAAQ,SAAS,GAAG,CAAC,CAC3C,CAMH,eAAsB,EAAY,EAG/B,EAAgB,EAA0C,CAC3D,IAAM,EAAU,MAAM,EAAe,EAAK,EAAO,GAAG,CACpD,OAAO,MAAM,OAAO,OAAO,QACzB,CACE,KAAM,UACN,GAAI,EAAQ,GACZ,UAAW,IACX,eAAgB,EAAO,gBAAkB,IAAI,WAC9C,CACD,EAAQ,IACR,EACD,CAOH,eAAsB,EAAY,EAG/B,EAAgB,EAA0C,CAC3D,IAAM,EAAU,MAAM,EAAe,EAAK,EAAO,GAAG,CACpD,OAAO,MAAM,OAAO,OAAO,QACzB,CACE,KAAM,UACN,GAAI,EAAQ,GACZ,UAAW,IACX,eAAgB,EAAO,gBAAkB,IAAI,WAC9C,CACD,EAAQ,IACR,EACD,CASH,eAAsB,EAAgB,EAA2C,CAC/E,OAAO,MAAM,OAAO,OAAO,YACzB,CACE,KAAM,UAEN,OAAQ,IACT,CACD,EACA,CAAC,UAAW,UAAU,CACvB,CASH,eAAsB,EAAc,EAA0C,EAAoC,EAA2C,CAC3J,OAAO,MAAM,OAAO,OAAO,UACzB,EACA,EACA,CAAE,KAAM,UAAW,OAAQ,IAAK,CAChC,EACA,CAAC,UAAW,UAAU,CACvB,CASH,eAAsB,EAAc,EAA0C,EAAmD,CAC/H,OAAO,MAAM,OAAO,OAAO,UAAU,EAAQ,EAAI"}
+{"version":3,"file":"xaes.cjs","names":["ensureUint8Array"],"sources":["../../../src/common/crypto/xaes.ts"],"sourcesContent":["// Original at https://github.com/dchest/xaes MIT License as of 2024-07-02\n// More at https://words.filippo.io/dispatches/xaes-256-gcm/\n\nimport { ensureUint8Array } from '../data/bin'\n\n/**\n * Implementation of XAES-256-GCM as defined in https://c2sp.org/XAES-256-GCM\n * based on the Web Cryptography API (https://www.w3.org/TR/WebCryptoAPI/).\n *\n * It uses a 256-bit AES-CBC CryptoKey and a 192-bit nonce to derive\n * a 256-bit key and a 96-bit nonce for AES-GCM.\n *\n * Due to the use of the standard CryptoKey and Web Cryptography API operations,\n * this implementation is fully compatible with other parts of the Web Cryptography API.\n * For example, keys can be stored in IndexedDB and be non-extractable. The only\n * additional requirement is that the key must have 'encrypt' usage even for decryption,\n * however, there's no real distinction between encryption and decryption operations\n * for AES-GCM anyway (you can simulate decryption by encrypting the ciphertext).\n */\n\n/**\n * Generates an AES block using the given key and data xored with the given xor.\n */\nasync function aesBlock(key: CryptoKey, data: BufferSource, xor: BufferSource): Promise<Uint8Array> {\n  const block = await crypto.subtle.encrypt(\n    { name: 'AES-CBC', iv: xor },\n    key,\n    data,\n  )\n  return new Uint8Array(block, 0, 16)\n}\n\n/**\n * Derives a half key.\n */\nasync function halfKey(index: number, key: CryptoKey, iv: Uint8Array, k1: Uint8Array): Promise<Uint8Array> {\n  const m = new Uint8Array(16)\n  m[1] = index\n  m[2] = 0x58 // 'X'\n  m.set(ensureUint8Array(iv.subarray(0, 12)), 4)\n  return await aesBlock(key, m, ensureUint8Array(k1))\n}\n\n/**\n * Derives a 256-bit key and 96-bit nonce from the given 256-bit key and a 192-bit nonce.\n */\nasync function deriveKeyNonce(key: CryptoKey, iv: BufferSource): Promise<{ key: CryptoKey, iv: Uint8Array }> {\n  if (key.algorithm.name !== 'AES-CBC') {\n    throw new Error('key must be for AES-CBC')\n  }\n  if (!key.usages.includes('encrypt')) {\n    throw new Error('key must have \\'encrypt\\' usage')\n  }\n  // @ts-expect-error todo\n  if (key.algorithm.length !== 256) {\n    throw new Error('key must be 256 bits')\n  }\n  if (iv == null || iv.byteLength !== 24) {\n    throw new Error('iv must be 24 bytes')\n  }\n  const ivBytes = ArrayBuffer.isView(iv)\n    ? new Uint8Array(iv.buffer, iv.byteOffset, iv.byteLength)\n    : new Uint8Array(iv)\n  const k1 = await aesBlock(key, new Uint8Array(16), new Uint8Array(16))\n\n  let msb = 0\n  for (let i = k1.length - 1; i >= 0; i--) {\n    [msb, k1[i]] = [(k1[i] >>> 7) & 0xFF, ((k1[i] << 1) | msb) & 0xFF]\n  }\n  k1[k1.length - 1] ^= (msb * 0b10000111) & 0xFF\n\n  const kxBytes = new Uint8Array(32)\n  kxBytes.set(await halfKey(0x01, key, ivBytes, k1), 0)\n  kxBytes.set(await halfKey(0x02, key, ivBytes, k1), 16)\n\n  const kx = await crypto.subtle.importKey(\n    'raw',\n    kxBytes,\n    { name: 'AES-GCM', length: 256 },\n    false,\n    [...key.usages],\n  )\n  return {\n    key: kx,\n    iv: ensureUint8Array(ivBytes.subarray(12)),\n  }\n}\n/**\n * Encrypts data using XAES-256-GCM with the given key and iv.\n * Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' usage.\n */\nexport async function encryptXAES(params: {\n  iv: BufferSource\n  additionalData?: BufferSource\n}, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer> {\n  const derived = await deriveKeyNonce(key, params.iv)\n  return await crypto.subtle.encrypt(\n    {\n      name: 'AES-GCM',\n      iv: derived.iv as BufferSource,\n      tagLength: 128,\n      additionalData: params.additionalData ?? new Uint8Array(),\n    },\n    derived.key,\n    data,\n  )\n}\n\n/**\n * Decrypts data using XAES-256-GCM with the given key and iv.\n * Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' and 'decrypt' usages.\n */\nexport async function decryptXAES(params: {\n  iv: BufferSource\n  additionalData?: BufferSource\n}, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer> {\n  const derived = await deriveKeyNonce(key, params.iv)\n  return await crypto.subtle.decrypt(\n    {\n      name: 'AES-GCM',\n      iv: derived.iv as BufferSource,\n      tagLength: 128,\n      additionalData: params.additionalData ?? new Uint8Array(),\n    },\n    derived.key,\n    data,\n  )\n}\n\n/**\n * Generate a random key suitable for XAES-256-GCM.\n * The actual key is an AES-CBC CryptoKey with 256-bit length.\n *\n * This function is not necessary, as you can use crypto.subtle.generateKey with AES-CBC directly.\n */\nexport async function generateKeyXAES(extractable?: boolean): Promise<CryptoKey> {\n  return await crypto.subtle.generateKey(\n    {\n      name: 'AES-CBC',\n      // @ts-expect-error todo\n      length: 256,\n    },\n    extractable,\n    ['encrypt', 'decrypt'],\n  )\n}\n\n/**\n * Import a key suitable for XAES-256-GCM.\n * The actual key must be an AES-CBC CryptoKey with 256-bit length.\n *\n * This function is not necessary, as you can use crypto.subtle.importKey with AES-CBC directly.\n */\nexport async function importKeyXAES(format: 'jwk' | 'raw' | 'pkcs8' | 'spki', keyData: BufferSource | JsonWebKey, extractable?: boolean): Promise<CryptoKey> {\n  return await crypto.subtle.importKey( // @ts-expect-error-next-line\n    format,\n    keyData,\n    { name: 'AES-CBC', length: 256 },\n    extractable,\n    ['encrypt', 'decrypt'],\n  )\n}\n\n/**\n * Export a key.\n * The resulting export will have AES-CBC algorithm specified.\n *\n * This function is not necessary, as you can use crypto.subtle.exportKey directly.\n */\nexport async function exportKeyXAES(format: 'jwk' | 'pkcs8' | 'raw' | 'spki', key: CryptoKey): Promise<ArrayBuffer | JsonWebKey> {\n  return await crypto.subtle.exportKey(format, key)\n}\n"],"mappings":"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"}

package/dist/common/crypto/xaes.mjs

@@ -1,2 +1,124 @@
-import{o as e}from"../../bin-SPdenYkw.mjs";async function t(e,t,n){let r=await crypto.subtle.encrypt({name:`AES-CBC`,iv:n},e,t);return new Uint8Array(r,0,16)}async function n(n,r,i,a){let o=new Uint8Array(16);return o[1]=n,o[2]=88,o.set(e(i.subarray(0,12)),4),await t(r,o,e(a))}async function r(r,i){if(r.algorithm.name!==`AES-CBC`)throw Error(`key must be for AES-CBC`);if(!r.usages.includes(`encrypt`))throw Error(`key must have 'encrypt' usage`);if(r.algorithm.length!==256)throw Error(`key must be 256 bits`);if(i==null||i.byteLength!==24)throw Error(`iv must be 24 bytes`);let a=ArrayBuffer.isView(i)?new Uint8Array(i.buffer,i.byteOffset,i.byteLength):new Uint8Array(i),o=await t(r,new Uint8Array(16),new Uint8Array(16)),s=0;for(let e=o.length-1;e>=0;e--)[s,o[e]]=[o[e]>>>7&255,(o[e]<<1|s)&255];o[o.length-1]^=s*135&255;let c=new Uint8Array(32);return c.set(await n(1,r,a,o),0),c.set(await n(2,r,a,o),16),{key:await crypto.subtle.importKey(`raw`,c,{name:`AES-GCM`,length:256},!1,[...r.usages]),iv:e(a.subarray(12))}}async function i(e,t,n){let i=await r(t,e.iv);return await crypto.subtle.encrypt({name:`AES-GCM`,iv:i.iv,tagLength:128,additionalData:e.additionalData??new Uint8Array},i.key,n)}async function a(e,t,n){let i=await r(t,e.iv);return await crypto.subtle.decrypt({name:`AES-GCM`,iv:i.iv,tagLength:128,additionalData:e.additionalData??new Uint8Array},i.key,n)}async function o(e){return await crypto.subtle.generateKey({name:`AES-CBC`,length:256},e,[`encrypt`,`decrypt`])}async function s(e,t,n){return await crypto.subtle.importKey(e,t,{name:`AES-CBC`,length:256},n,[`encrypt`,`decrypt`])}async function c(e,t){return await crypto.subtle.exportKey(e,t)}export{a as decryptXAES,i as encryptXAES,c as exportKeyXAES,o as generateKeyXAES,s as importKeyXAES};
+import { o as ensureUint8Array } from "../../bin-BAoS4qtm.mjs";
+
+//#region src/common/crypto/xaes.ts
+/**
+* Implementation of XAES-256-GCM as defined in https://c2sp.org/XAES-256-GCM
+* based on the Web Cryptography API (https://www.w3.org/TR/WebCryptoAPI/).
+*
+* It uses a 256-bit AES-CBC CryptoKey and a 192-bit nonce to derive
+* a 256-bit key and a 96-bit nonce for AES-GCM.
+*
+* Due to the use of the standard CryptoKey and Web Cryptography API operations,
+* this implementation is fully compatible with other parts of the Web Cryptography API.
+* For example, keys can be stored in IndexedDB and be non-extractable. The only
+* additional requirement is that the key must have 'encrypt' usage even for decryption,
+* however, there's no real distinction between encryption and decryption operations
+* for AES-GCM anyway (you can simulate decryption by encrypting the ciphertext).
+*/
+/**
+* Generates an AES block using the given key and data xored with the given xor.
+*/
+async function aesBlock(key, data, xor) {
+	const block = await crypto.subtle.encrypt({
+		name: "AES-CBC",
+		iv: xor
+	}, key, data);
+	return new Uint8Array(block, 0, 16);
+}
+/**
+* Derives a half key.
+*/
+async function halfKey(index, key, iv, k1) {
+	const m = new Uint8Array(16);
+	m[1] = index;
+	m[2] = 88;
+	m.set(ensureUint8Array(iv.subarray(0, 12)), 4);
+	return await aesBlock(key, m, ensureUint8Array(k1));
+}
+/**
+* Derives a 256-bit key and 96-bit nonce from the given 256-bit key and a 192-bit nonce.
+*/
+async function deriveKeyNonce(key, iv) {
+	if (key.algorithm.name !== "AES-CBC") throw new Error("key must be for AES-CBC");
+	if (!key.usages.includes("encrypt")) throw new Error("key must have 'encrypt' usage");
+	if (key.algorithm.length !== 256) throw new Error("key must be 256 bits");
+	if (iv == null || iv.byteLength !== 24) throw new Error("iv must be 24 bytes");
+	const ivBytes = ArrayBuffer.isView(iv) ? new Uint8Array(iv.buffer, iv.byteOffset, iv.byteLength) : new Uint8Array(iv);
+	const k1 = await aesBlock(key, new Uint8Array(16), new Uint8Array(16));
+	let msb = 0;
+	for (let i = k1.length - 1; i >= 0; i--) [msb, k1[i]] = [k1[i] >>> 7 & 255, (k1[i] << 1 | msb) & 255];
+	k1[k1.length - 1] ^= msb * 135 & 255;
+	const kxBytes = new Uint8Array(32);
+	kxBytes.set(await halfKey(1, key, ivBytes, k1), 0);
+	kxBytes.set(await halfKey(2, key, ivBytes, k1), 16);
+	return {
+		key: await crypto.subtle.importKey("raw", kxBytes, {
+			name: "AES-GCM",
+			length: 256
+		}, false, [...key.usages]),
+		iv: ensureUint8Array(ivBytes.subarray(12))
+	};
+}
+/**
+* Encrypts data using XAES-256-GCM with the given key and iv.
+* Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' usage.
+*/
+async function encryptXAES(params, key, data) {
+	const derived = await deriveKeyNonce(key, params.iv);
+	return await crypto.subtle.encrypt({
+		name: "AES-GCM",
+		iv: derived.iv,
+		tagLength: 128,
+		additionalData: params.additionalData ?? new Uint8Array()
+	}, derived.key, data);
+}
+/**
+* Decrypts data using XAES-256-GCM with the given key and iv.
+* Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' and 'decrypt' usages.
+*/
+async function decryptXAES(params, key, data) {
+	const derived = await deriveKeyNonce(key, params.iv);
+	return await crypto.subtle.decrypt({
+		name: "AES-GCM",
+		iv: derived.iv,
+		tagLength: 128,
+		additionalData: params.additionalData ?? new Uint8Array()
+	}, derived.key, data);
+}
+/**
+* Generate a random key suitable for XAES-256-GCM.
+* The actual key is an AES-CBC CryptoKey with 256-bit length.
+*
+* This function is not necessary, as you can use crypto.subtle.generateKey with AES-CBC directly.
+*/
+async function generateKeyXAES(extractable) {
+	return await crypto.subtle.generateKey({
+		name: "AES-CBC",
+		length: 256
+	}, extractable, ["encrypt", "decrypt"]);
+}
+/**
+* Import a key suitable for XAES-256-GCM.
+* The actual key must be an AES-CBC CryptoKey with 256-bit length.
+*
+* This function is not necessary, as you can use crypto.subtle.importKey with AES-CBC directly.
+*/
+async function importKeyXAES(format, keyData, extractable) {
+	return await crypto.subtle.importKey(format, keyData, {
+		name: "AES-CBC",
+		length: 256
+	}, extractable, ["encrypt", "decrypt"]);
+}
+/**
+* Export a key.
+* The resulting export will have AES-CBC algorithm specified.
+*
+* This function is not necessary, as you can use crypto.subtle.exportKey directly.
+*/
+async function exportKeyXAES(format, key) {
+	return await crypto.subtle.exportKey(format, key);
+}
+
+//#endregion
+export { decryptXAES, encryptXAES, exportKeyXAES, generateKeyXAES, importKeyXAES };
 //# sourceMappingURL=xaes.mjs.map

package/dist/common/crypto/xaes.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"xaes.mjs","names":[],"sources":["../../../src/common/crypto/xaes.ts"],"sourcesContent":["// Original at https://github.com/dchest/xaes MIT License as of 2024-07-02\n// More at https://words.filippo.io/dispatches/xaes-256-gcm/\n\nimport { ensureUint8Array } from '../data/bin'\n\n/**\n * Implementation of XAES-256-GCM as defined in https://c2sp.org/XAES-256-GCM\n * based on the Web Cryptography API (https://www.w3.org/TR/WebCryptoAPI/).\n *\n * It uses a 256-bit AES-CBC CryptoKey and a 192-bit nonce to derive\n * a 256-bit key and a 96-bit nonce for AES-GCM.\n *\n * Due to the use of the standard CryptoKey and Web Cryptography API operations,\n * this implementation is fully compatible with other parts of the Web Cryptography API.\n * For example, keys can be stored in IndexedDB and be non-extractable. The only\n * additional requirement is that the key must have 'encrypt' usage even for decryption,\n * however, there's no real distinction between encryption and decryption operations\n * for AES-GCM anyway (you can simulate decryption by encrypting the ciphertext).\n */\n\n/**\n * Generates an AES block using the given key and data xored with the given xor.\n */\nasync function aesBlock(key: CryptoKey, data: BufferSource, xor: BufferSource): Promise<Uint8Array> {\n  const block = await crypto.subtle.encrypt(\n    { name: 'AES-CBC', iv: xor },\n    key,\n    data,\n  )\n  return new Uint8Array(block, 0, 16)\n}\n\n/**\n * Derives a half key.\n */\nasync function halfKey(index: number, key: CryptoKey, iv: Uint8Array, k1: Uint8Array): Promise<Uint8Array> {\n  const m = new Uint8Array(16)\n  m[1] = index\n  m[2] = 0x58 // 'X'\n  m.set(ensureUint8Array(iv.subarray(0, 12)), 4)\n  return await aesBlock(key, m, ensureUint8Array(k1))\n}\n\n/**\n * Derives a 256-bit key and 96-bit nonce from the given 256-bit key and a 192-bit nonce.\n */\nasync function deriveKeyNonce(key: CryptoKey, iv: BufferSource): Promise<{ key: CryptoKey, iv: Uint8Array }> {\n  if (key.algorithm.name !== 'AES-CBC') {\n    throw new Error('key must be for AES-CBC')\n  }\n  if (!key.usages.includes('encrypt')) {\n    throw new Error('key must have \\'encrypt\\' usage')\n  }\n  // @ts-expect-error todo\n  if (key.algorithm.length !== 256) {\n    throw new Error('key must be 256 bits')\n  }\n  if (iv == null || iv.byteLength !== 24) {\n    throw new Error('iv must be 24 bytes')\n  }\n  const ivBytes = ArrayBuffer.isView(iv)\n    ? new Uint8Array(iv.buffer, iv.byteOffset, iv.byteLength)\n    : new Uint8Array(iv)\n  const k1 = await aesBlock(key, new Uint8Array(16), new Uint8Array(16))\n\n  let msb = 0\n  for (let i = k1.length - 1; i >= 0; i--) {\n    [msb, k1[i]] = [(k1[i] >>> 7) & 0xFF, ((k1[i] << 1) | msb) & 0xFF]\n  }\n  k1[k1.length - 1] ^= (msb * 0b10000111) & 0xFF\n\n  const kxBytes = new Uint8Array(32)\n  kxBytes.set(await halfKey(0x01, key, ivBytes, k1), 0)\n  kxBytes.set(await halfKey(0x02, key, ivBytes, k1), 16)\n\n  const kx = await crypto.subtle.importKey(\n    'raw',\n    kxBytes,\n    { name: 'AES-GCM', length: 256 },\n    false,\n    [...key.usages],\n  )\n  return {\n    key: kx,\n    iv: ensureUint8Array(ivBytes.subarray(12)),\n  }\n}\n/**\n * Encrypts data using XAES-256-GCM with the given key and iv.\n * Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' usage.\n */\nexport async function encryptXAES(params: {\n  iv: BufferSource\n  additionalData?: BufferSource\n}, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer> {\n  const derived = await deriveKeyNonce(key, params.iv)\n  return await crypto.subtle.encrypt(\n    {\n      name: 'AES-GCM',\n      iv: derived.iv as BufferSource,\n      tagLength: 128,\n      additionalData: params.additionalData ?? new Uint8Array(),\n    },\n    derived.key,\n    data,\n  )\n}\n\n/**\n * Decrypts data using XAES-256-GCM with the given key and iv.\n * Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' and 'decrypt' usages.\n */\nexport async function decryptXAES(params: {\n  iv: BufferSource\n  additionalData?: BufferSource\n}, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer> {\n  const derived = await deriveKeyNonce(key, params.iv)\n  return await crypto.subtle.decrypt(\n    {\n      name: 'AES-GCM',\n      iv: derived.iv as BufferSource,\n      tagLength: 128,\n      additionalData: params.additionalData ?? new Uint8Array(),\n    },\n    derived.key,\n    data,\n  )\n}\n\n/**\n * Generate a random key suitable for XAES-256-GCM.\n * The actual key is an AES-CBC CryptoKey with 256-bit length.\n *\n * This function is not necessary, as you can use crypto.subtle.generateKey with AES-CBC directly.\n */\nexport async function generateKeyXAES(extractable?: boolean): Promise<CryptoKey> {\n  return await crypto.subtle.generateKey(\n    {\n      name: 'AES-CBC',\n      // @ts-expect-error todo\n      length: 256,\n    },\n    extractable,\n    ['encrypt', 'decrypt'],\n  )\n}\n\n/**\n * Import a key suitable for XAES-256-GCM.\n * The actual key must be an AES-CBC CryptoKey with 256-bit length.\n *\n * This function is not necessary, as you can use crypto.subtle.importKey with AES-CBC directly.\n */\nexport async function importKeyXAES(format: 'jwk' | 'raw' | 'pkcs8' | 'spki', keyData: BufferSource | JsonWebKey, extractable?: boolean): Promise<CryptoKey> {\n  return await crypto.subtle.importKey( // @ts-expect-error-next-line\n    format,\n    keyData,\n    { name: 'AES-CBC', length: 256 },\n    extractable,\n    ['encrypt', 'decrypt'],\n  )\n}\n\n/**\n * Export a key.\n * The resulting export will have AES-CBC algorithm specified.\n *\n * This function is not necessary, as you can use crypto.subtle.exportKey directly.\n */\nexport async function exportKeyXAES(format: 'jwk' | 'pkcs8' | 'raw' | 'spki', key: CryptoKey): Promise<ArrayBuffer | JsonWebKey> {\n  return await crypto.subtle.exportKey(format, key)\n}\n"],"mappings":"2CAuBA,eAAe,EAAS,EAAgB,EAAoB,EAAwC,CAClG,IAAM,EAAQ,MAAM,OAAO,OAAO,QAChC,CAAE,KAAM,UAAW,GAAI,EAAK,CAC5B,EACA,EACD,CACD,OAAO,IAAI,WAAW,EAAO,EAAG,GAAG,CAMrC,eAAe,EAAQ,EAAe,EAAgB,EAAgB,EAAqC,CACzG,IAAM,EAAI,IAAI,WAAW,GAAG,CAI5B,MAHA,GAAE,GAAK,EACP,EAAE,GAAK,GACP,EAAE,IAAI,EAAiB,EAAG,SAAS,EAAG,GAAG,CAAC,CAAE,EAAE,CACvC,MAAM,EAAS,EAAK,EAAG,EAAiB,EAAG,CAAC,CAMrD,eAAe,EAAe,EAAgB,EAA+D,CAC3G,GAAI,EAAI,UAAU,OAAS,UACzB,MAAU,MAAM,0BAA0B,CAE5C,GAAI,CAAC,EAAI,OAAO,SAAS,UAAU,CACjC,MAAU,MAAM,gCAAkC,CAGpD,GAAI,EAAI,UAAU,SAAW,IAC3B,MAAU,MAAM,uBAAuB,CAEzC,GAAI,GAAM,MAAQ,EAAG,aAAe,GAClC,MAAU,MAAM,sBAAsB,CAExC,IAAM,EAAU,YAAY,OAAO,EAAG,CAClC,IAAI,WAAW,EAAG,OAAQ,EAAG,WAAY,EAAG,WAAW,CACvD,IAAI,WAAW,EAAG,CAChB,EAAK,MAAM,EAAS,EAAK,IAAI,WAAW,GAAG,CAAE,IAAI,WAAW,GAAG,CAAC,CAElE,EAAM,EACV,IAAK,IAAI,EAAI,EAAG,OAAS,EAAG,GAAK,EAAG,IAClC,CAAC,EAAK,EAAG,IAAM,CAAE,EAAG,KAAO,EAAK,KAAQ,EAAG,IAAM,EAAK,GAAO,IAAK,CAEpE,EAAG,EAAG,OAAS,IAAO,EAAM,IAAc,IAE1C,IAAM,EAAU,IAAI,WAAW,GAAG,CAWlC,OAVA,EAAQ,IAAI,MAAM,EAAQ,EAAM,EAAK,EAAS,EAAG,CAAE,EAAE,CACrD,EAAQ,IAAI,MAAM,EAAQ,EAAM,EAAK,EAAS,EAAG,CAAE,GAAG,CAS/C,CACL,IARS,MAAM,OAAO,OAAO,UAC7B,MACA,EACA,CAAE,KAAM,UAAW,OAAQ,IAAK,CAChC,GACA,CAAC,GAAG,EAAI,OAAO,CAChB,CAGC,GAAI,EAAiB,EAAQ,SAAS,GAAG,CAAC,CAC3C,CAMH,eAAsB,EAAY,EAG/B,EAAgB,EAA0C,CAC3D,IAAM,EAAU,MAAM,EAAe,EAAK,EAAO,GAAG,CACpD,OAAO,MAAM,OAAO,OAAO,QACzB,CACE,KAAM,UACN,GAAI,EAAQ,GACZ,UAAW,IACX,eAAgB,EAAO,gBAAkB,IAAI,WAC9C,CACD,EAAQ,IACR,EACD,CAOH,eAAsB,EAAY,EAG/B,EAAgB,EAA0C,CAC3D,IAAM,EAAU,MAAM,EAAe,EAAK,EAAO,GAAG,CACpD,OAAO,MAAM,OAAO,OAAO,QACzB,CACE,KAAM,UACN,GAAI,EAAQ,GACZ,UAAW,IACX,eAAgB,EAAO,gBAAkB,IAAI,WAC9C,CACD,EAAQ,IACR,EACD,CASH,eAAsB,EAAgB,EAA2C,CAC/E,OAAO,MAAM,OAAO,OAAO,YACzB,CACE,KAAM,UAEN,OAAQ,IACT,CACD,EACA,CAAC,UAAW,UAAU,CACvB,CASH,eAAsB,EAAc,EAA0C,EAAoC,EAA2C,CAC3J,OAAO,MAAM,OAAO,OAAO,UACzB,EACA,EACA,CAAE,KAAM,UAAW,OAAQ,IAAK,CAChC,EACA,CAAC,UAAW,UAAU,CACvB,CASH,eAAsB,EAAc,EAA0C,EAAmD,CAC/H,OAAO,MAAM,OAAO,OAAO,UAAU,EAAQ,EAAI"}
+{"version":3,"file":"xaes.mjs","names":[],"sources":["../../../src/common/crypto/xaes.ts"],"sourcesContent":["// Original at https://github.com/dchest/xaes MIT License as of 2024-07-02\n// More at https://words.filippo.io/dispatches/xaes-256-gcm/\n\nimport { ensureUint8Array } from '../data/bin'\n\n/**\n * Implementation of XAES-256-GCM as defined in https://c2sp.org/XAES-256-GCM\n * based on the Web Cryptography API (https://www.w3.org/TR/WebCryptoAPI/).\n *\n * It uses a 256-bit AES-CBC CryptoKey and a 192-bit nonce to derive\n * a 256-bit key and a 96-bit nonce for AES-GCM.\n *\n * Due to the use of the standard CryptoKey and Web Cryptography API operations,\n * this implementation is fully compatible with other parts of the Web Cryptography API.\n * For example, keys can be stored in IndexedDB and be non-extractable. The only\n * additional requirement is that the key must have 'encrypt' usage even for decryption,\n * however, there's no real distinction between encryption and decryption operations\n * for AES-GCM anyway (you can simulate decryption by encrypting the ciphertext).\n */\n\n/**\n * Generates an AES block using the given key and data xored with the given xor.\n */\nasync function aesBlock(key: CryptoKey, data: BufferSource, xor: BufferSource): Promise<Uint8Array> {\n  const block = await crypto.subtle.encrypt(\n    { name: 'AES-CBC', iv: xor },\n    key,\n    data,\n  )\n  return new Uint8Array(block, 0, 16)\n}\n\n/**\n * Derives a half key.\n */\nasync function halfKey(index: number, key: CryptoKey, iv: Uint8Array, k1: Uint8Array): Promise<Uint8Array> {\n  const m = new Uint8Array(16)\n  m[1] = index\n  m[2] = 0x58 // 'X'\n  m.set(ensureUint8Array(iv.subarray(0, 12)), 4)\n  return await aesBlock(key, m, ensureUint8Array(k1))\n}\n\n/**\n * Derives a 256-bit key and 96-bit nonce from the given 256-bit key and a 192-bit nonce.\n */\nasync function deriveKeyNonce(key: CryptoKey, iv: BufferSource): Promise<{ key: CryptoKey, iv: Uint8Array }> {\n  if (key.algorithm.name !== 'AES-CBC') {\n    throw new Error('key must be for AES-CBC')\n  }\n  if (!key.usages.includes('encrypt')) {\n    throw new Error('key must have \\'encrypt\\' usage')\n  }\n  // @ts-expect-error todo\n  if (key.algorithm.length !== 256) {\n    throw new Error('key must be 256 bits')\n  }\n  if (iv == null || iv.byteLength !== 24) {\n    throw new Error('iv must be 24 bytes')\n  }\n  const ivBytes = ArrayBuffer.isView(iv)\n    ? new Uint8Array(iv.buffer, iv.byteOffset, iv.byteLength)\n    : new Uint8Array(iv)\n  const k1 = await aesBlock(key, new Uint8Array(16), new Uint8Array(16))\n\n  let msb = 0\n  for (let i = k1.length - 1; i >= 0; i--) {\n    [msb, k1[i]] = [(k1[i] >>> 7) & 0xFF, ((k1[i] << 1) | msb) & 0xFF]\n  }\n  k1[k1.length - 1] ^= (msb * 0b10000111) & 0xFF\n\n  const kxBytes = new Uint8Array(32)\n  kxBytes.set(await halfKey(0x01, key, ivBytes, k1), 0)\n  kxBytes.set(await halfKey(0x02, key, ivBytes, k1), 16)\n\n  const kx = await crypto.subtle.importKey(\n    'raw',\n    kxBytes,\n    { name: 'AES-GCM', length: 256 },\n    false,\n    [...key.usages],\n  )\n  return {\n    key: kx,\n    iv: ensureUint8Array(ivBytes.subarray(12)),\n  }\n}\n/**\n * Encrypts data using XAES-256-GCM with the given key and iv.\n * Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' usage.\n */\nexport async function encryptXAES(params: {\n  iv: BufferSource\n  additionalData?: BufferSource\n}, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer> {\n  const derived = await deriveKeyNonce(key, params.iv)\n  return await crypto.subtle.encrypt(\n    {\n      name: 'AES-GCM',\n      iv: derived.iv as BufferSource,\n      tagLength: 128,\n      additionalData: params.additionalData ?? new Uint8Array(),\n    },\n    derived.key,\n    data,\n  )\n}\n\n/**\n * Decrypts data using XAES-256-GCM with the given key and iv.\n * Key must be a 256-bit AES-CBC CryptoKey with 'encrypt' and 'decrypt' usages.\n */\nexport async function decryptXAES(params: {\n  iv: BufferSource\n  additionalData?: BufferSource\n}, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer> {\n  const derived = await deriveKeyNonce(key, params.iv)\n  return await crypto.subtle.decrypt(\n    {\n      name: 'AES-GCM',\n      iv: derived.iv as BufferSource,\n      tagLength: 128,\n      additionalData: params.additionalData ?? new Uint8Array(),\n    },\n    derived.key,\n    data,\n  )\n}\n\n/**\n * Generate a random key suitable for XAES-256-GCM.\n * The actual key is an AES-CBC CryptoKey with 256-bit length.\n *\n * This function is not necessary, as you can use crypto.subtle.generateKey with AES-CBC directly.\n */\nexport async function generateKeyXAES(extractable?: boolean): Promise<CryptoKey> {\n  return await crypto.subtle.generateKey(\n    {\n      name: 'AES-CBC',\n      // @ts-expect-error todo\n      length: 256,\n    },\n    extractable,\n    ['encrypt', 'decrypt'],\n  )\n}\n\n/**\n * Import a key suitable for XAES-256-GCM.\n * The actual key must be an AES-CBC CryptoKey with 256-bit length.\n *\n * This function is not necessary, as you can use crypto.subtle.importKey with AES-CBC directly.\n */\nexport async function importKeyXAES(format: 'jwk' | 'raw' | 'pkcs8' | 'spki', keyData: BufferSource | JsonWebKey, extractable?: boolean): Promise<CryptoKey> {\n  return await crypto.subtle.importKey( // @ts-expect-error-next-line\n    format,\n    keyData,\n    { name: 'AES-CBC', length: 256 },\n    extractable,\n    ['encrypt', 'decrypt'],\n  )\n}\n\n/**\n * Export a key.\n * The resulting export will have AES-CBC algorithm specified.\n *\n * This function is not necessary, as you can use crypto.subtle.exportKey directly.\n */\nexport async function exportKeyXAES(format: 'jwk' | 'pkcs8' | 'raw' | 'spki', key: CryptoKey): Promise<ArrayBuffer | JsonWebKey> {\n  return await crypto.subtle.exportKey(format, key)\n}\n"],"mappings":"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"}

package/dist/common/csv.cjs

@@ -1,5 +1,50 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./data/json.cjs`),t=require(`./data/is.cjs`),n=require(`./data/regexp.cjs`);function r(n,r={}){let{separator:i=`,`}=r,a=``;r.addBom&&(a=``);for(let r=0;r<n.length;r++)a+=`${n[r].map(n=>{if(n==null||n===``)return``;if(t.isBoolean(n))return n?1:0;let r=String(n);return(t.isRecord(n)||t.isArray(n))&&(r=e.jsonStringifySafe(n)),r.includes(`"`)||r.includes(`
-`)||r.includes(i)?`"${r.replace(/"/g,`""`)}"`:r}).join(i)}\n`;return a}function i(e,t={}){let r=/("((?:(?:[^"]*?)(?:"")?)*)"|([^,;\t\n]*))([,;\t\n]|\r\n)/g;t.separator&&(r=new RegExp(r.source.replace(/',;\\t/g,n.escapeRegExp(t.separator)),r.flags));let i=[],a=[],o,s=`${e.replace(/\r\n/g,`
-`).trim()}\n`;for(;o=r.exec(s);){let e=o[2]??o[3]??``;e=e.replace(/""/g,`"`),a.push(e),o[4]===`
-`&&(i.push(a),a=[])}return i}function a(e,t={}){let n=i(e,t),r=n[0];return n.slice(1).map(e=>Object.fromEntries(e.map((e,t)=>[r[t],e])))}exports.csvParse=i,exports.csvParseToObjects=a,exports.csvStringify=r;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_common_data_json = require('./data/json.cjs');
+const require_common_data_is = require('./data/is.cjs');
+const require_common_data_regexp = require('./data/regexp.cjs');
+
+//#region src/common/csv.ts
+const defaultSeparator = ",";
+function csvStringify(data, opt = {}) {
+	const { separator = defaultSeparator } = opt;
+	let body = "";
+	if (opt.addBom) body = "";
+	for (let i = 0; i < data.length; i++) body += `${data[i].map((field) => {
+		if (field == null || field === "") return "";
+		if (require_common_data_is.isBoolean(field)) return field ? 1 : 0;
+		let s = String(field);
+		if (require_common_data_is.isRecord(field) || require_common_data_is.isArray(field)) s = require_common_data_json.jsonStringifySafe(field);
+		if (s.includes("\"") || s.includes("\n") || s.includes(separator)) return `"${s.replace(/"/g, "\"\"")}"`;
+		return s;
+	}).join(separator)}\n`;
+	return body;
+}
+function csvParse(raw, opt = {}) {
+	let rxOneValueWithSeparator = /("((?:(?:[^"]*?)(?:"")?)*)"|([^,;\t\n]*))([,;\t\n]|\r\n)/g;
+	if (opt.separator) rxOneValueWithSeparator = new RegExp(rxOneValueWithSeparator.source.replace(/',;\\t/g, require_common_data_regexp.escapeRegExp(opt.separator)), rxOneValueWithSeparator.flags);
+	const lines = [];
+	let row = [];
+	let m;
+	const text = `${raw.replace(/\r\n/g, "\n").trim()}\n`;
+	while (m = rxOneValueWithSeparator.exec(text)) {
+		let value = m[2] ?? m[3] ?? "";
+		value = value.replace(/""/g, "\"");
+		row.push(value);
+		if (m[4] === "\n") {
+			lines.push(row);
+			row = [];
+		}
+	}
+	return lines;
+}
+function csvParseToObjects(raw, opt = {}) {
+	const lines = csvParse(raw, opt);
+	const header = lines[0];
+	return lines.slice(1).map((l) => Object.fromEntries(l.map((v, i) => [header[i], v])));
+}
+
+//#endregion
+exports.csvParse = csvParse;
+exports.csvParseToObjects = csvParseToObjects;
+exports.csvStringify = csvStringify;
 //# sourceMappingURL=csv.cjs.map

package/dist/common/csv.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"csv.cjs","names":["isBoolean","isRecord","isArray","jsonStringifySafe","escapeRegExp"],"sources":["../../src/common/csv.ts"],"sourcesContent":["import { isArray, isBoolean, isRecord } from './data/is'\nimport { jsonStringifySafe } from './data/json'\nimport { escapeRegExp } from './data/regexp'\n\nconst defaultSeparator = ','\n\nexport function csvStringify(data: any[], opt: {\n  // header?: string[]\n  separator?: string\n  addBom?: boolean // option to add byte order mark for improved Excel support\n} = {}): string {\n  const { separator = defaultSeparator } = opt\n  let body = ''\n  if (opt.addBom)\n    body = '\\uFEFF'\n\n  // Append the header row to the response if requested\n  // if (header)\n  //   body = `${header.join(separator)}\\n`\n\n  // Convert the data to a CSV-like structure\n  for (let i = 0; i < data.length; i++) {\n    body += `${data[i].map((field: string) => {\n      if (field == null || field === '')\n        return ''\n      if (isBoolean(field))\n        return field ? 1 : 0\n      let s = String(field)\n      if (isRecord(field) || isArray(field))\n        s = jsonStringifySafe(field)\n      if (s.includes('\"') || s.includes('\\n') || s.includes(separator))\n        return `\"${s.replace(/\"/g, '\"\"')}\"`\n      return s\n    }).join(separator)}\\n`\n  }\n\n  return body\n}\n\nexport function csvParse(raw: string, opt: {\n  separator?: string\n} = {}) {\n  // https://regex101.com/r/BCpKyV/1\n  // eslint-disable-next-line regexp/no-unused-capturing-group, regexp/no-super-linear-backtracking, regexp/no-dupe-disjunctions, regexp/no-useless-non-capturing-group\n  let rxOneValueWithSeparator = /(\"((?:(?:[^\"]*?)(?:\"\")?)*)\"|([^,;\\t\\n]*))([,;\\t\\n]|\\r\\n)/g\n  if (opt.separator)\n    rxOneValueWithSeparator = new RegExp(rxOneValueWithSeparator.source.replace(/',;\\\\t/g, escapeRegExp(opt.separator)), rxOneValueWithSeparator.flags)\n\n  const lines: any[][] = []\n  let row: any[] = []\n  let m: any\n  const text = `${raw.replace(/\\r\\n/g, '\\n').trim()}\\n`\n\n  // eslint-disable-next-line no-cond-assign\n  while (m = rxOneValueWithSeparator.exec(text)) {\n    let value = m[2] ?? m[3] ?? ''\n    value = value.replace(/\"\"/g, '\"')\n    row.push(value)\n    if (m[4] === '\\n') {\n      lines.push(row)\n      row = []\n    }\n  }\n  return lines\n}\n\nexport function csvParseToObjects(raw: string, opt: {\n  separator?: string\n} = {}) {\n  const lines = csvParse(raw, opt)\n  const header = lines[0]\n  return lines.slice(1).map(l =>\n    Object.fromEntries (l.map((v, i) => [header[i], v])),\n  )\n}\n"],"mappings":"gKAMA,SAAgB,EAAa,EAAa,EAItC,EAAE,CAAU,CACd,GAAM,CAAE,YAAY,KAAqB,EACrC,EAAO,GACP,EAAI,SACN,EAAO,KAOT,IAAK,IAAI,EAAI,EAAG,EAAI,EAAK,OAAQ,IAC/B,GAAQ,GAAG,EAAK,GAAG,IAAK,GAAkB,CACxC,GAAI,GAAS,MAAQ,IAAU,GAC7B,MAAO,GACT,GAAIA,EAAAA,UAAU,EAAM,CAClB,OAAO,EAAQ,EAAI,EACrB,IAAI,EAAI,OAAO,EAAM,CAKrB,OAJIC,EAAAA,SAAS,EAAM,EAAIC,EAAAA,QAAQ,EAAM,IACnC,EAAIC,EAAAA,kBAAkB,EAAM,EAC1B,EAAE,SAAS,IAAI,EAAI,EAAE,SAAS;EAAK,EAAI,EAAE,SAAS,EAAU,CACvD,IAAI,EAAE,QAAQ,KAAM,KAAK,CAAC,GAC5B,GACP,CAAC,KAAK,EAAU,CAAC,IAGrB,OAAO,EAGT,SAAgB,EAAS,EAAa,EAElC,EAAE,CAAE,CAGN,IAAI,EAA0B,4DAC1B,EAAI,YACN,EAA0B,IAAI,OAAO,EAAwB,OAAO,QAAQ,UAAWC,EAAAA,aAAa,EAAI,UAAU,CAAC,CAAE,EAAwB,MAAM,EAErJ,IAAM,EAAiB,EAAE,CACrB,EAAa,EAAE,CACf,EACE,EAAO,GAAG,EAAI,QAAQ,QAAS;EAAK,CAAC,MAAM,CAAC,IAGlD,KAAO,EAAI,EAAwB,KAAK,EAAK,EAAE,CAC7C,IAAI,EAAQ,EAAE,IAAM,EAAE,IAAM,GAC5B,EAAQ,EAAM,QAAQ,MAAO,IAAI,CACjC,EAAI,KAAK,EAAM,CACX,EAAE,KAAO;IACX,EAAM,KAAK,EAAI,CACf,EAAM,EAAE,EAGZ,OAAO,EAGT,SAAgB,EAAkB,EAAa,EAE3C,EAAE,CAAE,CACN,IAAM,EAAQ,EAAS,EAAK,EAAI,CAC1B,EAAS,EAAM,GACrB,OAAO,EAAM,MAAM,EAAE,CAAC,IAAI,GACxB,OAAO,YAAa,EAAE,KAAK,EAAG,IAAM,CAAC,EAAO,GAAI,EAAE,CAAC,CAAC,CACrD"}
+{"version":3,"file":"csv.cjs","names":["isBoolean","isRecord","isArray","jsonStringifySafe","escapeRegExp"],"sources":["../../src/common/csv.ts"],"sourcesContent":["import { isArray, isBoolean, isRecord } from './data/is'\nimport { jsonStringifySafe } from './data/json'\nimport { escapeRegExp } from './data/regexp'\n\nconst defaultSeparator = ','\n\nexport function csvStringify(data: any[], opt: {\n  // header?: string[]\n  separator?: string\n  addBom?: boolean // option to add byte order mark for improved Excel support\n} = {}): string {\n  const { separator = defaultSeparator } = opt\n  let body = ''\n  if (opt.addBom)\n    body = '\\uFEFF'\n\n  // Append the header row to the response if requested\n  // if (header)\n  //   body = `${header.join(separator)}\\n`\n\n  // Convert the data to a CSV-like structure\n  for (let i = 0; i < data.length; i++) {\n    body += `${data[i].map((field: string) => {\n      if (field == null || field === '')\n        return ''\n      if (isBoolean(field))\n        return field ? 1 : 0\n      let s = String(field)\n      if (isRecord(field) || isArray(field))\n        s = jsonStringifySafe(field)\n      if (s.includes('\"') || s.includes('\\n') || s.includes(separator))\n        return `\"${s.replace(/\"/g, '\"\"')}\"`\n      return s\n    }).join(separator)}\\n`\n  }\n\n  return body\n}\n\nexport function csvParse(raw: string, opt: {\n  separator?: string\n} = {}) {\n  // https://regex101.com/r/BCpKyV/1\n  // eslint-disable-next-line regexp/no-unused-capturing-group, regexp/no-super-linear-backtracking, regexp/no-dupe-disjunctions, regexp/no-useless-non-capturing-group\n  let rxOneValueWithSeparator = /(\"((?:(?:[^\"]*?)(?:\"\")?)*)\"|([^,;\\t\\n]*))([,;\\t\\n]|\\r\\n)/g\n  if (opt.separator)\n    rxOneValueWithSeparator = new RegExp(rxOneValueWithSeparator.source.replace(/',;\\\\t/g, escapeRegExp(opt.separator)), rxOneValueWithSeparator.flags)\n\n  const lines: any[][] = []\n  let row: any[] = []\n  let m: any\n  const text = `${raw.replace(/\\r\\n/g, '\\n').trim()}\\n`\n\n  // eslint-disable-next-line no-cond-assign\n  while (m = rxOneValueWithSeparator.exec(text)) {\n    let value = m[2] ?? m[3] ?? ''\n    value = value.replace(/\"\"/g, '\"')\n    row.push(value)\n    if (m[4] === '\\n') {\n      lines.push(row)\n      row = []\n    }\n  }\n  return lines\n}\n\nexport function csvParseToObjects(raw: string, opt: {\n  separator?: string\n} = {}) {\n  const lines = csvParse(raw, opt)\n  const header = lines[0]\n  return lines.slice(1).map(l =>\n    Object.fromEntries (l.map((v, i) => [header[i], v])),\n  )\n}\n"],"mappings":";;;;;;AAIA,MAAM,mBAAmB;AAEzB,SAAgB,aAAa,MAAa,MAItC,EAAE,EAAU;CACd,MAAM,EAAE,YAAY,qBAAqB;CACzC,IAAI,OAAO;AACX,KAAI,IAAI,OACN,QAAO;AAOT,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,IAC/B,SAAQ,GAAG,KAAK,GAAG,KAAK,UAAkB;AACxC,MAAI,SAAS,QAAQ,UAAU,GAC7B,QAAO;AACT,MAAIA,iCAAU,MAAM,CAClB,QAAO,QAAQ,IAAI;EACrB,IAAI,IAAI,OAAO,MAAM;AACrB,MAAIC,gCAAS,MAAM,IAAIC,+BAAQ,MAAM,CACnC,KAAIC,2CAAkB,MAAM;AAC9B,MAAI,EAAE,SAAS,KAAI,IAAI,EAAE,SAAS,KAAK,IAAI,EAAE,SAAS,UAAU,CAC9D,QAAO,IAAI,EAAE,QAAQ,MAAM,OAAK,CAAC;AACnC,SAAO;GACP,CAAC,KAAK,UAAU,CAAC;AAGrB,QAAO;;AAGT,SAAgB,SAAS,KAAa,MAElC,EAAE,EAAE;CAGN,IAAI,0BAA0B;AAC9B,KAAI,IAAI,UACN,2BAA0B,IAAI,OAAO,wBAAwB,OAAO,QAAQ,WAAWC,wCAAa,IAAI,UAAU,CAAC,EAAE,wBAAwB,MAAM;CAErJ,MAAM,QAAiB,EAAE;CACzB,IAAI,MAAa,EAAE;CACnB,IAAI;CACJ,MAAM,OAAO,GAAG,IAAI,QAAQ,SAAS,KAAK,CAAC,MAAM,CAAC;AAGlD,QAAO,IAAI,wBAAwB,KAAK,KAAK,EAAE;EAC7C,IAAI,QAAQ,EAAE,MAAM,EAAE,MAAM;AAC5B,UAAQ,MAAM,QAAQ,OAAO,KAAI;AACjC,MAAI,KAAK,MAAM;AACf,MAAI,EAAE,OAAO,MAAM;AACjB,SAAM,KAAK,IAAI;AACf,SAAM,EAAE;;;AAGZ,QAAO;;AAGT,SAAgB,kBAAkB,KAAa,MAE3C,EAAE,EAAE;CACN,MAAM,QAAQ,SAAS,KAAK,IAAI;CAChC,MAAM,SAAS,MAAM;AACrB,QAAO,MAAM,MAAM,EAAE,CAAC,KAAI,MACxB,OAAO,YAAa,EAAE,KAAK,GAAG,MAAM,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,CACrD"}

package/dist/common/csv.mjs

@@ -1,5 +1,47 @@
-import{jsonStringifySafe as e}from"./data/json.mjs";import{isArray as t,isBoolean as n,isRecord as r}from"./data/is.mjs";import{escapeRegExp as i}from"./data/regexp.mjs";function a(i,a={}){let{separator:o=`,`}=a,s=``;a.addBom&&(s=``);for(let a=0;a<i.length;a++)s+=`${i[a].map(i=>{if(i==null||i===``)return``;if(n(i))return i?1:0;let a=String(i);return(r(i)||t(i))&&(a=e(i)),a.includes(`"`)||a.includes(`
-`)||a.includes(o)?`"${a.replace(/"/g,`""`)}"`:a}).join(o)}\n`;return s}function o(e,t={}){let n=/("((?:(?:[^"]*?)(?:"")?)*)"|([^,;\t\n]*))([,;\t\n]|\r\n)/g;t.separator&&(n=new RegExp(n.source.replace(/',;\\t/g,i(t.separator)),n.flags));let r=[],a=[],o,s=`${e.replace(/\r\n/g,`
-`).trim()}\n`;for(;o=n.exec(s);){let e=o[2]??o[3]??``;e=e.replace(/""/g,`"`),a.push(e),o[4]===`
-`&&(r.push(a),a=[])}return r}function s(e,t={}){let n=o(e,t),r=n[0];return n.slice(1).map(e=>Object.fromEntries(e.map((e,t)=>[r[t],e])))}export{o as csvParse,s as csvParseToObjects,a as csvStringify};
+import { jsonStringifySafe } from "./data/json.mjs";
+import { isArray, isBoolean, isRecord } from "./data/is.mjs";
+import { escapeRegExp } from "./data/regexp.mjs";
+
+//#region src/common/csv.ts
+const defaultSeparator = ",";
+function csvStringify(data, opt = {}) {
+	const { separator = defaultSeparator } = opt;
+	let body = "";
+	if (opt.addBom) body = "";
+	for (let i = 0; i < data.length; i++) body += `${data[i].map((field) => {
+		if (field == null || field === "") return "";
+		if (isBoolean(field)) return field ? 1 : 0;
+		let s = String(field);
+		if (isRecord(field) || isArray(field)) s = jsonStringifySafe(field);
+		if (s.includes("\"") || s.includes("\n") || s.includes(separator)) return `"${s.replace(/"/g, "\"\"")}"`;
+		return s;
+	}).join(separator)}\n`;
+	return body;
+}
+function csvParse(raw, opt = {}) {
+	let rxOneValueWithSeparator = /("((?:(?:[^"]*?)(?:"")?)*)"|([^,;\t\n]*))([,;\t\n]|\r\n)/g;
+	if (opt.separator) rxOneValueWithSeparator = new RegExp(rxOneValueWithSeparator.source.replace(/',;\\t/g, escapeRegExp(opt.separator)), rxOneValueWithSeparator.flags);
+	const lines = [];
+	let row = [];
+	let m;
+	const text = `${raw.replace(/\r\n/g, "\n").trim()}\n`;
+	while (m = rxOneValueWithSeparator.exec(text)) {
+		let value = m[2] ?? m[3] ?? "";
+		value = value.replace(/""/g, "\"");
+		row.push(value);
+		if (m[4] === "\n") {
+			lines.push(row);
+			row = [];
+		}
+	}
+	return lines;
+}
+function csvParseToObjects(raw, opt = {}) {
+	const lines = csvParse(raw, opt);
+	const header = lines[0];
+	return lines.slice(1).map((l) => Object.fromEntries(l.map((v, i) => [header[i], v])));
+}
+
+//#endregion
+export { csvParse, csvParseToObjects, csvStringify };
 //# sourceMappingURL=csv.mjs.map

package/dist/common/csv.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"csv.mjs","names":[],"sources":["../../src/common/csv.ts"],"sourcesContent":["import { isArray, isBoolean, isRecord } from './data/is'\nimport { jsonStringifySafe } from './data/json'\nimport { escapeRegExp } from './data/regexp'\n\nconst defaultSeparator = ','\n\nexport function csvStringify(data: any[], opt: {\n  // header?: string[]\n  separator?: string\n  addBom?: boolean // option to add byte order mark for improved Excel support\n} = {}): string {\n  const { separator = defaultSeparator } = opt\n  let body = ''\n  if (opt.addBom)\n    body = '\\uFEFF'\n\n  // Append the header row to the response if requested\n  // if (header)\n  //   body = `${header.join(separator)}\\n`\n\n  // Convert the data to a CSV-like structure\n  for (let i = 0; i < data.length; i++) {\n    body += `${data[i].map((field: string) => {\n      if (field == null || field === '')\n        return ''\n      if (isBoolean(field))\n        return field ? 1 : 0\n      let s = String(field)\n      if (isRecord(field) || isArray(field))\n        s = jsonStringifySafe(field)\n      if (s.includes('\"') || s.includes('\\n') || s.includes(separator))\n        return `\"${s.replace(/\"/g, '\"\"')}\"`\n      return s\n    }).join(separator)}\\n`\n  }\n\n  return body\n}\n\nexport function csvParse(raw: string, opt: {\n  separator?: string\n} = {}) {\n  // https://regex101.com/r/BCpKyV/1\n  // eslint-disable-next-line regexp/no-unused-capturing-group, regexp/no-super-linear-backtracking, regexp/no-dupe-disjunctions, regexp/no-useless-non-capturing-group\n  let rxOneValueWithSeparator = /(\"((?:(?:[^\"]*?)(?:\"\")?)*)\"|([^,;\\t\\n]*))([,;\\t\\n]|\\r\\n)/g\n  if (opt.separator)\n    rxOneValueWithSeparator = new RegExp(rxOneValueWithSeparator.source.replace(/',;\\\\t/g, escapeRegExp(opt.separator)), rxOneValueWithSeparator.flags)\n\n  const lines: any[][] = []\n  let row: any[] = []\n  let m: any\n  const text = `${raw.replace(/\\r\\n/g, '\\n').trim()}\\n`\n\n  // eslint-disable-next-line no-cond-assign\n  while (m = rxOneValueWithSeparator.exec(text)) {\n    let value = m[2] ?? m[3] ?? ''\n    value = value.replace(/\"\"/g, '\"')\n    row.push(value)\n    if (m[4] === '\\n') {\n      lines.push(row)\n      row = []\n    }\n  }\n  return lines\n}\n\nexport function csvParseToObjects(raw: string, opt: {\n  separator?: string\n} = {}) {\n  const lines = csvParse(raw, opt)\n  const header = lines[0]\n  return lines.slice(1).map(l =>\n    Object.fromEntries (l.map((v, i) => [header[i], v])),\n  )\n}\n"],"mappings":"0KAMA,SAAgB,EAAa,EAAa,EAItC,EAAE,CAAU,CACd,GAAM,CAAE,YAAY,KAAqB,EACrC,EAAO,GACP,EAAI,SACN,EAAO,KAOT,IAAK,IAAI,EAAI,EAAG,EAAI,EAAK,OAAQ,IAC/B,GAAQ,GAAG,EAAK,GAAG,IAAK,GAAkB,CACxC,GAAI,GAAS,MAAQ,IAAU,GAC7B,MAAO,GACT,GAAI,EAAU,EAAM,CAClB,OAAO,EAAQ,EAAI,EACrB,IAAI,EAAI,OAAO,EAAM,CAKrB,OAJI,EAAS,EAAM,EAAI,EAAQ,EAAM,IACnC,EAAI,EAAkB,EAAM,EAC1B,EAAE,SAAS,IAAI,EAAI,EAAE,SAAS;EAAK,EAAI,EAAE,SAAS,EAAU,CACvD,IAAI,EAAE,QAAQ,KAAM,KAAK,CAAC,GAC5B,GACP,CAAC,KAAK,EAAU,CAAC,IAGrB,OAAO,EAGT,SAAgB,EAAS,EAAa,EAElC,EAAE,CAAE,CAGN,IAAI,EAA0B,4DAC1B,EAAI,YACN,EAA0B,IAAI,OAAO,EAAwB,OAAO,QAAQ,UAAW,EAAa,EAAI,UAAU,CAAC,CAAE,EAAwB,MAAM,EAErJ,IAAM,EAAiB,EAAE,CACrB,EAAa,EAAE,CACf,EACE,EAAO,GAAG,EAAI,QAAQ,QAAS;EAAK,CAAC,MAAM,CAAC,IAGlD,KAAO,EAAI,EAAwB,KAAK,EAAK,EAAE,CAC7C,IAAI,EAAQ,EAAE,IAAM,EAAE,IAAM,GAC5B,EAAQ,EAAM,QAAQ,MAAO,IAAI,CACjC,EAAI,KAAK,EAAM,CACX,EAAE,KAAO;IACX,EAAM,KAAK,EAAI,CACf,EAAM,EAAE,EAGZ,OAAO,EAGT,SAAgB,EAAkB,EAAa,EAE3C,EAAE,CAAE,CACN,IAAM,EAAQ,EAAS,EAAK,EAAI,CAC1B,EAAS,EAAM,GACrB,OAAO,EAAM,MAAM,EAAE,CAAC,IAAI,GACxB,OAAO,YAAa,EAAE,KAAK,EAAG,IAAM,CAAC,EAAO,GAAI,EAAE,CAAC,CAAC,CACrD"}
+{"version":3,"file":"csv.mjs","names":[],"sources":["../../src/common/csv.ts"],"sourcesContent":["import { isArray, isBoolean, isRecord } from './data/is'\nimport { jsonStringifySafe } from './data/json'\nimport { escapeRegExp } from './data/regexp'\n\nconst defaultSeparator = ','\n\nexport function csvStringify(data: any[], opt: {\n  // header?: string[]\n  separator?: string\n  addBom?: boolean // option to add byte order mark for improved Excel support\n} = {}): string {\n  const { separator = defaultSeparator } = opt\n  let body = ''\n  if (opt.addBom)\n    body = '\\uFEFF'\n\n  // Append the header row to the response if requested\n  // if (header)\n  //   body = `${header.join(separator)}\\n`\n\n  // Convert the data to a CSV-like structure\n  for (let i = 0; i < data.length; i++) {\n    body += `${data[i].map((field: string) => {\n      if (field == null || field === '')\n        return ''\n      if (isBoolean(field))\n        return field ? 1 : 0\n      let s = String(field)\n      if (isRecord(field) || isArray(field))\n        s = jsonStringifySafe(field)\n      if (s.includes('\"') || s.includes('\\n') || s.includes(separator))\n        return `\"${s.replace(/\"/g, '\"\"')}\"`\n      return s\n    }).join(separator)}\\n`\n  }\n\n  return body\n}\n\nexport function csvParse(raw: string, opt: {\n  separator?: string\n} = {}) {\n  // https://regex101.com/r/BCpKyV/1\n  // eslint-disable-next-line regexp/no-unused-capturing-group, regexp/no-super-linear-backtracking, regexp/no-dupe-disjunctions, regexp/no-useless-non-capturing-group\n  let rxOneValueWithSeparator = /(\"((?:(?:[^\"]*?)(?:\"\")?)*)\"|([^,;\\t\\n]*))([,;\\t\\n]|\\r\\n)/g\n  if (opt.separator)\n    rxOneValueWithSeparator = new RegExp(rxOneValueWithSeparator.source.replace(/',;\\\\t/g, escapeRegExp(opt.separator)), rxOneValueWithSeparator.flags)\n\n  const lines: any[][] = []\n  let row: any[] = []\n  let m: any\n  const text = `${raw.replace(/\\r\\n/g, '\\n').trim()}\\n`\n\n  // eslint-disable-next-line no-cond-assign\n  while (m = rxOneValueWithSeparator.exec(text)) {\n    let value = m[2] ?? m[3] ?? ''\n    value = value.replace(/\"\"/g, '\"')\n    row.push(value)\n    if (m[4] === '\\n') {\n      lines.push(row)\n      row = []\n    }\n  }\n  return lines\n}\n\nexport function csvParseToObjects(raw: string, opt: {\n  separator?: string\n} = {}) {\n  const lines = csvParse(raw, opt)\n  const header = lines[0]\n  return lines.slice(1).map(l =>\n    Object.fromEntries (l.map((v, i) => [header[i], v])),\n  )\n}\n"],"mappings":";;;;;AAIA,MAAM,mBAAmB;AAEzB,SAAgB,aAAa,MAAa,MAItC,EAAE,EAAU;CACd,MAAM,EAAE,YAAY,qBAAqB;CACzC,IAAI,OAAO;AACX,KAAI,IAAI,OACN,QAAO;AAOT,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,IAC/B,SAAQ,GAAG,KAAK,GAAG,KAAK,UAAkB;AACxC,MAAI,SAAS,QAAQ,UAAU,GAC7B,QAAO;AACT,MAAI,UAAU,MAAM,CAClB,QAAO,QAAQ,IAAI;EACrB,IAAI,IAAI,OAAO,MAAM;AACrB,MAAI,SAAS,MAAM,IAAI,QAAQ,MAAM,CACnC,KAAI,kBAAkB,MAAM;AAC9B,MAAI,EAAE,SAAS,KAAI,IAAI,EAAE,SAAS,KAAK,IAAI,EAAE,SAAS,UAAU,CAC9D,QAAO,IAAI,EAAE,QAAQ,MAAM,OAAK,CAAC;AACnC,SAAO;GACP,CAAC,KAAK,UAAU,CAAC;AAGrB,QAAO;;AAGT,SAAgB,SAAS,KAAa,MAElC,EAAE,EAAE;CAGN,IAAI,0BAA0B;AAC9B,KAAI,IAAI,UACN,2BAA0B,IAAI,OAAO,wBAAwB,OAAO,QAAQ,WAAW,aAAa,IAAI,UAAU,CAAC,EAAE,wBAAwB,MAAM;CAErJ,MAAM,QAAiB,EAAE;CACzB,IAAI,MAAa,EAAE;CACnB,IAAI;CACJ,MAAM,OAAO,GAAG,IAAI,QAAQ,SAAS,KAAK,CAAC,MAAM,CAAC;AAGlD,QAAO,IAAI,wBAAwB,KAAK,KAAK,EAAE;EAC7C,IAAI,QAAQ,EAAE,MAAM,EAAE,MAAM;AAC5B,UAAQ,MAAM,QAAQ,OAAO,KAAI;AACjC,MAAI,KAAK,MAAM;AACf,MAAI,EAAE,OAAO,MAAM;AACjB,SAAM,KAAK,IAAI;AACf,SAAM,EAAE;;;AAGZ,QAAO;;AAGT,SAAgB,kBAAkB,KAAa,MAE3C,EAAE,EAAE;CACN,MAAM,QAAQ,SAAS,KAAK,IAAI;CAChC,MAAM,SAAS,MAAM;AACrB,QAAO,MAAM,MAAM,EAAE,CAAC,KAAI,MACxB,OAAO,YAAa,EAAE,KAAK,GAAG,MAAM,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,CACrD"}