@hexclave/shared 1.0.0

package/dist/esm/utils/crypto.js

@@ -0,0 +1,208 @@
+import { encodeBase32, encodeBase64 } from "./bytes.js";
+import { HexclaveAssertionError } from "./errors.js";
+import { globalVar } from "./globals.js";
+import { Result } from "./results.js";
+import { toArrayBufferBacked } from "./typed-arrays.js";
+
+//#region src/utils/crypto.tsx
+function generateRandomValues(array) {
+	if (!globalVar.crypto) throw new HexclaveAssertionError("Crypto API is not available in this environment. Are you using an old browser?");
+	if (!globalVar.crypto.getRandomValues) throw new HexclaveAssertionError("crypto.getRandomValues is not available in this environment. Are you using an old browser?");
+	return globalVar.crypto.getRandomValues(array);
+}
+/**
+* Generates a secure alphanumeric string using the system's cryptographically secure
+* random number generator.
+*/
+function generateSecureRandomString(minBitsOfEntropy = 224) {
+	const base32CharactersCount = Math.ceil(minBitsOfEntropy / 5);
+	const bytesCount = Math.ceil(base32CharactersCount * 5 / 8);
+	const str = encodeBase32(generateRandomValues(new Uint8Array(bytesCount)));
+	return str.slice(str.length - base32CharactersCount).toLowerCase();
+}
+async function getDerivedSymmetricKey(purpose, secret, salt) {
+	const secretBytes = typeof secret === "string" ? new TextEncoder().encode(secret) : toArrayBufferBacked(secret);
+	const originalSecretKey = await crypto.subtle.importKey("raw", secretBytes, "HKDF", false, ["deriveKey"]);
+	return await crypto.subtle.deriveKey({
+		name: "HKDF",
+		salt: toArrayBufferBacked(salt),
+		hash: "SHA-256",
+		info: new TextEncoder().encode(JSON.stringify([
+			"stack-crypto-helper-derived-symmetric-key",
+			purpose,
+			typeof secret === "string" ? "string-key" : "binary-key",
+			encodeBase64(salt)
+		]))
+	}, originalSecretKey, {
+		name: "AES-GCM",
+		length: 256
+	}, false, ["encrypt", "decrypt"]);
+}
+async function encrypt({ purpose, secret, value }) {
+	const iv = crypto.getRandomValues(new Uint8Array(12));
+	const salt = crypto.getRandomValues(new Uint8Array(16));
+	const derivedSecretKey = await getDerivedSymmetricKey(purpose, secret, salt);
+	const cipher = await crypto.subtle.encrypt({
+		name: "AES-GCM",
+		iv
+	}, derivedSecretKey, toArrayBufferBacked(value));
+	return new Uint8Array([
+		...[1, 0],
+		...salt,
+		...iv,
+		...new Uint8Array(cipher)
+	]);
+}
+async function decrypt({ purpose, secret, cipher }) {
+	const version = cipher.slice(0, 2);
+	if (version[0] !== 1 || version[1] !== 0) throw new HexclaveAssertionError("Invalid ciphertext version in decrypt(...); expected 0x0100", { purpose });
+	const salt = cipher.slice(2, 18);
+	const iv = cipher.slice(18, 30);
+	const cipherBytes = cipher.slice(30);
+	const derivedSecretKey = await getDerivedSymmetricKey(purpose, secret, salt);
+	try {
+		const plaintext = await crypto.subtle.decrypt({
+			name: "AES-GCM",
+			iv
+		}, derivedSecretKey, cipherBytes);
+		return Result.ok(new Uint8Array(plaintext));
+	} catch (e) {
+		if (e instanceof DOMException && e.name === "OperationError") return Result.error(new Error("Invalid ciphertext or secret when decrypting encrypted value", { cause: e }));
+		throw e;
+	}
+}
+(void 0)?.test("encrypt & decrypt", async ({ expect }) => {
+	const encryptAndDecrypt = async (encryptPurpose, decryptPurpose, encryptSecret, decryptSecret, value) => {
+		return await decrypt({
+			purpose: decryptPurpose,
+			secret: decryptSecret,
+			cipher: await encrypt({
+				purpose: encryptPurpose,
+				secret: encryptSecret,
+				value
+			})
+		});
+	};
+	const exampleBytes = new TextEncoder().encode("hello");
+	const exampleKey1 = crypto.getRandomValues(new Uint8Array(32));
+	const exampleKey2 = crypto.getRandomValues(new Uint8Array(32));
+	expect(await encryptAndDecrypt("p", "p", "secret", "secret", exampleBytes)).toEqual(Result.ok(exampleBytes));
+	expect(await encryptAndDecrypt("p", "p", exampleKey1, exampleKey1, exampleBytes)).toEqual(Result.ok(exampleBytes));
+	expect(await encryptAndDecrypt("p", "p", exampleKey1, "secret", exampleBytes)).toEqual(Result.error(expect.objectContaining({ message: "Invalid ciphertext or secret when decrypting encrypted value" })));
+	expect(await encryptAndDecrypt("p", "p", exampleKey1, exampleKey2, exampleBytes)).toEqual(Result.error(expect.objectContaining({ message: "Invalid ciphertext or secret when decrypting encrypted value" })));
+	expect(await encryptAndDecrypt("p", "not-p", exampleKey1, exampleKey1, exampleBytes)).toEqual(Result.error(expect.objectContaining({ message: "Invalid ciphertext or secret when decrypting encrypted value" })));
+});
+async function hash(options) {
+	return await iteratedHash({
+		...options,
+		iterations: 1
+	});
+}
+async function iteratedHash(options) {
+	const stringOrUint8ArrayToUint8Array = (value) => typeof value === "string" ? new TextEncoder().encode(value) : toArrayBufferBacked(value);
+	const stringOrUint8ArrayToBase64 = (value) => encodeBase64(stringOrUint8ArrayToUint8Array(value));
+	const input = await crypto.subtle.importKey("raw", stringOrUint8ArrayToUint8Array(options.value), "PBKDF2", false, ["deriveBits"]);
+	return new Uint8Array(await crypto.subtle.deriveBits({
+		name: "PBKDF2",
+		salt: new TextEncoder().encode(JSON.stringify([
+			"stack-crypto-helper-iterated-hash",
+			options.purpose,
+			stringOrUint8ArrayToBase64(options.salt ?? ""),
+			stringOrUint8ArrayToBase64(options.extra ?? "")
+		])),
+		iterations: options.iterations,
+		hash: "SHA-256"
+	}, input, 256));
+}
+(void 0)?.test("iteratedHash", async ({ expect }) => {
+	const valueBytes = new TextEncoder().encode("hello");
+	const incrementBytes = new Uint8Array([
+		1,
+		2,
+		3,
+		4,
+		5,
+		6,
+		7,
+		8,
+		9,
+		10,
+		11,
+		12,
+		13,
+		14,
+		15,
+		16
+	]);
+	const hash = await iteratedHash({
+		purpose: "purpose",
+		value: valueBytes,
+		iterations: 1e5
+	});
+	const hash2 = await iteratedHash({
+		purpose: "purpose",
+		value: valueBytes,
+		iterations: 1e5
+	});
+	const hashWithDifferentPurpose = await iteratedHash({
+		purpose: "different-purpose",
+		value: valueBytes,
+		iterations: 1e5
+	});
+	const hashWithEmptySalt = await iteratedHash({
+		purpose: "purpose",
+		value: valueBytes,
+		salt: new Uint8Array(0),
+		iterations: 1e5
+	});
+	const hashWithDifferentSalt = await iteratedHash({
+		purpose: "purpose",
+		value: valueBytes,
+		salt: incrementBytes,
+		iterations: 1e5
+	});
+	const hashWithEmptyExtra = await iteratedHash({
+		purpose: "purpose",
+		value: valueBytes,
+		extra: new Uint8Array(0),
+		iterations: 1e5
+	});
+	const hashWithDifferentExtra = await iteratedHash({
+		purpose: "purpose",
+		value: valueBytes,
+		extra: incrementBytes,
+		iterations: 1e5
+	});
+	const hashWithDifferentValue = await iteratedHash({
+		purpose: "purpose",
+		value: new TextEncoder().encode("hello2"),
+		iterations: 1e5
+	});
+	const hashWithDifferentSaltAndExtra = await iteratedHash({
+		purpose: "purpose",
+		value: valueBytes,
+		salt: incrementBytes,
+		extra: incrementBytes,
+		iterations: 1e5
+	});
+	const hashWithDifferentIterations = await iteratedHash({
+		purpose: "purpose",
+		value: valueBytes,
+		iterations: 100001
+	});
+	expect(hash).toEqual(hash2);
+	expect(hash).not.toEqual(hashWithDifferentPurpose);
+	expect(hash).toEqual(hashWithEmptySalt);
+	expect(hash).not.toEqual(hashWithDifferentSalt);
+	expect(hash).toEqual(hashWithEmptyExtra);
+	expect(hash).not.toEqual(hashWithDifferentExtra);
+	expect(hash).not.toEqual(hashWithDifferentValue);
+	expect(hash).not.toEqual(hashWithDifferentIterations);
+	expect(hashWithDifferentSalt).not.toEqual(hashWithDifferentExtra);
+	expect(hashWithDifferentSalt).not.toEqual(hashWithDifferentSaltAndExtra);
+	expect(hashWithDifferentExtra).not.toEqual(hashWithDifferentSaltAndExtra);
+});
+
+//#endregion
+export { decrypt, encrypt, generateRandomValues, generateSecureRandomString, hash, iteratedHash };
+//# sourceMappingURL=crypto.js.map

