zeed 1.2.4 → 1.3.1

package/dist/common/crypto/xaes.mjs

@@ -0,0 +1,124 @@
+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

@@ -0,0 +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":"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"}

package/dist/common/csv.cjs

@@ -1,2 +1,50 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk4M4EUXUScjs = require('../chunk-4M4EUXUS.cjs');require('../chunk-WCOWHFZD.cjs');require('../chunk-IVUEQANC.cjs');require('../chunk-IXH5D35S.cjs');require('../chunk-5RHVNJKM.cjs');require('../chunk-P7XCQ7WV.cjs');exports.csvParse = _chunk4M4EUXUScjs.b; exports.csvParseToObjects = _chunk4M4EUXUScjs.c; exports.csvStringify = _chunk4M4EUXUScjs.a;
+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,"sources":["/Users/dirk/work/github-zeed/dist/common/csv.cjs"],"names":[],"mappings":"AAAA,kIAAwC,iCAA8B,iCAA8B,iCAA8B,iCAA8B,iCAA8B,oIAA+D","file":"/Users/dirk/work/github-zeed/dist/common/csv.cjs"}
+{"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.d.cts

@@ -1,12 +1,2 @@
-declare function csvStringify(data: any[], opt?: {
-    separator?: string;
-    addBom?: boolean;
-}): string;
-declare function csvParse(raw: string, opt?: {
-    separator?: string;
-}): any[][];
-declare function csvParseToObjects(raw: string, opt?: {
-    separator?: string;
-}): any[];
-
-export { csvParse, csvParseToObjects, csvStringify };
+import { n as csvParseToObjects, r as csvStringify, t as csvParse } from "../csv-Ci2ysFZB.cjs";
+export { csvParse, csvParseToObjects, csvStringify };

package/dist/common/csv.d.mts

@@ -0,0 +1,2 @@
+import { n as csvParseToObjects, r as csvStringify, t as csvParse } from "../csv-jl8exttU.mjs";
+export { csvParse, csvParseToObjects, csvStringify };

package/dist/common/csv.mjs

@@ -0,0 +1,47 @@
+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

@@ -0,0 +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":";;;;;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"}

package/dist/common/data/array.cjs

@@ -1,2 +1,300 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkKYDHX5HWcjs = require('../../chunk-KYDHX5HW.cjs');require('../../chunk-B2XPF5R4.cjs');require('../../chunk-UXW3L3L6.cjs');require('../../chunk-P7XCQ7WV.cjs');exports.arrayAvg = _chunkKYDHX5HWcjs.w; exports.arrayBatches = _chunkKYDHX5HWcjs.x; exports.arrayEmptyInPlace = _chunkKYDHX5HWcjs.k; exports.arrayFilterInPlace = _chunkKYDHX5HWcjs.i; exports.arrayFlatten = _chunkKYDHX5HWcjs.d; exports.arrayIntersection = _chunkKYDHX5HWcjs.e; exports.arrayIsEqual = _chunkKYDHX5HWcjs.o; exports.arrayMax = _chunkKYDHX5HWcjs.t; exports.arrayMin = _chunkKYDHX5HWcjs.u; exports.arrayMinus = _chunkKYDHX5HWcjs.b; exports.arrayRandomElement = _chunkKYDHX5HWcjs.s; exports.arrayRemoveElement = _chunkKYDHX5HWcjs.g; exports.arraySetArrayInPlace = _chunkKYDHX5HWcjs.l; exports.arraySetElement = _chunkKYDHX5HWcjs.h; exports.arrayShuffle = _chunkKYDHX5HWcjs.q; exports.arrayShuffleForce = _chunkKYDHX5HWcjs.r; exports.arrayShuffleInPlace = _chunkKYDHX5HWcjs.p; exports.arraySorted = _chunkKYDHX5HWcjs.m; exports.arraySortedNumbers = _chunkKYDHX5HWcjs.n; exports.arraySum = _chunkKYDHX5HWcjs.v; exports.arraySymmetricDifference = _chunkKYDHX5HWcjs.f; exports.arrayToggleInPlace = _chunkKYDHX5HWcjs.j; exports.arrayUnion = _chunkKYDHX5HWcjs.c; exports.arrayUnique = _chunkKYDHX5HWcjs.a; exports.createArray = _chunkKYDHX5HWcjs.y;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_common_data_math = require('./math.cjs');
+const require_common_data_orderby = require('./orderby.cjs');
+
+//#region src/common/data/array.ts
+/**
+* Return a new array with duplicate values removed. Maintains first occurrence order.
+* @typeParam T - element type
+* @param arr - input array
+* @returns new array containing unique elements from `arr`
+*/
+function arrayUnique(arr) {
+	return arr.filter((n, index) => arr.indexOf(n) === index);
+}
+/**
+* Return elements present in `x` but not in `y`.
+* @typeParam T - element type
+* @param left - left-hand array
+* @param right - array of elements to exclude
+* @returns new array with elements from `left` that are not included in `right`
+*/
+function arrayMinus(left, right) {
+	return arrayUnique(left.filter((n) => !right.includes(n)));
+}
+/**
+* Return the union of multiple arrays (unique elements across all inputs).
+* @typeParam T - element type
+* @param arrays - arrays to union
+* @returns new array with unique elements from all provided arrays
+*/
+function arrayUnion(...arrays) {
+	return arrayUnique(arrays.reduce((acc = [], value) => acc.concat(value), []));
+}
+/** `[1,[2,3]]` becomes `[1,2,3]` */
+/**
+* Flatten nested arrays to a single-level array.
+* Example: `[1, [2, 3]]` becomes `[1, 2, 3]`.
+* @typeParam T - element type
+* @param arrays - one or more nested arrays to flatten
+* @returns flattened array containing all elements
+*/
+function arrayFlatten(...arrays) {
+	return arrays.flat(Number.POSITIVE_INFINITY);
+}
+/**
+* Return the intersection of two arrays (elements present in both).
+* @typeParam T - element type
+* @param left - first array
+* @param right - second array
+* @returns new array with elements present in both `left` and `right`
+*/
+function arrayIntersection(left, right) {
+	return arrayUnique(left).filter((n) => right.includes(n));
+}
+/**
+* Return the symmetric difference between two arrays (elements in either array but not both).
+* @typeParam T - element type
+*/
+function arraySymmetricDifference(left, right) {
+	return arrayMinus(arrayUnion(left, right), arrayIntersection(left, right));
+}
+/**
+* Remove all occurrences of `el` from `arr` in-place and return the mutated array.
+* If `arr` is not an array, returns an empty array.
+* @typeParam T - element type
+* @param arr - array to modify
+* @param el - element to remove
+* @returns the same array instance with `el` removed
+*/
+function arrayRemoveElement(arr, el) {
+	if (arr && Array.isArray(arr)) {
+		let index;
+		while ((index = arr.indexOf(el)) !== -1) arr.splice(index, 1);
+		return arr;
+	}
+	return [];
+}
+/** Only have it once in the set */
+/**
+* Ensure `el` exists in `arr`. If not present, push it and return the array.
+* @typeParam T - element type
+* @param arr - target array
+* @param el - element to ensure
+* @returns the same array instance (modified if `el` was added)
+*/
+function arraySetElement(arr, el) {
+	if (!arr.includes(el)) arr.push(el);
+	return arr;
+}
+/**
+* Filter an array in-place using `fn` and return the same array instance.
+* This replaces the array contents with the filtered result.
+* @typeParam T - element type
+* @param arr - array to filter in-place
+* @param fn - predicate to determine which elements to keep
+* @returns the same array instance after filtering
+*/
+function arrayFilterInPlace(arr, fn) {
+	arr.splice(0, arr.length, ...arr.filter(fn));
+	return arr;
+}
+/**
+* Toggle presence of `el` in `array` in-place: remove if present, add if missing.
+* @typeParam T - element type
+* @param arr - array to modify
+* @param el - element to toggle
+* @returns the same array instance after the toggle
+*/
+function arrayToggleInPlace(arr, el) {
+	const index = arr.findIndex((e) => e === el);
+	if (index >= 0) arr.splice(index, 1);
+	else arr.push(el);
+	return arr;
+}
+/**
+* Empty an array in-place (remove all elements) and return it.
+* @typeParam T - element type
+*/
+function arrayEmptyInPlace(arr) {
+	arr.splice(0, arr.length);
+	return arr;
+}
+/**
+* Replace the contents of `array` in-place with `newContent` and return it.
+* @typeParam T - element type
+* @param arr - target array to overwrite
+* @param newContent - new contents to set
+* @returns the same array instance after replacement
+*/
+function arraySetArrayInPlace(arr, newContent) {
+	arr.splice(0, arr.length, ...newContent);
+	return arr;
+}
+/**
+* Return a sorted copy of the provided iterable or array-like object.
+* @typeParam T - element type
+* @param arr - iterable or array-like input
+* @param compareFn - optional compare function (defaults to `cmp`)
+* @returns a new array sorted according to `compareFn`
+*/
+function arraySorted(arr, compareFn = require_common_data_orderby.cmp) {
+	return Array.from(arr).sort(compareFn);
+}
+/**
+* Return a new array with numbers sorted in ascending order.
+* @param arr - array of numbers
+* @returns sorted array of numbers
+*/
+function arraySortedNumbers(arr) {
+	return arraySorted(arr, (l, r) => l - r);
+}
+/**
+* Check strict equality of two arrays by length and element-wise === comparison.
+* @typeParam T - element type
+* @param array1 - first array
+* @param array2 - second array
+* @returns `true` if arrays are same length and all elements strictly equal
+*/
+function arrayIsEqual(array1, array2) {
+	return array1.length === array2.length && array1.every((value, index) => value === array2[index]);
+}
+/**
+* Shuffle an array in-place using a secure random source if available.
+* Note: uses Array.sort with random comparator which is sufficient for many cases but
+* not perfectly uniform. Returns the same mutated array.
+* @typeParam T - element type
+* @param array - array to shuffle in-place
+* @returns the shuffled array (same instance)
+*/
+function arrayShuffleInPlace(arr) {
+	arr.sort(() => require_common_data_math.getSecureRandomIfPossible() > .5 ? 1 : -1);
+	return arr;
+}
+/**
+* Return a shuffled copy of `array` (original array is not modified).
+* @typeParam T - element type
+* @param array - input array
+* @returns a new shuffled array
+*/
+function arrayShuffle(arr) {
+	return arrayShuffleInPlace(Array.from(arr));
+}
+/** Randomly shuffle the order of the array's elements. Force to have a different order if array has more than one element. */
+/**
+* Shuffle `array` and ensure the returned order differs from the original when possible.
+* If array length is 0 or 1 it is returned unchanged.
+* @typeParam T - element type
+* @param array - input array
+* @returns a shuffled array that's different from the input when feasible
+*/
+function arrayShuffleForce(arr) {
+	while (arr.length > 1) {
+		const copy = Array.from(arr);
+		arrayShuffleInPlace(copy);
+		if (!arrayIsEqual(arr, copy)) return copy;
+	}
+	return arr;
+}
+/**
+* Return a random element from `array` using a secure random source if available.
+* @typeParam T - element type
+* @param array - input array (must be non-empty)
+* @returns a randomly selected element
+*/
+function arrayRandomElement(arr) {
+	return arr[Math.floor(require_common_data_math.getSecureRandomIfPossible() * arr.length)];
+}
+/**
+* Return the maximum value from one or more nested arrays.
+* Uses the `>` operator for comparison.
+* @typeParam T - element type (should support `>` comparison)
+* @param arrays - nested arrays to search
+* @returns the maximum value or `undefined` if no elements present
+*/
+function arrayMax(...arrays) {
+	return arrayFlatten(...arrays).reduce((acc, value) => acc != null ? value > acc ? value : acc : value, void 0);
+}
+/**
+* Return the minimum value from one or more nested arrays.
+* Uses the `<` operator for comparison.
+* @typeParam T - element type (should support `<` comparison)
+* @param arrays - nested arrays to search
+* @returns the minimum value or `undefined` if no elements present
+*/
+function arrayMin(...arrays) {
+	return arrayFlatten(...arrays).reduce((acc, value) => acc != null ? value < acc ? value : acc : value, void 0);
+}
+/**
+* Sum all numbers in one or more nested arrays.
+* @param arrays - nested arrays of numbers
+* @returns the numeric sum (0 for empty input)
+*/
+function arraySum(...arrays) {
+	return arrayFlatten(...arrays).reduce((acc, value) => acc + value, 0);
+}
+/**
+* Compute the average of numbers across one or more nested arrays.
+* @param arrays - nested arrays of numbers
+* @returns arithmetic mean (NaN if there are no elements)
+*/
+function arrayAvg(...arrays) {
+	const flatArray = arrayFlatten(...arrays);
+	return flatArray.reduce((acc, value) => acc + value, 0) / flatArray.length;
+}
+/**
+* Split an array into chunks of `chunkLength` (last chunk may be smaller).
+* @typeParam T - element type
+* @param arr - input array
+* @param chunkLength - chunk size (positive integer)
+* @returns array of chunk arrays
+*/
+function arrayBatches(arr, chunkLength) {
+	const chunks = [];
+	let i = 0;
+	const n = arr.length;
+	while (i < n) chunks.push(arr.slice(i, i += chunkLength));
+	return chunks;
+}
+/**
+* Create an array of given `length` filled with `item` or the result of `item(index)`.
+* If `length` is <= 0 an empty array is returned.
+* @typeParam T - element type
+* @param length - desired length of the array
+* @param item - value to fill or a function producing a value per index
+* @returns newly created array of length `length`
+*/
+function createArray(length = 0, item) {
+	if (length <= 0) return [];
+	const arr = Array.from({ length });
+	for (let i = 0; i < length; i++) arr[i] = item instanceof Function ? item(i) : item;
+	return arr;
+}
+
+//#endregion
+exports.arrayAvg = arrayAvg;
+exports.arrayBatches = arrayBatches;
+exports.arrayEmptyInPlace = arrayEmptyInPlace;
+exports.arrayFilterInPlace = arrayFilterInPlace;
+exports.arrayFlatten = arrayFlatten;
+exports.arrayIntersection = arrayIntersection;
+exports.arrayIsEqual = arrayIsEqual;
+exports.arrayMax = arrayMax;
+exports.arrayMin = arrayMin;
+exports.arrayMinus = arrayMinus;
+exports.arrayRandomElement = arrayRandomElement;
+exports.arrayRemoveElement = arrayRemoveElement;
+exports.arraySetArrayInPlace = arraySetArrayInPlace;
+exports.arraySetElement = arraySetElement;
+exports.arrayShuffle = arrayShuffle;
+exports.arrayShuffleForce = arrayShuffleForce;
+exports.arrayShuffleInPlace = arrayShuffleInPlace;
+exports.arraySorted = arraySorted;
+exports.arraySortedNumbers = arraySortedNumbers;
+exports.arraySum = arraySum;
+exports.arraySymmetricDifference = arraySymmetricDifference;
+exports.arrayToggleInPlace = arrayToggleInPlace;
+exports.arrayUnion = arrayUnion;
+exports.arrayUnique = arrayUnique;
+exports.createArray = createArray;
 //# sourceMappingURL=array.cjs.map

package/dist/common/data/array.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/dirk/work/github-zeed/dist/common/data/array.cjs"],"names":[],"mappings":"AAAA,qIAAuF,oCAAiC,oCAAiC,oCAAiC,+nCAA8f","file":"/Users/dirk/work/github-zeed/dist/common/data/array.cjs"}
+{"version":3,"file":"array.cjs","names":["cmp","getSecureRandomIfPossible"],"sources":["../../../src/common/data/array.ts"],"sourcesContent":["/* eslint-disable no-cond-assign */\n\nimport type { NestedArray } from '../types'\nimport { getSecureRandomIfPossible } from './math'\nimport { cmp } from './orderby'\n\n/**\n * Return a new array with duplicate values removed. Maintains first occurrence order.\n * @typeParam T - element type\n * @param arr - input array\n * @returns new array containing unique elements from `arr`\n */\nexport function arrayUnique<T>(arr: T[]): T[] {\n  return arr.filter((n: any, index: any) => arr.indexOf(n) === index)\n}\n\n/**\n * Return elements present in `x` but not in `y`.\n * @typeParam T - element type\n * @param left - left-hand array\n * @param right - array of elements to exclude\n * @returns new array with elements from `left` that are not included in `right`\n */\nexport function arrayMinus<T>(left: T[], right: T[]): T[] {\n  return arrayUnique(left.filter((n: any) => !right.includes(n)))\n}\n\n/**\n * Return the union of multiple arrays (unique elements across all inputs).\n * @typeParam T - element type\n * @param arrays - arrays to union\n * @returns new array with unique elements from all provided arrays\n */\nexport function arrayUnion<T>(...arrays: T[][]): T[] {\n  return arrayUnique(arrays.reduce((acc: T[] = [], value) => acc.concat(value), []))\n}\n\n/** `[1,[2,3]]` becomes `[1,2,3]` */\n/**\n * Flatten nested arrays to a single-level array.\n * Example: `[1, [2, 3]]` becomes `[1, 2, 3]`.\n * @typeParam T - element type\n * @param arrays - one or more nested arrays to flatten\n * @returns flattened array containing all elements\n */\nexport function arrayFlatten<T>(...arrays: NestedArray<T>[]): T[] {\n  return (arrays as any).flat(Number.POSITIVE_INFINITY)\n}\n\n/**\n * Return the intersection of two arrays (elements present in both).\n * @typeParam T - element type\n * @param left - first array\n * @param right - second array\n * @returns new array with elements present in both `left` and `right`\n */\nexport function arrayIntersection<T>(left: T[], right: T[]): T[] {\n  return arrayUnique<T>(left).filter((n: any) => right.includes(n))\n}\n\n/**\n * Return the symmetric difference between two arrays (elements in either array but not both).\n * @typeParam T - element type\n */\nexport function arraySymmetricDifference<T>(left: T[], right: T[]): T[] {\n  return arrayMinus(arrayUnion(left, right), arrayIntersection(left, right))\n  // return arrayUnique(x.filter(n => !y.includes(n)).concat(y.filter(n => !x.includes(n))))\n}\n\n// export function arrayApply<T>(fn:  any, a: T[]): T[] {\n//   return a.reduce(fn, [])\n// }\n\n/**\n * Remove all occurrences of `el` from `arr` in-place and return the mutated array.\n * If `arr` is not an array, returns an empty array.\n * @typeParam T - element type\n * @param arr - array to modify\n * @param el - element to remove\n * @returns the same array instance with `el` removed\n */\nexport function arrayRemoveElement<T>(arr: T[], el: T): T[] {\n  if (arr && Array.isArray(arr)) {\n    let index\n    while ((index = arr.indexOf(el)) !== -1)\n      arr.splice(index, 1)\n    return arr\n  }\n  return []\n}\n\n/** Only have it once in the set */\n/**\n * Ensure `el` exists in `arr`. If not present, push it and return the array.\n * @typeParam T - element type\n * @param arr - target array\n * @param el - element to ensure\n * @returns the same array instance (modified if `el` was added)\n */\nexport function arraySetElement<T>(arr: T[], el: T): T[] {\n  if (!arr.includes(el))\n    arr.push(el)\n  return arr\n}\n\n// via https://stackoverflow.com/a/49587869 and Erwin\n/**\n * Filter an array in-place using `fn` and return the same array instance.\n * This replaces the array contents with the filtered result.\n * @typeParam T - element type\n * @param arr - array to filter in-place\n * @param fn - predicate to determine which elements to keep\n * @returns the same array instance after filtering\n */\nexport function arrayFilterInPlace<T>(arr: T[], fn: (el: T) => boolean): T[] {\n  arr.splice(0, arr.length, ...arr.filter(fn))\n  return arr\n}\n\n// via https://stackoverflow.com/a/49587869 and Erwin\n/**\n * Toggle presence of `el` in `array` in-place: remove if present, add if missing.\n * @typeParam T - element type\n * @param arr - array to modify\n * @param el - element to toggle\n * @returns the same array instance after the toggle\n */\nexport function arrayToggleInPlace<T>(arr: T[], el: T): T[] {\n  const index = arr.findIndex(e => e === el)\n  if (index >= 0)\n    arr.splice(index, 1)\n  else arr.push(el)\n  return arr\n}\n\n/**\n * Empty an array in-place (remove all elements) and return it.\n * @typeParam T - element type\n */\nexport function arrayEmptyInPlace<T>(arr: T[]): T[] {\n  arr.splice(0, arr.length)\n  return arr\n}\n\n/**\n * Replace the contents of `array` in-place with `newContent` and return it.\n * @typeParam T - element type\n * @param arr - target array to overwrite\n * @param newContent - new contents to set\n * @returns the same array instance after replacement\n */\nexport function arraySetArrayInPlace<T>(arr: T[], newContent: T[]): T[] {\n  arr.splice(0, arr.length, ...newContent)\n  return arr\n}\n\n/**\n * Return a sorted copy of the provided iterable or array-like object.\n * @typeParam T - element type\n * @param arr - iterable or array-like input\n * @param compareFn - optional compare function (defaults to `cmp`)\n * @returns a new array sorted according to `compareFn`\n */\nexport function arraySorted<T>(\n  arr: Iterable<T> | ArrayLike<T>,\n  compareFn: ((a: T, b: T) => number) | undefined = cmp,\n): T[] {\n  return Array.from(arr).sort(compareFn)\n}\n\n/**\n * Return a new array with numbers sorted in ascending order.\n * @param arr - array of numbers\n * @returns sorted array of numbers\n */\nexport function arraySortedNumbers(arr: number[]): number[] {\n  return arraySorted(arr, (l: number, r: number) => l - r)\n}\n\n/**\n * Check strict equality of two arrays by length and element-wise === comparison.\n * @typeParam T - element type\n * @param array1 - first array\n * @param array2 - second array\n * @returns `true` if arrays are same length and all elements strictly equal\n */\nexport function arrayIsEqual<T>(array1: T[], array2: T[]): boolean {\n  return (\n    array1.length === array2.length\n    && array1.every((value, index) => value === array2[index])\n  )\n}\n\n/**\n * Shuffle an array in-place using a secure random source if available.\n * Note: uses Array.sort with random comparator which is sufficient for many cases but\n * not perfectly uniform. Returns the same mutated array.\n * @typeParam T - element type\n * @param array - array to shuffle in-place\n * @returns the shuffled array (same instance)\n */\nexport function arrayShuffleInPlace<T>(arr: T[]): T[] {\n  arr.sort(() => (getSecureRandomIfPossible() > 0.5 ? 1 : -1))\n\n  // Alternative https://github.com/sindresorhus/array-shuffle/blob/main/index.js#L8\n  // for (let index = array.length - 1; index > 0; index--) {\n  //   const newIndex = Math.floor(Math.random() * (index + 1));\n  //   [array[index], array[newIndex]] = [array[newIndex], array[index]];\n  // }\n\n  return arr\n}\n\n/**\n * Return a shuffled copy of `array` (original array is not modified).\n * @typeParam T - element type\n * @param array - input array\n * @returns a new shuffled array\n */\nexport function arrayShuffle<T>(arr: T[]): T[] {\n  return arrayShuffleInPlace(Array.from(arr))\n}\n\n/** Randomly shuffle the order of the array's elements. Force to have a different order if array has more than one element. */\n/**\n * Shuffle `array` and ensure the returned order differs from the original when possible.\n * If array length is 0 or 1 it is returned unchanged.\n * @typeParam T - element type\n * @param array - input array\n * @returns a shuffled array that's different from the input when feasible\n */\nexport function arrayShuffleForce<T>(arr: T[]): T[] {\n  while (arr.length > 1) {\n    const copy = Array.from(arr)\n    arrayShuffleInPlace(copy)\n    if (!arrayIsEqual(arr, copy))\n      return copy\n  }\n  return arr\n}\n\n/**\n * Return a random element from `array` using a secure random source if available.\n * @typeParam T - element type\n * @param array - input array (must be non-empty)\n * @returns a randomly selected element\n */\nexport function arrayRandomElement<T>(arr: T[]): T {\n  return arr[Math.floor(getSecureRandomIfPossible() * arr.length)]\n}\n\n/**\n * Return the maximum value from one or more nested arrays.\n * Uses the `>` operator for comparison.\n * @typeParam T - element type (should support `>` comparison)\n * @param arrays - nested arrays to search\n * @returns the maximum value or `undefined` if no elements present\n */\nexport function arrayMax<T>(...arrays: NestedArray<T>[]): T {\n  return arrayFlatten(...arrays).reduce(\n    (acc: T, value: T) => (acc != null ? (value > acc ? value : acc) : value),\n    undefined as T,\n  )\n}\n\n/**\n * Return the minimum value from one or more nested arrays.\n * Uses the `<` operator for comparison.\n * @typeParam T - element type (should support `<` comparison)\n * @param arrays - nested arrays to search\n * @returns the minimum value or `undefined` if no elements present\n */\nexport function arrayMin<T>(...arrays: NestedArray<T>[]): T {\n  return arrayFlatten(...arrays).reduce(\n    (acc: T, value: T) => (acc != null ? (value < acc ? value : acc) : value),\n    undefined as T,\n  )\n}\n\n/**\n * Sum all numbers in one or more nested arrays.\n * @param arrays - nested arrays of numbers\n * @returns the numeric sum (0 for empty input)\n */\nexport function arraySum(...arrays: NestedArray<number>[]): number {\n  return arrayFlatten(...arrays).reduce((acc, value) => acc + value, 0)\n}\n\n/**\n * Compute the average of numbers across one or more nested arrays.\n * @param arrays - nested arrays of numbers\n * @returns arithmetic mean (NaN if there are no elements)\n */\nexport function arrayAvg(...arrays: NestedArray<number>[]): number {\n  const flatArray = arrayFlatten(...arrays)\n  return flatArray.reduce((acc, value) => acc + value, 0) / flatArray.length\n}\n\n/**\n * Split an array into chunks of `chunkLength` (last chunk may be smaller).\n * @typeParam T - element type\n * @param arr - input array\n * @param chunkLength - chunk size (positive integer)\n * @returns array of chunk arrays\n */\nexport function arrayBatches<T>(arr: T[], chunkLength: number): T[][] {\n  const chunks = []\n  let i = 0\n  const n = arr.length\n  while (i < n)\n    chunks.push(arr.slice(i, (i += chunkLength)))\n  return chunks\n}\n\n/**\n * Create an array of given `length` filled with `item` or the result of `item(index)`.\n * If `length` is <= 0 an empty array is returned.\n * @typeParam T - element type\n * @param length - desired length of the array\n * @param item - value to fill or a function producing a value per index\n * @returns newly created array of length `length`\n */\nexport function createArray<T>(\n  length = 0,\n  item?: T | ((index: number) => T), // todo remove optional\n): T[] {\n  if (length <= 0)\n    return []\n  const arr: T[] = Array.from({ length })\n  for (let i = 0; i < length; i++)\n    // @ts-expect-error xxx\n    arr[i] = item instanceof Function ? item(i) : item\n  return arr\n}\n"],"mappings":"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"}