@hexclave/shared 1.0.0

package/dist/utils/http.js

@@ -0,0 +1,79 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
+let __bytes_js = require("./bytes.js");
+
+//#region src/utils/http.tsx
+const HTTP_METHODS = {
+	"GET": {
+		safe: true,
+		idempotent: true
+	},
+	"POST": {
+		safe: false,
+		idempotent: false
+	},
+	"PUT": {
+		safe: false,
+		idempotent: true
+	},
+	"DELETE": {
+		safe: false,
+		idempotent: true
+	},
+	"PATCH": {
+		safe: false,
+		idempotent: false
+	},
+	"OPTIONS": {
+		safe: true,
+		idempotent: true
+	},
+	"HEAD": {
+		safe: true,
+		idempotent: true
+	},
+	"TRACE": {
+		safe: true,
+		idempotent: true
+	},
+	"CONNECT": {
+		safe: false,
+		idempotent: false
+	}
+};
+function decodeBasicAuthorizationHeader(value) {
+	const [type, encoded, ...rest] = value.split(" ");
+	if (rest.length > 0) return null;
+	if (!encoded) return null;
+	if (type !== "Basic") return null;
+	if (!(0, __bytes_js.isBase64)(encoded)) return null;
+	const split = new TextDecoder().decode((0, __bytes_js.decodeBase64)(encoded)).split(":");
+	return [split[0], split.slice(1).join(":")];
+}
+(void 0)?.test("decodeBasicAuthorizationHeader", ({ expect }) => {
+	const username = "user";
+	const password = "pass";
+	expect(decodeBasicAuthorizationHeader(encodeBasicAuthorizationHeader(username, password))).toEqual([username, password]);
+	const complexPassword = "pass:with:colons";
+	expect(decodeBasicAuthorizationHeader(encodeBasicAuthorizationHeader(username, complexPassword))).toEqual([username, complexPassword]);
+	expect(decodeBasicAuthorizationHeader("NotBasic dXNlcjpwYXNz")).toBe(null);
+	expect(decodeBasicAuthorizationHeader("Basic")).toBe(null);
+	expect(decodeBasicAuthorizationHeader("Basic not-base64")).toBe(null);
+	expect(decodeBasicAuthorizationHeader("Basic dXNlcjpwYXNz extra")).toBe(null);
+});
+function encodeBasicAuthorizationHeader(id, password) {
+	if (id.includes(":")) throw new Error("Basic authorization header id cannot contain ':'");
+	return `Basic ${(0, __bytes_js.encodeBase64)(new TextEncoder().encode(`${id}:${password}`))}`;
+}
+(void 0)?.test("encodeBasicAuthorizationHeader", ({ expect }) => {
+	expect(encodeBasicAuthorizationHeader("user", "pass")).toMatch(/^Basic [A-Za-z0-9+/=]+$/);
+	expect(encodeBasicAuthorizationHeader("user", "")).toMatch(/^Basic [A-Za-z0-9+/=]+$/);
+	expect(encodeBasicAuthorizationHeader("user", "p@ss!w0rd")).toMatch(/^Basic [A-Za-z0-9+/=]+$/);
+	expect(() => encodeBasicAuthorizationHeader("user:name", "pass")).toThrow();
+});
+
+//#endregion
+exports.HTTP_METHODS = HTTP_METHODS;
+exports.decodeBasicAuthorizationHeader = decodeBasicAuthorizationHeader;
+exports.encodeBasicAuthorizationHeader = encodeBasicAuthorizationHeader;
+//# sourceMappingURL=http.js.map