package/dist/esm/utils/crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.js","names":[],"sources":["../../../src/utils/crypto.tsx"],"sourcesContent":["import { encodeBase32, encodeBase64 } from \"./bytes\";\nimport { HexclaveAssertionError } from \"./errors\";\nimport { globalVar } from \"./globals\";\nimport { Result } from \"./results\";\nimport { toArrayBufferBacked } from \"./typed-arrays\";\n\nexport function generateRandomValues(array: Uint8Array): typeof array {\n  if (!globalVar.crypto) {\n    throw new HexclaveAssertionError(\"Crypto API is not available in this environment. Are you using an old browser?\");\n  }\n  if (!globalVar.crypto.getRandomValues) {\n    throw new HexclaveAssertionError(\"crypto.getRandomValues is not available in this environment. Are you using an old browser?\");\n  }\n  return globalVar.crypto.getRandomValues(array);\n}\n\n/**\n * Generates a secure alphanumeric string using the system's cryptographically secure\n * random number generator.\n */\nexport function generateSecureRandomString(minBitsOfEntropy: number = 224) {\n  const base32CharactersCount = Math.ceil(minBitsOfEntropy / 5);\n  const bytesCount = Math.ceil(base32CharactersCount * 5 / 8);\n  const randomBytes = generateRandomValues(new Uint8Array(bytesCount));\n  const str = encodeBase32(randomBytes);\n  return str.slice(str.length - base32CharactersCount).toLowerCase();\n}\n\nasync function getDerivedSymmetricKey(purpose: string, secret: string | Uint8Array, salt: Uint8Array) {\n  const secretBytes = typeof secret === \"string\" ? new TextEncoder().encode(secret) : toArrayBufferBacked(secret);\n  const originalSecretKey = await crypto.subtle.importKey(\"raw\", secretBytes, \"HKDF\", false, [\"deriveKey\"]);\n  return await crypto.subtle.deriveKey(\n    {\n      name: \"HKDF\",\n      salt: toArrayBufferBacked(salt),\n      hash: \"SHA-256\",\n      info: new TextEncoder().encode(JSON.stringify([\n        \"stack-crypto-helper-derived-symmetric-key\",\n        purpose,\n        typeof secret === \"string\" ? \"string-key\" : \"binary-key\",\n        encodeBase64(salt),\n      ])),\n    },\n    originalSecretKey,\n    { name: \"AES-GCM\", length: 256 },\n    false,\n    [\"encrypt\", \"decrypt\"]\n  );\n}\n\nexport async function encrypt({ purpose, secret, value }: { purpose: string, secret: string | Uint8Array, value: Uint8Array }) {\n  const iv = crypto.getRandomValues(new Uint8Array(12));\n  const salt = crypto.getRandomValues(new Uint8Array(16));\n  const derivedSecretKey = await getDerivedSymmetricKey(purpose, secret, salt);\n\n  const cipher = await crypto.subtle.encrypt({\n    name: \"AES-GCM\",\n    iv,\n  }, derivedSecretKey, toArrayBufferBacked(value));\n\n  const version = [0x01, 0x00];\n  return new Uint8Array([...version, ...salt, ...iv, ...new Uint8Array(cipher)]);\n}\n\nexport async function decrypt({ purpose, secret, cipher }: { purpose: string, secret: string | Uint8Array, cipher: Uint8Array }) {\n  const version = cipher.slice(0, 2);\n  if (version[0] !== 0x01 || version[1] !== 0x00) throw new HexclaveAssertionError(\"Invalid ciphertext version in decrypt(...); expected 0x0100\", { purpose });\n  const salt = cipher.slice(2, 18);\n  const iv = cipher.slice(18, 30);\n  const cipherBytes = cipher.slice(30);\n  const derivedSecretKey = await getDerivedSymmetricKey(purpose, secret, salt);\n\n  try {\n    const plaintext = await crypto.subtle.decrypt({\n      name: \"AES-GCM\",\n      iv,\n    }, derivedSecretKey, cipherBytes);\n    return Result.ok(new Uint8Array(plaintext));\n  } catch (e) {\n    if (e instanceof DOMException && e.name === \"OperationError\") {\n      return Result.error(new Error(\"Invalid ciphertext or secret when decrypting encrypted value\", { cause: e }));\n    }\n    throw e;\n  }\n}\n\nimport.meta.vitest?.test(\"encrypt & decrypt\", async ({ expect }) => {\n  const encryptAndDecrypt = async (encryptPurpose: string, decryptPurpose: string, encryptSecret: string | Uint8Array, decryptSecret: string | Uint8Array, value: Uint8Array) => {\n    const encrypted = await encrypt({ purpose: encryptPurpose, secret: encryptSecret, value });\n    const decrypted = await decrypt({ purpose: decryptPurpose, secret: decryptSecret, cipher: encrypted });\n    return decrypted;\n  };\n\n  const exampleBytes = new TextEncoder().encode(\"hello\");\n\n  const exampleKey1 = crypto.getRandomValues(new Uint8Array(32));\n  const exampleKey2 = crypto.getRandomValues(new Uint8Array(32));\n\n  expect(await encryptAndDecrypt(\"p\", \"p\", \"secret\", \"secret\", exampleBytes)).toEqual(Result.ok(exampleBytes));\n  expect(await encryptAndDecrypt(\"p\", \"p\", exampleKey1, exampleKey1, exampleBytes)).toEqual(Result.ok(exampleBytes));\n  expect(await encryptAndDecrypt(\"p\", \"p\", exampleKey1, \"secret\", exampleBytes)).toEqual(Result.error(expect.objectContaining({ message: \"Invalid ciphertext or secret when decrypting encrypted value\" })));\n  expect(await encryptAndDecrypt(\"p\", \"p\", exampleKey1, exampleKey2, exampleBytes)).toEqual(Result.error(expect.objectContaining({ message: \"Invalid ciphertext or secret when decrypting encrypted value\" })));\n  expect(await encryptAndDecrypt(\"p\", \"not-p\", exampleKey1, exampleKey1, exampleBytes)).toEqual(Result.error(expect.objectContaining({ message: \"Invalid ciphertext or secret when decrypting encrypted value\" })));\n});\n\nexport type HashOptions = {\n  purpose: string,\n  salt?: string | Uint8Array,\n  extra?: string | Uint8Array,\n  value: string | Uint8Array,\n};\n\nexport async function hash(options: HashOptions) {\n  return await iteratedHash({ ...options, iterations: 1 });\n}\n\nexport async function iteratedHash(options: HashOptions & { iterations: number }) {\n  const stringOrUint8ArrayToUint8Array = (value: string | Uint8Array) => typeof value === \"string\" ? new TextEncoder().encode(value) : toArrayBufferBacked(value);\n  const stringOrUint8ArrayToBase64 = (value: string | Uint8Array) => encodeBase64(stringOrUint8ArrayToUint8Array(value));\n  const input = await crypto.subtle.importKey(\n    \"raw\",\n    stringOrUint8ArrayToUint8Array(options.value),\n    \"PBKDF2\",\n    false,\n    [\"deriveBits\"]\n  );\n  return new Uint8Array(await crypto.subtle.deriveBits({\n    name: \"PBKDF2\",\n    salt: new TextEncoder().encode(JSON.stringify([\n      \"stack-crypto-helper-iterated-hash\",\n      options.purpose,\n      stringOrUint8ArrayToBase64(options.salt ?? \"\"),\n      stringOrUint8ArrayToBase64(options.extra ?? \"\"),\n    ])),\n    iterations: options.iterations,\n    hash: \"SHA-256\",\n  }, input, 256));\n}\n\nimport.meta.vitest?.test(\"iteratedHash\", async ({ expect }) => {\n  const valueBytes = new TextEncoder().encode(\"hello\");\n  const incrementBytes = new Uint8Array([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10]);\n\n  const hash = await iteratedHash({ purpose: \"purpose\", value: valueBytes, iterations: 100_000 });\n  const hash2 = await iteratedHash({ purpose: \"purpose\", value: valueBytes, iterations: 100_000 });\n  const hashWithDifferentPurpose = await iteratedHash({ purpose: \"different-purpose\", value: valueBytes, iterations: 100_000 });\n  const hashWithEmptySalt = await iteratedHash({ purpose: \"purpose\", value: valueBytes, salt: new Uint8Array(0), iterations: 100_000 });\n  const hashWithDifferentSalt = await iteratedHash({ purpose: \"purpose\", value: valueBytes, salt: incrementBytes, iterations: 100_000 });\n  const hashWithEmptyExtra = await iteratedHash({ purpose: \"purpose\", value: valueBytes, extra: new Uint8Array(0), iterations: 100_000 });\n  const hashWithDifferentExtra = await iteratedHash({ purpose: \"purpose\", value: valueBytes, extra: incrementBytes, iterations: 100_000 });\n  const hashWithDifferentValue = await iteratedHash({ purpose: \"purpose\", value: new TextEncoder().encode(\"hello2\"), iterations: 100_000 });\n  const hashWithDifferentSaltAndExtra = await iteratedHash({ purpose: \"purpose\", value: valueBytes, salt: incrementBytes, extra: incrementBytes, iterations: 100_000 });\n  const hashWithDifferentIterations = await iteratedHash({ purpose: \"purpose\", value: valueBytes, iterations: 100_001 });\n\n\n  expect(hash).toEqual(hash2);\n  expect(hash).not.toEqual(hashWithDifferentPurpose);\n  expect(hash).toEqual(hashWithEmptySalt);\n  expect(hash).not.toEqual(hashWithDifferentSalt);\n  expect(hash).toEqual(hashWithEmptyExtra);\n  expect(hash).not.toEqual(hashWithDifferentExtra);\n  expect(hash).not.toEqual(hashWithDifferentValue);\n  expect(hash).not.toEqual(hashWithDifferentIterations);\n\n  expect(hashWithDifferentSalt).not.toEqual(hashWithDifferentExtra);\n  expect(hashWithDifferentSalt).not.toEqual(hashWithDifferentSaltAndExtra);\n  expect(hashWithDifferentExtra).not.toEqual(hashWithDifferentSaltAndExtra);\n});\n"],"mappings":"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"}