package/dist/utils/http.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.js","names":[],"sources":["../../src/utils/http.tsx"],"sourcesContent":["import { decodeBase64, encodeBase64, isBase64 } from \"./bytes\";\n\nexport const HTTP_METHODS = {\n  \"GET\": {\n    safe: true,\n    idempotent: true,\n  },\n  \"POST\": {\n    safe: false,\n    idempotent: false,\n  },\n  \"PUT\": {\n    safe: false,\n    idempotent: true,\n  },\n  \"DELETE\": {\n    safe: false,\n    idempotent: true,\n  },\n  \"PATCH\": {\n    safe: false,\n    idempotent: false,\n  },\n  \"OPTIONS\": {\n    safe: true,\n    idempotent: true,\n  },\n  \"HEAD\": {\n    safe: true,\n    idempotent: true,\n  },\n  \"TRACE\": {\n    safe: true,\n    idempotent: true,\n  },\n  \"CONNECT\": {\n    safe: false,\n    idempotent: false,\n  },\n} as const;\nexport type HttpMethod = keyof typeof HTTP_METHODS;\n\nexport function decodeBasicAuthorizationHeader(value: string): [string, string] | null {\n  const [type, encoded, ...rest] = value.split(' ');\n  if (rest.length > 0) return null;\n  if (!encoded) return null;\n  if (type !== 'Basic') return null;\n  if (!isBase64(encoded)) return null;\n  const decoded = new TextDecoder().decode(decodeBase64(encoded));\n  const split = decoded.split(':');\n  return [split[0], split.slice(1).join(':')];\n}\nimport.meta.vitest?.test(\"decodeBasicAuthorizationHeader\", ({ expect }) => {\n  // Test with valid Basic Authorization header\n  const username = \"user\";\n  const password = \"pass\";\n  const encoded = encodeBasicAuthorizationHeader(username, password);\n  expect(decodeBasicAuthorizationHeader(encoded)).toEqual([username, password]);\n\n  // Test with password containing colons\n  const complexPassword = \"pass:with:colons\";\n  const encodedComplex = encodeBasicAuthorizationHeader(username, complexPassword);\n  expect(decodeBasicAuthorizationHeader(encodedComplex)).toEqual([username, complexPassword]);\n\n  // Test with invalid headers\n  expect(decodeBasicAuthorizationHeader(\"NotBasic dXNlcjpwYXNz\")).toBe(null); // Wrong type\n  expect(decodeBasicAuthorizationHeader(\"Basic\")).toBe(null); // Missing encoded part\n  expect(decodeBasicAuthorizationHeader(\"Basic not-base64\")).toBe(null); // Not base64\n  expect(decodeBasicAuthorizationHeader(\"Basic dXNlcjpwYXNz extra\")).toBe(null); // Extra parts\n});\n\nexport function encodeBasicAuthorizationHeader(id: string, password: string): string {\n  if (id.includes(':')) throw new Error(\"Basic authorization header id cannot contain ':'\");\n  return `Basic ${encodeBase64(new TextEncoder().encode(`${id}:${password}`))}`;\n}\nimport.meta.vitest?.test(\"encodeBasicAuthorizationHeader\", ({ expect }) => {\n  // Test with simple username and password\n  const encoded = encodeBasicAuthorizationHeader(\"user\", \"pass\");\n  expect(encoded).toMatch(/^Basic [A-Za-z0-9+/=]+$/); // Should start with \"Basic \" followed by base64\n\n  // Test with empty password\n  const encodedEmptyPass = encodeBasicAuthorizationHeader(\"user\", \"\");\n  expect(encodedEmptyPass).toMatch(/^Basic [A-Za-z0-9+/=]+$/);\n\n  // Test with password containing special characters\n  const encodedSpecialChars = encodeBasicAuthorizationHeader(\"user\", \"p@ss!w0rd\");\n  expect(encodedSpecialChars).toMatch(/^Basic [A-Za-z0-9+/=]+$/);\n\n  // Test with username containing colon should throw\n  expect(() => encodeBasicAuthorizationHeader(\"user:name\", \"pass\")).toThrow();\n});\n"],"mappings":";;;;;AAEA,MAAa,eAAe;CAC1B,OAAO;EACL,MAAM;EACN,YAAY;EACb;CACD,QAAQ;EACN,MAAM;EACN,YAAY;EACb;CACD,OAAO;EACL,MAAM;EACN,YAAY;EACb;CACD,UAAU;EACR,MAAM;EACN,YAAY;EACb;CACD,SAAS;EACP,MAAM;EACN,YAAY;EACb;CACD,WAAW;EACT,MAAM;EACN,YAAY;EACb;CACD,QAAQ;EACN,MAAM;EACN,YAAY;EACb;CACD,SAAS;EACP,MAAM;EACN,YAAY;EACb;CACD,WAAW;EACT,MAAM;EACN,YAAY;EACb;CACF;AAGD,SAAgB,+BAA+B,OAAwC;CACrF,MAAM,CAAC,MAAM,SAAS,GAAG,QAAQ,MAAM,MAAM,IAAI;AACjD,KAAI,KAAK,SAAS,EAAG,QAAO;AAC5B,KAAI,CAAC,QAAS,QAAO;AACrB,KAAI,SAAS,QAAS,QAAO;AAC7B,KAAI,0BAAU,QAAQ,CAAE,QAAO;CAE/B,MAAM,QADU,IAAI,aAAa,CAAC,oCAAoB,QAAQ,CAAC,CACzC,MAAM,IAAI;AAChC,QAAO,CAAC,MAAM,IAAI,MAAM,MAAM,EAAE,CAAC,KAAK,IAAI,CAAC;;CAE7C,SAAW,KAAC,mCAAc,EAAA,aAAoC;CAE5D,MAAM,WAAW;CACjB,MAAM,WAAW;AAEjB,QAAO,+BADS,+BAA+B,UAAU,SAAS,CACpB,CAAC,CAAC,QAAQ,CAAC,UAAU,SAAS,CAAC;CAG7E,MAAM,kBAAkB;AAExB,QAAO,+BADgB,+BAA+B,UAAU,gBAAgB,CAC3B,CAAC,CAAC,QAAQ,CAAC,UAAU,gBAAgB,CAAC;AAG3F,QAAO,+BAA+B,wBAAwB,CAAC,CAAC,KAAK,KAAK;AAC1E,QAAO,+BAA+B,QAAQ,CAAC,CAAC,KAAK,KAAK;AAC1D,QAAO,+BAA+B,mBAAmB,CAAC,CAAC,KAAK,KAAK;AACrE,QAAO,+BAA+B,2BAA2B,CAAC,CAAC,KAAK,KAAK;EAC7E;AAEF,SAAgB,+BAA+B,IAAY,UAA0B;AACnF,KAAI,GAAG,SAAS,IAAI,CAAE,OAAM,IAAI,MAAM,mDAAmD;AACzF,QAAO,sCAAsB,IAAI,aAAa,CAAC,OAAO,GAAG,GAAG,GAAG,WAAW,CAAC;;CAE7E,SAAW,KAAC,mCAAc,EAAA,aAAoC;AAG5D,QADgB,+BAA+B,QAAQ,OAAO,CAC/C,CAAC,QAAQ,0BAA0B;AAIlD,QADyB,+BAA+B,QAAQ,GAAG,CAC3C,CAAC,QAAQ,0BAA0B;AAI3D,QAD4B,+BAA+B,QAAQ,YAAY,CACpD,CAAC,QAAQ,0BAA0B;AAG9D,cAAa,+BAA+B,aAAa,OAAO,CAAC,CAAC,SAAS;EAC3E"}