package/dist/esm/utils/currencies.d.ts

@@ -0,0 +1,8 @@
+import { Currency, MoneyAmount, SUPPORTED_CURRENCIES } from "./currency-constants";
+
+//#region src/utils/currencies.d.ts
+type SupportedCurrency = (typeof SUPPORTED_CURRENCIES)[number];
+declare function moneyAmountToStripeUnits(amount: MoneyAmount, currency: Currency): number;
+//#endregion
+export { SupportedCurrency, moneyAmountToStripeUnits };
+//# sourceMappingURL=currencies.d.ts.map

package/dist/esm/utils/currencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"currencies.d.ts","names":[],"sources":["../../../src/utils/currencies.tsx"],"mappings":";;;KAIY,iBAAA,WAA4B,oBAAA;AAAA,iBAExB,wBAAA,CAAyB,MAAA,EAAQ,WAAA,EAAa,QAAA,EAAU,QAAA"}

package/dist/esm/utils/currencies.js

@@ -0,0 +1,50 @@
+import { moneyAmountSchema } from "../schema-fields.js";
+import { HexclaveAssertionError } from "./errors.js";
+import { SUPPORTED_CURRENCIES } from "./currency-constants.js";
+
+//#region src/utils/currencies.tsx
+function moneyAmountToStripeUnits(amount, currency) {
+	const validated = moneyAmountSchema(currency).defined().validateSync(amount);
+	if (currency.stripeDecimals !== currency.decimals) throw new HexclaveAssertionError("unimplemented: TODO support different decimal configurations");
+	const [whole, fractional = ""] = validated.split(".");
+	const paddedFractional = fractional.padEnd(currency.decimals, "0");
+	return Number.parseInt(whole + paddedFractional, 10);
+}
+(void 0)?.describe("moneyAmountToStripeUnits", (test) => {
+	const USD = SUPPORTED_CURRENCIES.find((c) => c.code === "USD");
+	test("converts fully-padded USD amounts", ({ expect }) => {
+		expect(moneyAmountToStripeUnits("5.00", USD)).toBe(500);
+		expect(moneyAmountToStripeUnits("0.01", USD)).toBe(1);
+		expect(moneyAmountToStripeUnits("12.34", USD)).toBe(1234);
+	});
+	test("converts whole-number USD amounts (no decimals)", ({ expect }) => {
+		expect(moneyAmountToStripeUnits("5", USD)).toBe(500);
+		expect(moneyAmountToStripeUnits("10", USD)).toBe(1e3);
+		expect(moneyAmountToStripeUnits("0", USD)).toBe(0);
+	});
+	test("converts USD amounts with one decimal digit", ({ expect }) => {
+		expect(moneyAmountToStripeUnits("5.5", USD)).toBe(550);
+		expect(moneyAmountToStripeUnits("0.5", USD)).toBe(50);
+	});
+	test("matches stripeUnitsToMoneyAmount round-trip", ({ expect }) => {
+		for (const cents of [
+			0,
+			1,
+			5,
+			50,
+			99,
+			100,
+			1234,
+			1e5
+		]) expect(moneyAmountToStripeUnits(`${Math.floor(cents / 100)}.${(cents % 100).toString().padStart(2, "0")}`, USD)).toBe(cents);
+	});
+	test("rejects invalid money strings via schema", ({ expect }) => {
+		expect(() => moneyAmountToStripeUnits("abc", USD)).toThrow();
+		expect(() => moneyAmountToStripeUnits("5.555", USD)).toThrow();
+		expect(() => moneyAmountToStripeUnits("05", USD)).toThrow();
+	});
+});
+
+//#endregion
+export { moneyAmountToStripeUnits };
+//# sourceMappingURL=currencies.js.map