package/dist/utils/ips.d.ts

@@ -0,0 +1,8 @@
+//#region src/utils/ips.d.ts
+type Ipv4Address = `${number}.${number}.${number}.${number}`;
+type Ipv6Address = string;
+declare function isIpAddress(ip: string): boolean;
+declare function assertIpAddress(ip: string): asserts ip is Ipv4Address | Ipv6Address;
+//#endregion
+export { Ipv4Address, Ipv6Address, assertIpAddress, isIpAddress };
+//# sourceMappingURL=ips.d.ts.map

package/dist/utils/ips.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ips.d.ts","names":[],"sources":["../../src/utils/ips.tsx"],"mappings":";KAEY,WAAA;AAAA,KACA,WAAA;AAAA,iBAEI,WAAA,CAAY,EAAA;AAAA,iBAwBZ,eAAA,CAAgB,EAAA,mBAAqB,EAAA,IAAM,WAAA,GAAc,WAAA"}

package/dist/utils/ips.js

@@ -0,0 +1,40 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
+let ip_regex = require("ip-regex");
+ip_regex = require_chunk.__toESM(ip_regex);
+
+//#region src/utils/ips.tsx
+function isIpAddress(ip) {
+	return (0, ip_regex.default)({ exact: true }).test(ip);
+}
+(void 0)?.test("isIpAddress", ({ expect }) => {
+	expect(isIpAddress("192.168.1.1")).toBe(true);
+	expect(isIpAddress("127.0.0.1")).toBe(true);
+	expect(isIpAddress("0.0.0.0")).toBe(true);
+	expect(isIpAddress("255.255.255.255")).toBe(true);
+	expect(isIpAddress("::1")).toBe(true);
+	expect(isIpAddress("2001:db8::")).toBe(true);
+	expect(isIpAddress("2001:db8:85a3:8d3:1319:8a2e:370:7348")).toBe(true);
+	expect(isIpAddress("")).toBe(false);
+	expect(isIpAddress("not an ip")).toBe(false);
+	expect(isIpAddress("256.256.256.256")).toBe(false);
+	expect(isIpAddress("192.168.1")).toBe(false);
+	expect(isIpAddress("192.168.1.1.1")).toBe(false);
+	expect(isIpAddress("2001:db8::xyz")).toBe(false);
+});
+function assertIpAddress(ip) {
+	if (!isIpAddress(ip)) throw new Error(`Invalid IP address: ${ip}`);
+}
+(void 0)?.test("assertIpAddress", ({ expect }) => {
+	expect(() => assertIpAddress("192.168.1.1")).not.toThrow();
+	expect(() => assertIpAddress("::1")).not.toThrow();
+	expect(() => assertIpAddress("")).toThrow("Invalid IP address: ");
+	expect(() => assertIpAddress("not an ip")).toThrow("Invalid IP address: not an ip");
+	expect(() => assertIpAddress("256.256.256.256")).toThrow("Invalid IP address: 256.256.256.256");
+	expect(() => assertIpAddress("192.168.1")).toThrow("Invalid IP address: 192.168.1");
+});
+
+//#endregion
+exports.assertIpAddress = assertIpAddress;
+exports.isIpAddress = isIpAddress;
+//# sourceMappingURL=ips.js.map

package/dist/utils/ips.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ips.js","names":[],"sources":["../../src/utils/ips.tsx"],"sourcesContent":["import ipRegex from \"ip-regex\";\n\nexport type Ipv4Address = `${number}.${number}.${number}.${number}`;\nexport type Ipv6Address = string;\n\nexport function isIpAddress(ip: string) {\n  return ipRegex({ exact: true }).test(ip);\n}\nimport.meta.vitest?.test(\"isIpAddress\", ({ expect }) => {\n  // Test valid IPv4 addresses\n  expect(isIpAddress(\"192.168.1.1\")).toBe(true);\n  expect(isIpAddress(\"127.0.0.1\")).toBe(true);\n  expect(isIpAddress(\"0.0.0.0\")).toBe(true);\n  expect(isIpAddress(\"255.255.255.255\")).toBe(true);\n\n  // Test valid IPv6 addresses\n  expect(isIpAddress(\"::1\")).toBe(true);\n  expect(isIpAddress(\"2001:db8::\")).toBe(true);\n  expect(isIpAddress(\"2001:db8:85a3:8d3:1319:8a2e:370:7348\")).toBe(true);\n\n  // Test invalid IP addresses\n  expect(isIpAddress(\"\")).toBe(false);\n  expect(isIpAddress(\"not an ip\")).toBe(false);\n  expect(isIpAddress(\"256.256.256.256\")).toBe(false);\n  expect(isIpAddress(\"192.168.1\")).toBe(false);\n  expect(isIpAddress(\"192.168.1.1.1\")).toBe(false);\n  expect(isIpAddress(\"2001:db8::xyz\")).toBe(false);\n});\n\nexport function assertIpAddress(ip: string): asserts ip is Ipv4Address | Ipv6Address {\n  if (!isIpAddress(ip)) {\n    throw new Error(`Invalid IP address: ${ip}`);\n  }\n}\nimport.meta.vitest?.test(\"assertIpAddress\", ({ expect }) => {\n  // Test with valid IPv4 address\n  expect(() => assertIpAddress(\"192.168.1.1\")).not.toThrow();\n\n  // Test with valid IPv6 address\n  expect(() => assertIpAddress(\"::1\")).not.toThrow();\n\n  // Test with invalid IP addresses\n  expect(() => assertIpAddress(\"\")).toThrow(\"Invalid IP address: \");\n  expect(() => assertIpAddress(\"not an ip\")).toThrow(\"Invalid IP address: not an ip\");\n  expect(() => assertIpAddress(\"256.256.256.256\")).toThrow(\"Invalid IP address: 256.256.256.256\");\n  expect(() => assertIpAddress(\"192.168.1\")).toThrow(\"Invalid IP address: 192.168.1\");\n});\n"],"mappings":";;;;;;AAKA,SAAgB,YAAY,IAAY;AACtC,8BAAe,EAAE,OAAO,MAAM,CAAC,CAAC,KAAK,GAAG;;CAE1C,SAAW,KAAC,gBAAc,EAAA,aAAiB;AAEzC,QAAO,YAAY,cAAc,CAAC,CAAC,KAAK,KAAK;AAC7C,QAAO,YAAY,YAAY,CAAC,CAAC,KAAK,KAAK;AAC3C,QAAO,YAAY,UAAU,CAAC,CAAC,KAAK,KAAK;AACzC,QAAO,YAAY,kBAAkB,CAAC,CAAC,KAAK,KAAK;AAGjD,QAAO,YAAY,MAAM,CAAC,CAAC,KAAK,KAAK;AACrC,QAAO,YAAY,aAAa,CAAC,CAAC,KAAK,KAAK;AAC5C,QAAO,YAAY,uCAAuC,CAAC,CAAC,KAAK,KAAK;AAGtE,QAAO,YAAY,GAAG,CAAC,CAAC,KAAK,MAAM;AACnC,QAAO,YAAY,YAAY,CAAC,CAAC,KAAK,MAAM;AAC5C,QAAO,YAAY,kBAAkB,CAAC,CAAC,KAAK,MAAM;AAClD,QAAO,YAAY,YAAY,CAAC,CAAC,KAAK,MAAM;AAC5C,QAAO,YAAY,gBAAgB,CAAC,CAAC,KAAK,MAAM;AAChD,QAAO,YAAY,gBAAgB,CAAC,CAAC,KAAK,MAAM;EAChD;AAEF,SAAgB,gBAAgB,IAAqD;AACnF,KAAI,CAAC,YAAY,GAAG,CAClB,OAAM,IAAI,MAAM,uBAAuB,KAAK;;CAGhD,SAAW,KAAC,oBAAc,EAAA,aAAqB;AAE7C,cAAa,gBAAgB,cAAc,CAAC,CAAC,IAAI,SAAS;AAG1D,cAAa,gBAAgB,MAAM,CAAC,CAAC,IAAI,SAAS;AAGlD,cAAa,gBAAgB,GAAG,CAAC,CAAC,QAAQ,uBAAuB;AACjE,cAAa,gBAAgB,YAAY,CAAC,CAAC,QAAQ,gCAAgC;AACnF,cAAa,gBAAgB,kBAAkB,CAAC,CAAC,QAAQ,sCAAsC;AAC/F,cAAa,gBAAgB,YAAY,CAAC,CAAC,QAAQ,gCAAgC;EACnF"}

package/dist/utils/json.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "./results.js";
+
+//#region src/utils/json.d.ts
+type Json = null | boolean | number | string | Json[] | {
+  [key: string]: Json;
+};
+type ReadonlyJson = null | boolean | number | string | readonly ReadonlyJson[] | {
+  readonly [key: string]: ReadonlyJson;
+};
+declare function isJsonSerializable(value: unknown): value is Json;
+declare function parseJson(json: string): Result<Json>;
+declare function stringifyJson(json: Json): Result<string>;
+//#endregion
+export { Json, ReadonlyJson, isJsonSerializable, parseJson, stringifyJson };
+//# sourceMappingURL=json.d.ts.map