package/dist/esm/utils/currencies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"currencies.js","names":[],"sources":["../../../src/utils/currencies.tsx"],"sourcesContent":["import { moneyAmountSchema } from \"../schema-fields\";\nimport { SUPPORTED_CURRENCIES, type Currency, type MoneyAmount } from \"./currency-constants\";\nimport { HexclaveAssertionError } from \"./errors\";\n\nexport type SupportedCurrency = (typeof SUPPORTED_CURRENCIES)[number];\n\nexport function moneyAmountToStripeUnits(amount: MoneyAmount, currency: Currency): number {\n  const validated = moneyAmountSchema(currency).defined().validateSync(amount);\n  if (currency.stripeDecimals !== currency.decimals) {\n    throw new HexclaveAssertionError(\"unimplemented: TODO support different decimal configurations\");\n  }\n  // `moneyAmountSchema` accepts strings with 0..currency.decimals fractional\n  // digits, so we must right-pad the fractional part before stripping the dot.\n  // A naïve `replace('.', '')` underweights inputs like \"5\" → 5 (should be 500\n  // for USD) and \"0.5\" → 5 (should be 50).\n  const [whole, fractional = \"\"] = validated.split(\".\");\n  const paddedFractional = fractional.padEnd(currency.decimals, \"0\");\n  return Number.parseInt(whole + paddedFractional, 10);\n}\n\nimport.meta.vitest?.describe(\"moneyAmountToStripeUnits\", (test) => {\n  const USD = SUPPORTED_CURRENCIES.find((c) => c.code === \"USD\")!;\n\n  test(\"converts fully-padded USD amounts\", ({ expect }) => {\n    expect(moneyAmountToStripeUnits(\"5.00\" as MoneyAmount, USD)).toBe(500);\n    expect(moneyAmountToStripeUnits(\"0.01\" as MoneyAmount, USD)).toBe(1);\n    expect(moneyAmountToStripeUnits(\"12.34\" as MoneyAmount, USD)).toBe(1234);\n  });\n\n  test(\"converts whole-number USD amounts (no decimals)\", ({ expect }) => {\n    expect(moneyAmountToStripeUnits(\"5\" as MoneyAmount, USD)).toBe(500);\n    expect(moneyAmountToStripeUnits(\"10\" as MoneyAmount, USD)).toBe(1000);\n    expect(moneyAmountToStripeUnits(\"0\" as MoneyAmount, USD)).toBe(0);\n  });\n\n  test(\"converts USD amounts with one decimal digit\", ({ expect }) => {\n    expect(moneyAmountToStripeUnits(\"5.5\" as MoneyAmount, USD)).toBe(550);\n    expect(moneyAmountToStripeUnits(\"0.5\" as MoneyAmount, USD)).toBe(50);\n  });\n\n  test(\"matches stripeUnitsToMoneyAmount round-trip\", ({ expect }) => {\n    for (const cents of [0, 1, 5, 50, 99, 100, 1234, 100000]) {\n      const padded = `${Math.floor(cents / 100)}.${(cents % 100).toString().padStart(2, \"0\")}` as MoneyAmount;\n      expect(moneyAmountToStripeUnits(padded, USD)).toBe(cents);\n    }\n  });\n\n  test(\"rejects invalid money strings via schema\", ({ expect }) => {\n    expect(() => moneyAmountToStripeUnits(\"abc\" as MoneyAmount, USD)).toThrow();\n    expect(() => moneyAmountToStripeUnits(\"5.555\" as MoneyAmount, USD)).toThrow();\n    expect(() => moneyAmountToStripeUnits(\"05\" as MoneyAmount, USD)).toThrow();\n  });\n});\n"],"mappings":";;;;;AAMA,SAAgB,yBAAyB,QAAqB,UAA4B;CACxF,MAAM,YAAY,kBAAkB,SAAS,CAAC,SAAS,CAAC,aAAa,OAAO;AAC5E,KAAI,SAAS,mBAAmB,SAAS,SACvC,OAAM,IAAI,uBAAuB,+DAA+D;CAMlG,MAAM,CAAC,OAAO,aAAa,MAAM,UAAU,MAAM,IAAI;CACrD,MAAM,mBAAmB,WAAW,OAAO,SAAS,UAAU,IAAI;AAClE,QAAO,OAAO,SAAS,QAAQ,kBAAkB,GAAG;;CAGtD,SAAW,SAAS,6BAAU,SAA4B;CACxD,MAAM,MAAM,qBAAqB,MAAM,MAAM,EAAE,SAAS,MAAM;AAE9D,MAAK,sCAAsC,EAAE,aAAa;AACxD,SAAO,yBAAyB,QAAuB,IAAI,CAAC,CAAC,KAAK,IAAI;AACtE,SAAO,yBAAyB,QAAuB,IAAI,CAAC,CAAC,KAAK,EAAE;AACpE,SAAO,yBAAyB,SAAwB,IAAI,CAAC,CAAC,KAAK,KAAK;GACxE;AAEF,MAAK,oDAAoD,EAAE,aAAa;AACtE,SAAO,yBAAyB,KAAoB,IAAI,CAAC,CAAC,KAAK,IAAI;AACnE,SAAO,yBAAyB,MAAqB,IAAI,CAAC,CAAC,KAAK,IAAK;AACrE,SAAO,yBAAyB,KAAoB,IAAI,CAAC,CAAC,KAAK,EAAE;GACjE;AAEF,MAAK,gDAAgD,EAAE,aAAa;AAClE,SAAO,yBAAyB,OAAsB,IAAI,CAAC,CAAC,KAAK,IAAI;AACrE,SAAO,yBAAyB,OAAsB,IAAI,CAAC,CAAC,KAAK,GAAG;GACpE;AAEF,MAAK,gDAAgD,EAAE,aAAa;AAClE,OAAK,MAAM,SAAS;GAAC;GAAG;GAAG;GAAG;GAAI;GAAI;GAAK;GAAM;GAAO,CAEtD,QAAO,yBADQ,GAAG,KAAK,MAAM,QAAQ,IAAI,CAAC,IAAI,QAAQ,KAAK,UAAU,CAAC,SAAS,GAAG,IAAI,IAC9C,IAAI,CAAC,CAAC,KAAK,MAAM;GAE3D;AAEF,MAAK,6CAA6C,EAAE,aAAa;AAC/D,eAAa,yBAAyB,OAAsB,IAAI,CAAC,CAAC,SAAS;AAC3E,eAAa,yBAAyB,SAAwB,IAAI,CAAC,CAAC,SAAS;AAC7E,eAAa,yBAAyB,MAAqB,IAAI,CAAC,CAAC,SAAS;GAC1E;EACF"}