package/dist/utils/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","names":[],"sources":["../../src/utils/json.tsx"],"mappings":";;;KAEY,IAAA,sCAKR,IAAA;EAAA,CACG,GAAA,WAAc,IAAA;AAAA;AAAA,KAET,YAAA,+CAKC,YAAA;EAAA,UACG,GAAA,WAAc,YAAA;AAAA;AAAA,iBAEd,kBAAA,CAAmB,KAAA,YAAiB,KAAA,IAAS,IAAA;AAAA,iBAqD7C,SAAA,CAAU,IAAA,WAAe,MAAA,CAAO,IAAA;AAAA,iBA6DhC,aAAA,CAAc,IAAA,EAAM,IAAA,GAAO,MAAA"}

package/dist/utils/json.js

@@ -0,0 +1,182 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
+let __results_js = require("./results.js");
+
+//#region src/utils/json.tsx
+function isJsonSerializable(value) {
+	switch (typeof value) {
+		case "object":
+			if (value === null) return true;
+			if (Array.isArray(value)) return value.every(isJsonSerializable);
+			return Object.keys(value).every((k) => typeof k === "string") && Object.values(value).every(isJsonSerializable);
+		case "string":
+		case "number":
+		case "boolean": return true;
+		default: return false;
+	}
+}
+(void 0)?.test("isJsonSerializable", ({ expect }) => {
+	expect(isJsonSerializable(null)).toBe(true);
+	expect(isJsonSerializable(true)).toBe(true);
+	expect(isJsonSerializable(false)).toBe(true);
+	expect(isJsonSerializable(123)).toBe(true);
+	expect(isJsonSerializable("string")).toBe(true);
+	expect(isJsonSerializable([])).toBe(true);
+	expect(isJsonSerializable([
+		1,
+		2,
+		3
+	])).toBe(true);
+	expect(isJsonSerializable([
+		"a",
+		"b",
+		"c"
+	])).toBe(true);
+	expect(isJsonSerializable([
+		1,
+		"a",
+		true,
+		null
+	])).toBe(true);
+	expect(isJsonSerializable([
+		1,
+		[2, 3],
+		{ a: "b" }
+	])).toBe(true);
+	expect(isJsonSerializable({})).toBe(true);
+	expect(isJsonSerializable({
+		a: 1,
+		b: 2
+	})).toBe(true);
+	expect(isJsonSerializable({
+		a: "string",
+		b: true,
+		c: null
+	})).toBe(true);
+	expect(isJsonSerializable({
+		a: [
+			1,
+			2,
+			3
+		],
+		b: { c: "d" }
+	})).toBe(true);
+	expect(isJsonSerializable(void 0)).toBe(false);
+	expect(isJsonSerializable(() => {})).toBe(false);
+	expect(isJsonSerializable(Symbol())).toBe(false);
+	expect(isJsonSerializable(BigInt(123))).toBe(false);
+	expect(isJsonSerializable([
+		1,
+		void 0,
+		3
+	])).toBe(false);
+	expect(isJsonSerializable([
+		1,
+		() => {},
+		3
+	])).toBe(false);
+	expect(isJsonSerializable({
+		a: 1,
+		b: void 0
+	})).toBe(false);
+	expect(isJsonSerializable({
+		a: 1,
+		b: () => {}
+	})).toBe(false);
+});
+function parseJson(json) {
+	return __results_js.Result.fromThrowing(() => JSON.parse(json));
+}
+(void 0)?.test("parseJson", ({ expect }) => {
+	const nullResult = parseJson("null");
+	expect(nullResult.status).toBe("ok");
+	if (nullResult.status === "ok") expect(nullResult.data).toBe(null);
+	const trueResult = parseJson("true");
+	expect(trueResult.status).toBe("ok");
+	if (trueResult.status === "ok") expect(trueResult.data).toBe(true);
+	const numberResult = parseJson("123");
+	expect(numberResult.status).toBe("ok");
+	if (numberResult.status === "ok") expect(numberResult.data).toBe(123);
+	const stringResult = parseJson("\"string\"");
+	expect(stringResult.status).toBe("ok");
+	if (stringResult.status === "ok") expect(stringResult.data).toBe("string");
+	const emptyArrayResult = parseJson("[]");
+	expect(emptyArrayResult.status).toBe("ok");
+	if (emptyArrayResult.status === "ok") expect(emptyArrayResult.data).toEqual([]);
+	const arrayResult = parseJson("[1,2,3]");
+	expect(arrayResult.status).toBe("ok");
+	if (arrayResult.status === "ok") expect(arrayResult.data).toEqual([
+		1,
+		2,
+		3
+	]);
+	const emptyObjectResult = parseJson("{}");
+	expect(emptyObjectResult.status).toBe("ok");
+	if (emptyObjectResult.status === "ok") expect(emptyObjectResult.data).toEqual({});
+	const objectResult = parseJson("{\"a\":1,\"b\":\"string\"}");
+	expect(objectResult.status).toBe("ok");
+	if (objectResult.status === "ok") expect(objectResult.data).toEqual({
+		a: 1,
+		b: "string"
+	});
+	expect(parseJson("").status).toBe("error");
+	expect(parseJson("undefined").status).toBe("error");
+	expect(parseJson("{").status).toBe("error");
+	expect(parseJson("{\"a\":1,}").status).toBe("error");
+	expect(parseJson("function(){}").status).toBe("error");
+});
+function stringifyJson(json) {
+	return __results_js.Result.fromThrowing(() => JSON.stringify(json));
+}
+(void 0)?.test("stringifyJson", ({ expect }) => {
+	const nullResult = stringifyJson(null);
+	expect(nullResult.status).toBe("ok");
+	if (nullResult.status === "ok") expect(nullResult.data).toBe("null");
+	const trueResult = stringifyJson(true);
+	expect(trueResult.status).toBe("ok");
+	if (trueResult.status === "ok") expect(trueResult.data).toBe("true");
+	const numberResult = stringifyJson(123);
+	expect(numberResult.status).toBe("ok");
+	if (numberResult.status === "ok") expect(numberResult.data).toBe("123");
+	const stringResult = stringifyJson("string");
+	expect(stringResult.status).toBe("ok");
+	if (stringResult.status === "ok") expect(stringResult.data).toBe("\"string\"");
+	const emptyArrayResult = stringifyJson([]);
+	expect(emptyArrayResult.status).toBe("ok");
+	if (emptyArrayResult.status === "ok") expect(emptyArrayResult.data).toBe("[]");
+	const arrayResult = stringifyJson([
+		1,
+		2,
+		3
+	]);
+	expect(arrayResult.status).toBe("ok");
+	if (arrayResult.status === "ok") expect(arrayResult.data).toBe("[1,2,3]");
+	const emptyObjectResult = stringifyJson({});
+	expect(emptyObjectResult.status).toBe("ok");
+	if (emptyObjectResult.status === "ok") expect(emptyObjectResult.data).toBe("{}");
+	const objectResult = stringifyJson({
+		a: 1,
+		b: "string"
+	});
+	expect(objectResult.status).toBe("ok");
+	if (objectResult.status === "ok") expect(objectResult.data).toBe("{\"a\":1,\"b\":\"string\"}");
+	const nestedResult = stringifyJson({
+		a: [
+			1,
+			2,
+			3
+		],
+		b: { c: "d" }
+	});
+	expect(nestedResult.status).toBe("ok");
+	if (nestedResult.status === "ok") expect(nestedResult.data).toBe("{\"a\":[1,2,3],\"b\":{\"c\":\"d\"}}");
+	const circular = { a: 1 };
+	circular.self = circular;
+	expect(stringifyJson(circular).status).toBe("error");
+});
+
+//#endregion
+exports.isJsonSerializable = isJsonSerializable;
+exports.parseJson = parseJson;
+exports.stringifyJson = stringifyJson;
+//# sourceMappingURL=json.js.map

package/dist/utils/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","names":[],"sources":["../../src/utils/json.tsx"],"sourcesContent":["import { Result } from \"./results\";\n\nexport type Json =\n  | null\n  | boolean\n  | number\n  | string\n  | Json[]\n  | { [key: string]: Json };\n\nexport type ReadonlyJson =\n  | null\n  | boolean\n  | number\n  | string\n  | readonly ReadonlyJson[]\n  | { readonly [key: string]: ReadonlyJson };\n\nexport function isJsonSerializable(value: unknown): value is Json {\n  switch (typeof value) {\n    case \"object\": {\n      if (value === null) return true;\n      if (Array.isArray(value)) return value.every(isJsonSerializable);\n      return Object.keys(value).every(k => typeof k === \"string\") && Object.values(value).every(isJsonSerializable);\n    }\n    case \"string\":\n    case \"number\":\n    case \"boolean\": {\n      return true;\n    }\n    default: {\n      return false;\n    }\n  }\n}\nimport.meta.vitest?.test(\"isJsonSerializable\", ({ expect }) => {\n  // Test primitive values\n  expect(isJsonSerializable(null)).toBe(true);\n  expect(isJsonSerializable(true)).toBe(true);\n  expect(isJsonSerializable(false)).toBe(true);\n  expect(isJsonSerializable(123)).toBe(true);\n  expect(isJsonSerializable(\"string\")).toBe(true);\n\n  // Test arrays\n  expect(isJsonSerializable([])).toBe(true);\n  expect(isJsonSerializable([1, 2, 3])).toBe(true);\n  expect(isJsonSerializable([\"a\", \"b\", \"c\"])).toBe(true);\n  expect(isJsonSerializable([1, \"a\", true, null])).toBe(true);\n  expect(isJsonSerializable([1, [2, 3], { a: \"b\" }])).toBe(true);\n\n  // Test objects\n  expect(isJsonSerializable({})).toBe(true);\n  expect(isJsonSerializable({ a: 1, b: 2 })).toBe(true);\n  expect(isJsonSerializable({ a: \"string\", b: true, c: null })).toBe(true);\n  expect(isJsonSerializable({ a: [1, 2, 3], b: { c: \"d\" } })).toBe(true);\n\n  // Test invalid JSON values\n  expect(isJsonSerializable(undefined)).toBe(false);\n  expect(isJsonSerializable(() => {})).toBe(false);\n  expect(isJsonSerializable(Symbol())).toBe(false);\n  expect(isJsonSerializable(BigInt(123))).toBe(false);\n\n  // Test arrays with invalid JSON values\n  expect(isJsonSerializable([1, undefined, 3])).toBe(false);\n  expect(isJsonSerializable([1, () => {}, 3])).toBe(false);\n\n  // Test objects with invalid JSON values\n  expect(isJsonSerializable({ a: 1, b: undefined })).toBe(false);\n  expect(isJsonSerializable({ a: 1, b: () => {} })).toBe(false);\n});\n\nexport function parseJson(json: string): Result<Json> {\n  return Result.fromThrowing(() => JSON.parse(json));\n}\nimport.meta.vitest?.test(\"parseJson\", ({ expect }) => {\n  // Test valid JSON strings\n  const nullResult = parseJson(\"null\");\n  expect(nullResult.status).toBe(\"ok\");\n  if (nullResult.status === \"ok\") {\n    expect(nullResult.data).toBe(null);\n  }\n\n  const trueResult = parseJson(\"true\");\n  expect(trueResult.status).toBe(\"ok\");\n  if (trueResult.status === \"ok\") {\n    expect(trueResult.data).toBe(true);\n  }\n\n  const numberResult = parseJson(\"123\");\n  expect(numberResult.status).toBe(\"ok\");\n  if (numberResult.status === \"ok\") {\n    expect(numberResult.data).toBe(123);\n  }\n\n  const stringResult = parseJson('\"string\"');\n  expect(stringResult.status).toBe(\"ok\");\n  if (stringResult.status === \"ok\") {\n    expect(stringResult.data).toBe(\"string\");\n  }\n\n  const emptyArrayResult = parseJson(\"[]\");\n  expect(emptyArrayResult.status).toBe(\"ok\");\n  if (emptyArrayResult.status === \"ok\") {\n    expect(emptyArrayResult.data).toEqual([]);\n  }\n\n  const arrayResult = parseJson(\"[1,2,3]\");\n  expect(arrayResult.status).toBe(\"ok\");\n  if (arrayResult.status === \"ok\") {\n    expect(arrayResult.data).toEqual([1, 2, 3]);\n  }\n\n  const emptyObjectResult = parseJson(\"{}\");\n  expect(emptyObjectResult.status).toBe(\"ok\");\n  if (emptyObjectResult.status === \"ok\") {\n    expect(emptyObjectResult.data).toEqual({});\n  }\n\n  const objectResult = parseJson('{\"a\":1,\"b\":\"string\"}');\n  expect(objectResult.status).toBe(\"ok\");\n  if (objectResult.status === \"ok\") {\n    expect(objectResult.data).toEqual({ a: 1, b: \"string\" });\n  }\n\n  // Test invalid JSON strings\n  expect(parseJson(\"\").status).toBe(\"error\");\n  expect(parseJson(\"undefined\").status).toBe(\"error\");\n  expect(parseJson(\"{\").status).toBe(\"error\");\n  expect(parseJson('{\"a\":1,}').status).toBe(\"error\");\n  expect(parseJson(\"function(){}\").status).toBe(\"error\");\n});\n\nexport function stringifyJson(json: Json): Result<string> {\n  return Result.fromThrowing(() => JSON.stringify(json));\n}\nimport.meta.vitest?.test(\"stringifyJson\", ({ expect }) => {\n  // Test primitive values\n  const nullResult = stringifyJson(null);\n  expect(nullResult.status).toBe(\"ok\");\n  if (nullResult.status === \"ok\") {\n    expect(nullResult.data).toBe(\"null\");\n  }\n\n  const trueResult = stringifyJson(true);\n  expect(trueResult.status).toBe(\"ok\");\n  if (trueResult.status === \"ok\") {\n    expect(trueResult.data).toBe(\"true\");\n  }\n\n  const numberResult = stringifyJson(123);\n  expect(numberResult.status).toBe(\"ok\");\n  if (numberResult.status === \"ok\") {\n    expect(numberResult.data).toBe(\"123\");\n  }\n\n  const stringResult = stringifyJson(\"string\");\n  expect(stringResult.status).toBe(\"ok\");\n  if (stringResult.status === \"ok\") {\n    expect(stringResult.data).toBe('\"string\"');\n  }\n\n  // Test arrays\n  const emptyArrayResult = stringifyJson([]);\n  expect(emptyArrayResult.status).toBe(\"ok\");\n  if (emptyArrayResult.status === \"ok\") {\n    expect(emptyArrayResult.data).toBe(\"[]\");\n  }\n\n  const arrayResult = stringifyJson([1, 2, 3]);\n  expect(arrayResult.status).toBe(\"ok\");\n  if (arrayResult.status === \"ok\") {\n    expect(arrayResult.data).toBe(\"[1,2,3]\");\n  }\n\n  // Test objects\n  const emptyObjectResult = stringifyJson({});\n  expect(emptyObjectResult.status).toBe(\"ok\");\n  if (emptyObjectResult.status === \"ok\") {\n    expect(emptyObjectResult.data).toBe(\"{}\");\n  }\n\n  const objectResult = stringifyJson({ a: 1, b: \"string\" });\n  expect(objectResult.status).toBe(\"ok\");\n  if (objectResult.status === \"ok\") {\n    expect(objectResult.data).toBe('{\"a\":1,\"b\":\"string\"}');\n  }\n\n  // Test nested structures\n  const nested = { a: [1, 2, 3], b: { c: \"d\" } };\n  const nestedResult = stringifyJson(nested);\n  expect(nestedResult.status).toBe(\"ok\");\n  if (nestedResult.status === \"ok\") {\n    expect(nestedResult.data).toBe('{\"a\":[1,2,3],\"b\":{\"c\":\"d\"}}');\n  }\n\n  // Test circular references (should error)\n  const circular: any = { a: 1 };\n  circular.self = circular;\n  expect(stringifyJson(circular).status).toBe(\"error\");\n});\n"],"mappings":"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"}