package/dist/esm/utils/currency-constants.d.ts

@@ -0,0 +1,39 @@
+//#region src/utils/currency-constants.d.ts
+type MoneyAmount = `${number}` | `${number}.${number}`;
+type Currency = {
+  code: Uppercase<string>;
+  decimals: number;
+  stripeDecimals: number;
+};
+declare const SUPPORTED_CURRENCIES: [{
+  readonly code: "USD";
+  readonly decimals: 2;
+  readonly stripeDecimals: 2;
+}, {
+  readonly code: "EUR";
+  readonly decimals: 2;
+  readonly stripeDecimals: 2;
+}, {
+  readonly code: "GBP";
+  readonly decimals: 2;
+  readonly stripeDecimals: 2;
+}, {
+  readonly code: "JPY";
+  readonly decimals: 0;
+  readonly stripeDecimals: 0;
+}, {
+  readonly code: "INR";
+  readonly decimals: 2;
+  readonly stripeDecimals: 2;
+}, {
+  readonly code: "AUD";
+  readonly decimals: 2;
+  readonly stripeDecimals: 2;
+}, {
+  readonly code: "CAD";
+  readonly decimals: 2;
+  readonly stripeDecimals: 2;
+}];
+//#endregion
+export { Currency, MoneyAmount, SUPPORTED_CURRENCIES };
+//# sourceMappingURL=currency-constants.d.ts.map

package/dist/esm/utils/currency-constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"currency-constants.d.ts","names":[],"sources":["../../../src/utils/currency-constants.tsx"],"mappings":";KAAY,WAAA;AAAA,KAEA,QAAA;EACV,IAAA,EAAM,SAAA;EACN,QAAA;EACA,cAAA;AAAA;AAAA,cAGW,oBAAA;EAAA"}

package/dist/esm/utils/currency-constants.js

@@ -0,0 +1,42 @@
+//#region src/utils/currency-constants.tsx
+const SUPPORTED_CURRENCIES = [
+	{
+		code: "USD",
+		decimals: 2,
+		stripeDecimals: 2
+	},
+	{
+		code: "EUR",
+		decimals: 2,
+		stripeDecimals: 2
+	},
+	{
+		code: "GBP",
+		decimals: 2,
+		stripeDecimals: 2
+	},
+	{
+		code: "JPY",
+		decimals: 0,
+		stripeDecimals: 0
+	},
+	{
+		code: "INR",
+		decimals: 2,
+		stripeDecimals: 2
+	},
+	{
+		code: "AUD",
+		decimals: 2,
+		stripeDecimals: 2
+	},
+	{
+		code: "CAD",
+		decimals: 2,
+		stripeDecimals: 2
+	}
+];
+
+//#endregion
+export { SUPPORTED_CURRENCIES };
+//# sourceMappingURL=currency-constants.js.map

package/dist/esm/utils/currency-constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"currency-constants.js","names":[],"sources":["../../../src/utils/currency-constants.tsx"],"sourcesContent":["export type MoneyAmount = `${number}` | `${number}.${number}`;\n\nexport type Currency = {\n  code: Uppercase<string>,\n  decimals: number,\n  stripeDecimals: number,\n};\n\nexport const SUPPORTED_CURRENCIES = [\n  {\n    code: 'USD',\n    decimals: 2,\n    stripeDecimals: 2,\n  },\n  {\n    code: 'EUR',\n    decimals: 2,\n    stripeDecimals: 2,\n  },\n  {\n    code: 'GBP',\n    decimals: 2,\n    stripeDecimals: 2,\n  },\n  {\n    code: 'JPY',\n    decimals: 0,\n    stripeDecimals: 0,\n  },\n  {\n    code: 'INR',\n    decimals: 2,\n    stripeDecimals: 2,\n  },\n  {\n    code: 'AUD',\n    decimals: 2,\n    stripeDecimals: 2,\n  },\n  {\n    code: 'CAD',\n    decimals: 2,\n    stripeDecimals: 2,\n  },\n] as const satisfies Currency[];\n"],"mappings":";AAQA,MAAa,uBAAuB;CAClC;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;EACjB;CACD;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;EACjB;CACD;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;EACjB;CACD;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;EACjB;CACD;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;EACjB;CACD;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;EACjB;CACD;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;EACjB;CACF"}

package/dist/esm/utils/dates.d.ts