package/dist/utils/jsx-editable-transpiler.d.ts

@@ -0,0 +1,68 @@
+//#region src/utils/jsx-editable-transpiler.d.ts
+/**
+ * Metadata for an editable text region in JSX source code.
+ * This information is used by the AI to accurately locate and update text.
+ */
+type EditableMetadata = {
+  /** Unique identifier for this editable region */id: string; /** Exact source code location */
+  loc: {
+    start: number;
+    end: number;
+    line: number;
+    column: number;
+  }; /** The original text content */
+  originalText: string; /** Hash of original text for quick mismatch detection */
+  textHash: string; /** JSX ancestry path from component root to this text node */
+  jsxPath: string[]; /** The immediate parent JSX element */
+  parentElement: {
+    tagName: string;
+    props: Record<string, string>;
+  }; /** Surrounding source context for disambiguation */
+  sourceContext: {
+    before: string;
+    after: string;
+  }; /** Index among sibling text nodes in the same parent */
+  siblingIndex: number; /** Total count of this exact text in the source */
+  occurrenceCount: number; /** Which occurrence this is (1-indexed) */
+  occurrenceIndex: number; /** Which file this text is in */
+  sourceFile: "template" | "theme";
+};
+/**
+ * Result of transpiling JSX source to include editable markers.
+ */
+type TranspileResult = {
+  /** The transformed source code with __Editable wrappers */code: string; /** Map of editable region IDs to their metadata */
+  editableRegions: Record<string, EditableMetadata>;
+};
+/**
+ * Transpiles TSX source code to wrap all static JSX text nodes with __Editable components.
+ *
+ * For example:
+ * ```tsx
+ * <Text>Hi, {name}! Welcome.</Text>
+ * ```
+ * becomes:
+ * ```tsx
+ * <Text>
+ *   <__Editable __id="e1">Hi, </__Editable>
+ *   {name}
+ *   <__Editable __id="e2">! Welcome.</__Editable>
+ * </Text>
+ * ```
+ */
+declare function transpileJsxForEditing(source: string, options: {
+  sourceFile: "template" | "theme";
+}): TranspileResult;
+/**
+ * Post-processes rendered HTML to convert sentinel tokens to HTML comments.
+ *
+ * Converts:
+ * - `⟦STACK_EDITABLE_START:<id>⟧` → `<!-- STACK_EDITABLE_START <id> -->`
+ * - `⟦STACK_EDITABLE_END:<id>⟧` → `<!-- STACK_EDITABLE_END <id> -->`
+ * - `⟦STACK_EXPR_START:<base64-encoded-expr>⟧` → `<!-- STACK_EXPR_START <base64> -->`
+ * - `⟦STACK_EXPR_END⟧` → `<!-- STACK_EXPR_END -->`
+ */
+declare function convertSentinelTokensToComments(html: string): string;
+//#endregion
+export { EditableMetadata, TranspileResult, convertSentinelTokensToComments, transpileJsxForEditing };
+//# sourceMappingURL=jsx-editable-transpiler.d.ts.map

package/dist/utils/jsx-editable-transpiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-editable-transpiler.d.ts","names":[],"sources":["../../src/utils/jsx-editable-transpiler.tsx"],"mappings":";;AAUA;;;KAAY,gBAAA;EAEV,iDAAA,EAAA,UAIE;EADF,GAAA;IACE,KAAA;IACA,GAAA;IACA,IAAA;IACA,MAAA;EAAA,GAaF;EATA,YAAA,UAWE;EARF,QAAA,UAYA;EATA,OAAA,YAWE;EARF,aAAA;IACE,OAAA;IACA,KAAA,EAAO,MAAA;EAAA,GAmBC;EAfV,aAAA;IACE,MAAA;IACA,KAAA;EAAA,GAuBqB;EAnBvB,YAAA,UAmBA;EAhBA,eAAA,UAgBgC;EAbhC,eAAA,UAagD;EAVhD,UAAA;AAAA;;;;KAMU,eAAA;EAsDV,2DApDA,IAAA,UAuDgB;EArDhB,eAAA,EAAiB,MAAA,SAAe,gBAAA;AAAA;;;;;;;;;;;;;;;;;iBAgDlB,sBAAA,CACd,MAAA,UACA,OAAA;EACE,UAAA;AAAA,IAED,eAAA;;;;;;;;;;iBAsRa,+BAAA,CAAgC,IAAA"}