@@ -0,0 +1,23 @@
+//#region src/utils/dates.d.ts
+declare function isWeekend(date: Date): boolean;
+declare function fromNow(date: Date): string;
+declare function fromNowDetailed(date: Date): {
+  result: string;
+  /**
+   * May be Infinity if the result will never change.
+   */
+  secondsUntilChange: number;
+};
+/**
+ * Returns a string representation of the given date in the format expected by the `datetime-local` input type.
+ */
+declare function getInputDatetimeLocalString(date: Date): string;
+type Interval = [number, 'millisecond' | 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year'];
+type DayInterval = [number, 'day' | 'week' | 'month' | 'year'];
+declare function subtractInterval(date: Date, interval: Interval): Date;
+declare function addInterval(date: Date, interval: Interval): Date;
+declare const FAR_FUTURE_DATE: Date;
+declare function getIntervalsElapsed(anchor: Date, to: Date, repeat: DayInterval): number;
+//#endregion
+export { DayInterval, FAR_FUTURE_DATE, Interval, addInterval, fromNow, fromNowDetailed, getInputDatetimeLocalString, getIntervalsElapsed, isWeekend, subtractInterval };
+//# sourceMappingURL=dates.d.ts.map

package/dist/esm/utils/dates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dates.d.ts","names":[],"sources":["../../../src/utils/dates.tsx"],"mappings":";iBAIgB,SAAA,CAAU,IAAA,EAAM,IAAA;AAAA,iBAuBhB,OAAA,CAAQ,IAAA,EAAM,IAAA;AAAA,iBAiCd,eAAA,CAAgB,IAAA,EAAM,IAAA;EACpC,MAAA;EAzD8B;;AAuBhC;EAsCE,kBAAA;AAAA;;;AALF;iBAkDgB,2BAAA,CAA4B,IAAA,EAAM,IAAA;AAAA,KAkCtC,QAAA;AAAA,KACA,WAAA;AAAA,iBA+CI,gBAAA,CAAiB,IAAA,EAAM,IAAA,EAAM,QAAA,EAAU,QAAA,GAAW,IAAA;AAAA,iBAIlD,WAAA,CAAY,IAAA,EAAM,IAAA,EAAM,QAAA,EAAU,QAAA,GAAW,IAAA;AAAA,cAIhD,eAAA,EAAe,IAAA;AAAA,iBAUZ,mBAAA,CAAoB,MAAA,EAAQ,IAAA,EAAM,EAAA,EAAI,IAAA,EAAM,MAAA,EAAQ,WAAA"}

package/dist/esm/utils/dates.js

@@ -0,0 +1,167 @@
+import { intervalSchema } from "../schema-fields.js";
+import { HexclaveAssertionError } from "./errors.js";
+import { remainder } from "./math.js";
+
+//#region src/utils/dates.tsx
+function isWeekend(date) {
+	return date.getDay() === 0 || date.getDay() === 6;
+}
+(void 0)?.test("isWeekend", ({ expect }) => {
+	expect(isWeekend(new Date(2023, 0, 1))).toBe(true);
+	expect(isWeekend(new Date(2023, 0, 7))).toBe(true);
+	expect(isWeekend(new Date(2023, 0, 2))).toBe(false);
+	expect(isWeekend(new Date(2023, 0, 6))).toBe(false);
+});
+const agoUnits = [
+	[60, "second"],
+	[60, "minute"],
+	[24, "hour"],
+	[7, "day"],
+	[5, "week"]
+];
+function fromNow(date) {
+	return fromNowDetailed(date).result;
+}
+(void 0)?.test("fromNow", ({ expect }) => {
+	const fixedDate = /* @__PURE__ */ new Date("2023-01-15T12:00:00.000Z");
+	(void 0)?.vi.useFakeTimers();
+	(void 0)?.vi.setSystemTime(fixedDate);
+	expect(fromNow(/* @__PURE__ */ new Date("2023-01-15T11:59:50.000Z"))).toBe("just now");
+	expect(fromNow(/* @__PURE__ */ new Date("2023-01-15T11:59:00.000Z"))).toBe("1 minute ago");
+	expect(fromNow(/* @__PURE__ */ new Date("2023-01-15T11:00:00.000Z"))).toBe("1 hour ago");
+	expect(fromNow(/* @__PURE__ */ new Date("2023-01-14T12:00:00.000Z"))).toBe("1 day ago");
+	expect(fromNow(/* @__PURE__ */ new Date("2023-01-08T12:00:00.000Z"))).toBe("1 week ago");
+	expect(fromNow(/* @__PURE__ */ new Date("2023-01-15T12:00:10.000Z"))).toBe("just now");
+	expect(fromNow(/* @__PURE__ */ new Date("2023-01-15T12:01:00.000Z"))).toBe("in 1 minute");
+	expect(fromNow(/* @__PURE__ */ new Date("2023-01-15T13:00:00.000Z"))).toBe("in 1 hour");
+	expect(fromNow(/* @__PURE__ */ new Date("2023-01-16T12:00:00.000Z"))).toBe("in 1 day");
+	expect(fromNow(/* @__PURE__ */ new Date("2023-01-22T12:00:00.000Z"))).toBe("in 1 week");
+	expect(fromNow(/* @__PURE__ */ new Date("2022-01-15T12:00:00.000Z"))).toMatch(/Jan 15, 2022/);
+	(void 0)?.vi.useRealTimers();
+});
+function fromNowDetailed(date) {
+	if (!(date instanceof Date)) throw new Error(`fromNow only accepts Date objects (received: ${date})`);
+	const elapsed = (/* @__PURE__ */ new Date()).getTime() - date.getTime();
+	let remainingInUnit = Math.abs(elapsed) / 1e3;
+	if (remainingInUnit < 15) return {
+		result: "just now",
+		secondsUntilChange: 15 - remainingInUnit
+	};
+	let unitInSeconds = 1;
+	for (const [nextUnitSize, unitName] of agoUnits) {
+		const rounded = Math.round(remainingInUnit);
+		if (rounded < nextUnitSize) if (elapsed < 0) return {
+			result: `in ${rounded} ${unitName}${rounded === 1 ? "" : "s"}`,
+			secondsUntilChange: remainder((remainingInUnit - rounded + .5) * unitInSeconds, unitInSeconds)
+		};
+		else return {
+			result: `${rounded} ${unitName}${rounded === 1 ? "" : "s"} ago`,
+			secondsUntilChange: remainder((rounded - remainingInUnit - .5) * unitInSeconds, unitInSeconds)
+		};
+		unitInSeconds *= nextUnitSize;
+		remainingInUnit /= nextUnitSize;
+	}
+	return {
+		result: date.toLocaleDateString("en-US", {
+			year: "numeric",
+			month: "short",
+			day: "numeric"
+		}),
+		secondsUntilChange: Infinity
+	};
+}
+/**
+* Returns a string representation of the given date in the format expected by the `datetime-local` input type.
+*/
+function getInputDatetimeLocalString(date) {
+	date = new Date(date);
+	date.setMinutes(date.getMinutes() - date.getTimezoneOffset());
+	return date.toISOString().slice(0, 19);
+}
+(void 0)?.test("getInputDatetimeLocalString", ({ expect }) => {
+	(void 0)?.vi.useFakeTimers();
+	expect(getInputDatetimeLocalString(/* @__PURE__ */ new Date("2023-01-15T12:30:45.000Z"))).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/);
+	const dates = [
+		/* @__PURE__ */ new Date("2023-01-01T00:00:00.000Z"),
+		/* @__PURE__ */ new Date("2023-06-15T23:59:59.000Z"),
+		/* @__PURE__ */ new Date("2023-12-31T12:34:56.000Z")
+	];
+	for (const date of dates) expect(getInputDatetimeLocalString(date)).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/);
+	(void 0)?.vi.useRealTimers();
+});
+function applyInterval(date, times, interval) {
+	if (!intervalSchema.isValidSync(interval)) throw new HexclaveAssertionError(`Invalid interval`, { interval });
+	const [amount, unit] = interval;
+	switch (unit) {
+		case "millisecond":
+			date.setMilliseconds(date.getMilliseconds() + amount * times);
+			break;
+		case "second":
+			date.setSeconds(date.getSeconds() + amount * times);
+			break;
+		case "minute":
+			date.setMinutes(date.getMinutes() + amount * times);
+			break;
+		case "hour":
+			date.setHours(date.getHours() + amount * times);
+			break;
+		case "day":
+			date.setDate(date.getDate() + amount * times);
+			break;
+		case "week":
+			date.setDate(date.getDate() + amount * times * 7);
+			break;
+		case "month":
+			date.setMonth(date.getMonth() + amount * times);
+			break;
+		case "year":
+			date.setFullYear(date.getFullYear() + amount * times);
+			break;
+		default: throw new HexclaveAssertionError(`Invalid interval despite schema validation`, { interval });
+	}
+	return date;
+}
+function subtractInterval(date, interval) {
+	return applyInterval(date, -1, interval);
+}
+function addInterval(date, interval) {
+	return applyInterval(date, 1, interval);
+}
+const FAR_FUTURE_DATE = /* @__PURE__ */ new Date(864e13);
+function getMsPerDayIntervalUnit(unit) {
+	if (unit === "day") return 1440 * 60 * 1e3;
+	return 10080 * 60 * 1e3;
+}
+function getIntervalsElapsed(anchor, to, repeat) {
+	const [amount, unit] = repeat;
+	if (to <= anchor) return 0;
+	if (unit === "day" || unit === "week") {
+		const msPerUnit = getMsPerDayIntervalUnit(unit);
+		const diffMs = to.getTime() - anchor.getTime();
+		return Math.floor(diffMs / (msPerUnit * amount));
+	}
+	if (["month", "year"].includes(unit)) {
+		let count = 0;
+		let current = new Date(anchor);
+		for (;;) {
+			const next = addInterval(new Date(current), [amount, unit]);
+			if (next > to) break;
+			current = next;
+			count += 1;
+		}
+		return count;
+	}
+	return 0;
+}
+(void 0)?.test("getIntervalsElapsed", ({ expect }) => {
+	const anchor = /* @__PURE__ */ new Date("2025-01-01T00:00:00.000Z");
+	const to = /* @__PURE__ */ new Date("2025-01-15T00:00:00.000Z");
+	expect(getIntervalsElapsed(anchor, to, [1, "week"])).toBe(2);
+	expect(getIntervalsElapsed(anchor, to, [3, "day"])).toBe(4);
+	expect(getIntervalsElapsed(/* @__PURE__ */ new Date("2023-01-31T00:00:00.000Z"), /* @__PURE__ */ new Date("2023-03-01T00:00:00.000Z"), [1, "month"])).toBe(0);
+	expect(getIntervalsElapsed(/* @__PURE__ */ new Date("2020-01-01T00:00:00.000Z"), /* @__PURE__ */ new Date("2022-06-01T00:00:00.000Z"), [1, "year"])).toBe(2);
+});
+
+//#endregion
+export { FAR_FUTURE_DATE, addInterval, fromNow, fromNowDetailed, getInputDatetimeLocalString, getIntervalsElapsed, isWeekend, subtractInterval };
+//# sourceMappingURL=dates.js.map

package/dist/esm/utils/dates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dates.js","names":[],"sources":["../../../src/utils/dates.tsx"],"sourcesContent":["import { intervalSchema } from \"../schema-fields\";\nimport { HexclaveAssertionError } from \"./errors\";\nimport { remainder } from \"./math\";\n\nexport function isWeekend(date: Date): boolean {\n  return date.getDay() === 0 || date.getDay() === 6;\n}\n\nimport.meta.vitest?.test(\"isWeekend\", ({ expect }) => {\n  // Sunday (day 0)\n  expect(isWeekend(new Date(2023, 0, 1))).toBe(true);\n  // Saturday (day 6)\n  expect(isWeekend(new Date(2023, 0, 7))).toBe(true);\n  // Monday (day 1)\n  expect(isWeekend(new Date(2023, 0, 2))).toBe(false);\n  // Friday (day 5)\n  expect(isWeekend(new Date(2023, 0, 6))).toBe(false);\n});\n\nconst agoUnits = [\n  [60, 'second'],\n  [60, 'minute'],\n  [24, 'hour'],\n  [7, 'day'],\n  [5, 'week'],\n] as const;\n\nexport function fromNow(date: Date): string {\n  return fromNowDetailed(date).result;\n}\n\nimport.meta.vitest?.test(\"fromNow\", ({ expect }) => {\n  // Set a fixed date for testing\n  const fixedDate = new Date(\"2023-01-15T12:00:00.000Z\");\n\n  // Use Vitest's fake timers\n  import.meta.vitest?.vi.useFakeTimers();\n  import.meta.vitest?.vi.setSystemTime(fixedDate);\n\n  // Test past times\n  expect(fromNow(new Date(\"2023-01-15T11:59:50.000Z\"))).toBe(\"just now\");\n  expect(fromNow(new Date(\"2023-01-15T11:59:00.000Z\"))).toBe(\"1 minute ago\");\n  expect(fromNow(new Date(\"2023-01-15T11:00:00.000Z\"))).toBe(\"1 hour ago\");\n  expect(fromNow(new Date(\"2023-01-14T12:00:00.000Z\"))).toBe(\"1 day ago\");\n  expect(fromNow(new Date(\"2023-01-08T12:00:00.000Z\"))).toBe(\"1 week ago\");\n\n  // Test future times\n  expect(fromNow(new Date(\"2023-01-15T12:00:10.000Z\"))).toBe(\"just now\");\n  expect(fromNow(new Date(\"2023-01-15T12:01:00.000Z\"))).toBe(\"in 1 minute\");\n  expect(fromNow(new Date(\"2023-01-15T13:00:00.000Z\"))).toBe(\"in 1 hour\");\n  expect(fromNow(new Date(\"2023-01-16T12:00:00.000Z\"))).toBe(\"in 1 day\");\n  expect(fromNow(new Date(\"2023-01-22T12:00:00.000Z\"))).toBe(\"in 1 week\");\n\n  // Test very old dates (should use date format)\n  expect(fromNow(new Date(\"2022-01-15T12:00:00.000Z\"))).toMatch(/Jan 15, 2022/);\n\n  // Restore real timers\n  import.meta.vitest?.vi.useRealTimers();\n});\n\nexport function fromNowDetailed(date: Date): {\n  result: string,\n  /**\n   * May be Infinity if the result will never change.\n   */\n  secondsUntilChange: number,\n} {\n  if (!(date instanceof Date)) {\n    throw new Error(`fromNow only accepts Date objects (received: ${date})`);\n  }\n\n  const now = new Date();\n  const elapsed = now.getTime() - date.getTime();\n\n  let remainingInUnit = Math.abs(elapsed) / 1000;\n  if (remainingInUnit < 15) {\n    return {\n      result: 'just now',\n      secondsUntilChange: 15 - remainingInUnit,\n    };\n  }\n  let unitInSeconds = 1;\n  for (const [nextUnitSize, unitName] of agoUnits) {\n    const rounded = Math.round(remainingInUnit);\n    if (rounded < nextUnitSize) {\n      if (elapsed < 0) {\n        return {\n          result: `in ${rounded} ${unitName}${rounded === 1 ? '' : 's'}`,\n          secondsUntilChange: remainder((remainingInUnit - rounded + 0.5) * unitInSeconds, unitInSeconds),\n        };\n      } else {\n        return {\n          result: `${rounded} ${unitName}${rounded === 1 ? '' : 's'} ago`,\n          secondsUntilChange: remainder((rounded - remainingInUnit - 0.5) * unitInSeconds, unitInSeconds),\n        };\n      }\n    }\n    unitInSeconds *= nextUnitSize;\n    remainingInUnit /= nextUnitSize;\n  }\n\n  return {\n    result: date.toLocaleDateString('en-US', { year: 'numeric', month: 'short', day: 'numeric' }),\n    secondsUntilChange: Infinity,\n  };\n}\n\n/**\n * Returns a string representation of the given date in the format expected by the `datetime-local` input type.\n */\nexport function getInputDatetimeLocalString(date: Date): string {\n  date = new Date(date);\n  date.setMinutes(date.getMinutes() - date.getTimezoneOffset());\n  return date.toISOString().slice(0, 19);\n}\n\nimport.meta.vitest?.test(\"getInputDatetimeLocalString\", ({ expect }) => {\n  // Use Vitest's fake timers to ensure consistent timezone behavior\n  import.meta.vitest?.vi.useFakeTimers();\n\n  // Test with a specific date\n  const mockDate = new Date(\"2023-01-15T12:30:45.000Z\");\n  const result = getInputDatetimeLocalString(mockDate);\n\n  // The result should be in the format YYYY-MM-DDTHH:MM:SS\n  expect(result).toMatch(/^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}$/);\n\n  // Test with different dates\n  const dates = [\n    new Date(\"2023-01-01T00:00:00.000Z\"),\n    new Date(\"2023-06-15T23:59:59.000Z\"),\n    new Date(\"2023-12-31T12:34:56.000Z\"),\n  ];\n\n  for (const date of dates) {\n    const result = getInputDatetimeLocalString(date);\n    expect(result).toMatch(/^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}$/);\n  }\n\n  // Restore real timers\n  import.meta.vitest?.vi.useRealTimers();\n});\n\n\nexport type Interval = [number, 'millisecond' | 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year'];\nexport type DayInterval = [number, 'day' | 'week' | 'month' | 'year'];\n\nfunction applyInterval(date: Date, times: number, interval: Interval): Date {\n  if (!intervalSchema.isValidSync(interval)) {\n    throw new HexclaveAssertionError(`Invalid interval`, { interval });\n  }\n  const [amount, unit] = interval;\n  switch (unit) {\n    case 'millisecond': {\n      date.setMilliseconds(date.getMilliseconds() + amount * times);\n      break;\n    }\n    case 'second': {\n      date.setSeconds(date.getSeconds() + amount * times);\n      break;\n    }\n    case 'minute': {\n      date.setMinutes(date.getMinutes() + amount * times);\n      break;\n    }\n    case 'hour': {\n      date.setHours(date.getHours() + amount * times);\n      break;\n    }\n    case 'day': {\n      date.setDate(date.getDate() + amount * times);\n      break;\n    }\n    case 'week': {\n      date.setDate(date.getDate() + amount * times * 7);\n      break;\n    }\n    case 'month': {\n      date.setMonth(date.getMonth() + amount * times);\n      break;\n    }\n    case 'year': {\n      date.setFullYear(date.getFullYear() + amount * times);\n      break;\n    }\n    default: {\n      throw new HexclaveAssertionError(`Invalid interval despite schema validation`, { interval });\n    }\n  }\n  return date;\n}\n\nexport function subtractInterval(date: Date, interval: Interval): Date {\n  return applyInterval(date, -1, interval);\n}\n\nexport function addInterval(date: Date, interval: Interval): Date {\n  return applyInterval(date, 1, interval);\n}\n\nexport const FAR_FUTURE_DATE = new Date(8640000000000000); // 13 Sep 275760 00:00:00 UTC\n\nfunction getMsPerDayIntervalUnit(unit: 'day' | 'week'): number {\n  if (unit === 'day') {\n    return 24 * 60 * 60 * 1000;\n  }\n  return 7 * 24 * 60 * 60 * 1000;\n}\n\n\nexport function getIntervalsElapsed(anchor: Date, to: Date, repeat: DayInterval): number {\n  const [amount, unit] = repeat;\n  if (to <= anchor) return 0;\n  if (unit === 'day' || unit === 'week') {\n    const msPerUnit = getMsPerDayIntervalUnit(unit);\n    const diffMs = to.getTime() - anchor.getTime();\n    return Math.floor(diffMs / (msPerUnit * amount));\n  }\n  if ([\"month\", \"year\"].includes(unit)) {\n    let count = 0;\n    let current = new Date(anchor);\n    for (; ;) {\n      const next = addInterval(new Date(current), [amount, unit]);\n      if (next > to) break;\n      current = next;\n      count += 1;\n    }\n    return count;\n  }\n  return 0;\n}\n\nimport.meta.vitest?.test(\"getIntervalsElapsed\", ({ expect }) => {\n  const anchor = new Date('2025-01-01T00:00:00.000Z');\n  const to = new Date('2025-01-15T00:00:00.000Z');\n  expect(getIntervalsElapsed(anchor, to, [1, 'week'])).toBe(2);\n  expect(getIntervalsElapsed(anchor, to, [3, 'day'])).toBe(4);\n\n  const mAnchor = new Date('2023-01-31T00:00:00.000Z');\n  const mTo = new Date('2023-03-01T00:00:00.000Z');\n  expect(getIntervalsElapsed(mAnchor, mTo, [1, 'month'])).toBe(0);\n\n  const yAnchor = new Date('2020-01-01T00:00:00.000Z');\n  const yTo = new Date('2022-06-01T00:00:00.000Z');\n  expect(getIntervalsElapsed(yAnchor, yTo, [1, 'year'])).toBe(2);\n});\n"],"mappings":"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"}

package/dist/esm/utils/dev-env-state-path.d.ts

@@ -0,0 +1,6 @@
+//#region src/utils/dev-env-state-path.d.ts
+declare function defaultStackDevEnvStatePath(): string;
+declare function stackDevEnvStatePath(): string;
+//#endregion
+export { defaultStackDevEnvStatePath, stackDevEnvStatePath };
+//# sourceMappingURL=dev-env-state-path.d.ts.map

package/dist/esm/utils/dev-env-state-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-env-state-path.d.ts","names":[],"sources":["../../../src/utils/dev-env-state-path.ts"],"mappings":";iBAGgB,2BAAA,CAAA;AAAA,iBAQA,oBAAA,CAAA"}