@berkayyalcin/utilkit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Berkay Yalçın
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,60 @@
+# utilkit
+
+Zero-dependency devkit for everyday JavaScript/TypeScript utilities. Pure functions — works in React, Vue, Angular, Node, or plain browser scripts.
+
+## Install
+
+```bash
+npm install @berkayyalcin/utilkit
+```
+
+## Quick Start
+
+```ts
+import { base64Encode, base64Decode, stringLength, byteLength, safeJsonParse } from "@berkayyalcin/utilkit";
+
+base64Encode("Türkçe metin 🎉");        // Unicode-safe, unlike native btoa
+base64Decode("not-valid-base64");        // null, never throws
+
+stringLength("😀");                       // 1 (visual character)
+"😀".length;                              // 2 (native — counts UTF-16 units, not visual chars)
+byteLength("😀");                         // 4 (UTF-8 byte size)
+
+safeJsonParse("not json");                // null, never throws
+safeJsonParse("not json", { empty: true }); // { empty: true } — fallback value
+```
+
+You can also import from a specific category for smaller bundles:
+
+```ts
+import { base64Encode } from "@berkayyalcin/utilkit/encoding";
+import { stringLength } from "@berkayyalcin/utilkit/text";
+import { safeJsonParse } from "@berkayyalcin/utilkit/data";
+```
+
+## API
+
+| Function | Signature | Description |
+|---|---|---|
+| `base64Encode` | `(input: string) => string` | UTF-8-safe Base64 encode. |
+| `base64Decode` | `(input: string) => string \| null` | Base64 decode; `null` on invalid input. |
+| `stringLength` | `(input: string) => number` | Visual character (grapheme) count. |
+| `byteLength` | `(input: string) => number` | UTF-8 byte length. |
+| `safeJsonParse` | `<T>(input: string, fallback?: T) => T \| null` | `JSON.parse` that never throws. |
+
+## Design Principles
+
+- **Zero dependencies.**
+- **100% test coverage.**
+- **Tree-shakeable** — `"sideEffects": false`, ESM + CJS builds.
+- **TypeScript-first.**
+- **Null-safe on invalid input** — functions that can fail return `null` (or a caller-supplied fallback) instead of throwing.
+- **MIT licensed.**
+
+## Türkçe
+
+`utilkit`, günlük JavaScript/TypeScript ihtiyaçları için sıfır bağımlılıklı bir devkit'tir: Unicode-güvenli Base64 kodlama, doğru string uzunluğu (karakter + byte) ve güvenli JSON ayrıştırma. Saf fonksiyonlardan oluşur — React, Vue, Angular veya Node fark etmeksizin her yerde çalışır. Kurulum ve API referansı için yukarıdaki İngilizce bölüme bakınız (fonksiyon imzaları evrenseldir).
+
+## License
+
+MIT © [Berkay Yalçın](https://berkayyalcin.dev)

package/dist/data/index.cjs

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/data/index.ts
+var data_exports = {};
+__export(data_exports, {
+  safeJsonParse: () => safeJsonParse
+});
+module.exports = __toCommonJS(data_exports);
+
+// src/data/json.ts
+function safeJsonParse(input, fallback) {
+  try {
+    return JSON.parse(input);
+  } catch {
+    return fallback ?? null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  safeJsonParse
+});
+//# sourceMappingURL=index.cjs.map

package/dist/data/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/data/index.ts","../../src/data/json.ts"],"sourcesContent":["export { safeJsonParse } from \"./json.js\";\n","/**\n * `JSON.parse` wrapped in try/catch. Returns `fallback` (or `null` if no\n * fallback is given) on invalid input instead of throwing, so callers never\n * need their own try/catch for the common \"might not be JSON\" case.\n */\nexport function safeJsonParse<T = unknown>(input: string, fallback?: T): T | null {\n  try {\n    return JSON.parse(input) as T;\n  } catch {\n    return fallback ?? null;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACKO,SAAS,cAA2B,OAAe,UAAwB;AAChF,MAAI;AACF,WAAO,KAAK,MAAM,KAAK;AAAA,EACzB,QAAQ;AACN,WAAO,YAAY;AAAA,EACrB;AACF;","names":[]}

package/dist/data/index.d.cts

@@ -0,0 +1,8 @@
+/**
+ * `JSON.parse` wrapped in try/catch. Returns `fallback` (or `null` if no
+ * fallback is given) on invalid input instead of throwing, so callers never
+ * need their own try/catch for the common "might not be JSON" case.
+ */
+declare function safeJsonParse<T = unknown>(input: string, fallback?: T): T | null;
+
+export { safeJsonParse };

package/dist/data/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `JSON.parse` wrapped in try/catch. Returns `fallback` (or `null` if no
+ * fallback is given) on invalid input instead of throwing, so callers never
+ * need their own try/catch for the common "might not be JSON" case.
+ */
+declare function safeJsonParse<T = unknown>(input: string, fallback?: T): T | null;
+
+export { safeJsonParse };

package/dist/data/index.mjs

@@ -0,0 +1,12 @@
+// src/data/json.ts
+function safeJsonParse(input, fallback) {
+  try {
+    return JSON.parse(input);
+  } catch {
+    return fallback ?? null;
+  }
+}
+export {
+  safeJsonParse
+};
+//# sourceMappingURL=index.mjs.map

package/dist/data/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/data/json.ts"],"sourcesContent":["/**\n * `JSON.parse` wrapped in try/catch. Returns `fallback` (or `null` if no\n * fallback is given) on invalid input instead of throwing, so callers never\n * need their own try/catch for the common \"might not be JSON\" case.\n */\nexport function safeJsonParse<T = unknown>(input: string, fallback?: T): T | null {\n  try {\n    return JSON.parse(input) as T;\n  } catch {\n    return fallback ?? null;\n  }\n}\n"],"mappings":";AAKO,SAAS,cAA2B,OAAe,UAAwB;AAChF,MAAI;AACF,WAAO,KAAK,MAAM,KAAK;AAAA,EACzB,QAAQ;AACN,WAAO,YAAY;AAAA,EACrB;AACF;","names":[]}

package/dist/encoding/index.cjs

@@ -0,0 +1,95 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/encoding/index.ts
+var encoding_exports = {};
+__export(encoding_exports, {
+  base64Decode: () => base64Decode,
+  base64Encode: () => base64Encode
+});
+module.exports = __toCommonJS(encoding_exports);
+
+// src/encoding/base64.ts
+var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function bytesToBase64(bytes) {
+  let result = "";
+  let i = 0;
+  for (; i + 2 < bytes.length; i += 3) {
+    const chunk = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+    result += BASE64_ALPHABET[chunk >> 18 & 63];
+    result += BASE64_ALPHABET[chunk >> 12 & 63];
+    result += BASE64_ALPHABET[chunk >> 6 & 63];
+    result += BASE64_ALPHABET[chunk & 63];
+  }
+  const remaining = bytes.length - i;
+  if (remaining === 1) {
+    const chunk = bytes[i] << 16;
+    result += BASE64_ALPHABET[chunk >> 18 & 63];
+    result += BASE64_ALPHABET[chunk >> 12 & 63];
+    result += "==";
+  } else if (remaining === 2) {
+    const chunk = bytes[i] << 16 | bytes[i + 1] << 8;
+    result += BASE64_ALPHABET[chunk >> 18 & 63];
+    result += BASE64_ALPHABET[chunk >> 12 & 63];
+    result += BASE64_ALPHABET[chunk >> 6 & 63];
+    result += "=";
+  }
+  return result;
+}
+function base64Encode(input) {
+  const bytes = new TextEncoder().encode(input);
+  return bytesToBase64(bytes);
+}
+var BASE64_LOOKUP = Object.fromEntries(
+  [...BASE64_ALPHABET].map((char, index) => [char, index])
+);
+function base64ToBytes(input) {
+  if (input.length === 0) return new Uint8Array(0);
+  if (input.length % 4 !== 0) return null;
+  const clean = input.replace(/=+$/, "");
+  const bytes = [];
+  let buffer = 0;
+  let bits = 0;
+  for (const char of clean) {
+    const value = BASE64_LOOKUP[char];
+    if (value === void 0) return null;
+    buffer = buffer << 6 | value;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      bytes.push(buffer >> bits & 255);
+    }
+  }
+  return new Uint8Array(bytes);
+}
+function base64Decode(input) {
+  const bytes = base64ToBytes(input);
+  if (bytes === null) return null;
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  base64Decode,
+  base64Encode
+});
+//# sourceMappingURL=index.cjs.map

package/dist/encoding/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/encoding/index.ts","../../src/encoding/base64.ts"],"sourcesContent":["export { base64Encode, base64Decode } from \"./base64.js\";\n","const BASE64_ALPHABET = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n\nfunction bytesToBase64(bytes: Uint8Array): string {\n  let result = \"\";\n  let i = 0;\n\n  for (; i + 2 < bytes.length; i += 3) {\n    const chunk = (bytes[i]! << 16) | (bytes[i + 1]! << 8) | bytes[i + 2]!;\n    result += BASE64_ALPHABET[(chunk >> 18) & 63];\n    result += BASE64_ALPHABET[(chunk >> 12) & 63];\n    result += BASE64_ALPHABET[(chunk >> 6) & 63];\n    result += BASE64_ALPHABET[chunk & 63];\n  }\n\n  const remaining = bytes.length - i;\n  if (remaining === 1) {\n    const chunk = bytes[i]! << 16;\n    result += BASE64_ALPHABET[(chunk >> 18) & 63];\n    result += BASE64_ALPHABET[(chunk >> 12) & 63];\n    result += \"==\";\n  } else if (remaining === 2) {\n    const chunk = (bytes[i]! << 16) | (bytes[i + 1]! << 8);\n    result += BASE64_ALPHABET[(chunk >> 18) & 63];\n    result += BASE64_ALPHABET[(chunk >> 12) & 63];\n    result += BASE64_ALPHABET[(chunk >> 6) & 63];\n    result += \"=\";\n  }\n\n  return result;\n}\n\n/**\n * UTF-8-safe Base64 encode. Unlike native `btoa`, this does not corrupt or\n * throw on non-Latin1 input (e.g. Turkish or emoji characters) and does not\n * depend on Node-only `Buffer`, so behavior is identical across runtimes.\n */\nexport function base64Encode(input: string): string {\n  const bytes = new TextEncoder().encode(input);\n  return bytesToBase64(bytes);\n}\n\nconst BASE64_LOOKUP: Record<string, number> = Object.fromEntries(\n  [...BASE64_ALPHABET].map((char, index) => [char, index])\n);\n\nfunction base64ToBytes(input: string): Uint8Array | null {\n  if (input.length === 0) return new Uint8Array(0);\n  if (input.length % 4 !== 0) return null;\n\n  const clean = input.replace(/=+$/, \"\");\n\n  const bytes: number[] = [];\n  let buffer = 0;\n  let bits = 0;\n\n  for (const char of clean) {\n    const value = BASE64_LOOKUP[char];\n    if (value === undefined) return null;\n    buffer = (buffer << 6) | value;\n    bits += 6;\n    if (bits >= 8) {\n      bits -= 8;\n      bytes.push((buffer >> bits) & 0xff);\n    }\n  }\n\n  return new Uint8Array(bytes);\n}\n\n/**\n * Base64 decode. Does not throw on invalid Base64 input or on a decoded byte\n * sequence that isn't valid UTF-8 — returns `null` in both cases instead,\n * so callers never need to wrap this in try/catch.\n */\nexport function base64Decode(input: string): string | null {\n  const bytes = base64ToBytes(input);\n  if (bytes === null) return null;\n\n  try {\n    return new TextDecoder(\"utf-8\", { fatal: true }).decode(bytes);\n  } catch {\n    return null;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,IAAM,kBAAkB;AAExB,SAAS,cAAc,OAA2B;AAChD,MAAI,SAAS;AACb,MAAI,IAAI;AAER,SAAO,IAAI,IAAI,MAAM,QAAQ,KAAK,GAAG;AACnC,UAAM,QAAS,MAAM,CAAC,KAAM,KAAO,MAAM,IAAI,CAAC,KAAM,IAAK,MAAM,IAAI,CAAC;AACpE,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,IAAK,EAAE;AAC3C,cAAU,gBAAgB,QAAQ,EAAE;AAAA,EACtC;AAEA,QAAM,YAAY,MAAM,SAAS;AACjC,MAAI,cAAc,GAAG;AACnB,UAAM,QAAQ,MAAM,CAAC,KAAM;AAC3B,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU;AAAA,EACZ,WAAW,cAAc,GAAG;AAC1B,UAAM,QAAS,MAAM,CAAC,KAAM,KAAO,MAAM,IAAI,CAAC,KAAM;AACpD,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,IAAK,EAAE;AAC3C,cAAU;AAAA,EACZ;AAEA,SAAO;AACT;AAOO,SAAS,aAAa,OAAuB;AAClD,QAAM,QAAQ,IAAI,YAAY,EAAE,OAAO,KAAK;AAC5C,SAAO,cAAc,KAAK;AAC5B;AAEA,IAAM,gBAAwC,OAAO;AAAA,EACnD,CAAC,GAAG,eAAe,EAAE,IAAI,CAAC,MAAM,UAAU,CAAC,MAAM,KAAK,CAAC;AACzD;AAEA,SAAS,cAAc,OAAkC;AACvD,MAAI,MAAM,WAAW,EAAG,QAAO,IAAI,WAAW,CAAC;AAC/C,MAAI,MAAM,SAAS,MAAM,EAAG,QAAO;AAEnC,QAAM,QAAQ,MAAM,QAAQ,OAAO,EAAE;AAErC,QAAM,QAAkB,CAAC;AACzB,MAAI,SAAS;AACb,MAAI,OAAO;AAEX,aAAW,QAAQ,OAAO;AACxB,UAAM,QAAQ,cAAc,IAAI;AAChC,QAAI,UAAU,OAAW,QAAO;AAChC,aAAU,UAAU,IAAK;AACzB,YAAQ;AACR,QAAI,QAAQ,GAAG;AACb,cAAQ;AACR,YAAM,KAAM,UAAU,OAAQ,GAAI;AAAA,IACpC;AAAA,EACF;AAEA,SAAO,IAAI,WAAW,KAAK;AAC7B;AAOO,SAAS,aAAa,OAA8B;AACzD,QAAM,QAAQ,cAAc,KAAK;AACjC,MAAI,UAAU,KAAM,QAAO;AAE3B,MAAI;AACF,WAAO,IAAI,YAAY,SAAS,EAAE,OAAO,KAAK,CAAC,EAAE,OAAO,KAAK;AAAA,EAC/D,QAAQ;AACN,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/encoding/index.d.cts

@@ -0,0 +1,14 @@
+/**
+ * UTF-8-safe Base64 encode. Unlike native `btoa`, this does not corrupt or
+ * throw on non-Latin1 input (e.g. Turkish or emoji characters) and does not
+ * depend on Node-only `Buffer`, so behavior is identical across runtimes.
+ */
+declare function base64Encode(input: string): string;
+/**
+ * Base64 decode. Does not throw on invalid Base64 input or on a decoded byte
+ * sequence that isn't valid UTF-8 — returns `null` in both cases instead,
+ * so callers never need to wrap this in try/catch.
+ */
+declare function base64Decode(input: string): string | null;
+
+export { base64Decode, base64Encode };

package/dist/encoding/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * UTF-8-safe Base64 encode. Unlike native `btoa`, this does not corrupt or
+ * throw on non-Latin1 input (e.g. Turkish or emoji characters) and does not
+ * depend on Node-only `Buffer`, so behavior is identical across runtimes.
+ */
+declare function base64Encode(input: string): string;
+/**
+ * Base64 decode. Does not throw on invalid Base64 input or on a decoded byte
+ * sequence that isn't valid UTF-8 — returns `null` in both cases instead,
+ * so callers never need to wrap this in try/catch.
+ */
+declare function base64Decode(input: string): string | null;
+
+export { base64Decode, base64Encode };

package/dist/encoding/index.mjs

@@ -0,0 +1,67 @@
+// src/encoding/base64.ts
+var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function bytesToBase64(bytes) {
+  let result = "";
+  let i = 0;
+  for (; i + 2 < bytes.length; i += 3) {
+    const chunk = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+    result += BASE64_ALPHABET[chunk >> 18 & 63];
+    result += BASE64_ALPHABET[chunk >> 12 & 63];
+    result += BASE64_ALPHABET[chunk >> 6 & 63];
+    result += BASE64_ALPHABET[chunk & 63];
+  }
+  const remaining = bytes.length - i;
+  if (remaining === 1) {
+    const chunk = bytes[i] << 16;
+    result += BASE64_ALPHABET[chunk >> 18 & 63];
+    result += BASE64_ALPHABET[chunk >> 12 & 63];
+    result += "==";
+  } else if (remaining === 2) {
+    const chunk = bytes[i] << 16 | bytes[i + 1] << 8;
+    result += BASE64_ALPHABET[chunk >> 18 & 63];
+    result += BASE64_ALPHABET[chunk >> 12 & 63];
+    result += BASE64_ALPHABET[chunk >> 6 & 63];
+    result += "=";
+  }
+  return result;
+}
+function base64Encode(input) {
+  const bytes = new TextEncoder().encode(input);
+  return bytesToBase64(bytes);
+}
+var BASE64_LOOKUP = Object.fromEntries(
+  [...BASE64_ALPHABET].map((char, index) => [char, index])
+);
+function base64ToBytes(input) {
+  if (input.length === 0) return new Uint8Array(0);
+  if (input.length % 4 !== 0) return null;
+  const clean = input.replace(/=+$/, "");
+  const bytes = [];
+  let buffer = 0;
+  let bits = 0;
+  for (const char of clean) {
+    const value = BASE64_LOOKUP[char];
+    if (value === void 0) return null;
+    buffer = buffer << 6 | value;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      bytes.push(buffer >> bits & 255);
+    }
+  }
+  return new Uint8Array(bytes);
+}
+function base64Decode(input) {
+  const bytes = base64ToBytes(input);
+  if (bytes === null) return null;
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return null;
+  }
+}
+export {
+  base64Decode,
+  base64Encode
+};
+//# sourceMappingURL=index.mjs.map

package/dist/encoding/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/encoding/base64.ts"],"sourcesContent":["const BASE64_ALPHABET = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n\nfunction bytesToBase64(bytes: Uint8Array): string {\n  let result = \"\";\n  let i = 0;\n\n  for (; i + 2 < bytes.length; i += 3) {\n    const chunk = (bytes[i]! << 16) | (bytes[i + 1]! << 8) | bytes[i + 2]!;\n    result += BASE64_ALPHABET[(chunk >> 18) & 63];\n    result += BASE64_ALPHABET[(chunk >> 12) & 63];\n    result += BASE64_ALPHABET[(chunk >> 6) & 63];\n    result += BASE64_ALPHABET[chunk & 63];\n  }\n\n  const remaining = bytes.length - i;\n  if (remaining === 1) {\n    const chunk = bytes[i]! << 16;\n    result += BASE64_ALPHABET[(chunk >> 18) & 63];\n    result += BASE64_ALPHABET[(chunk >> 12) & 63];\n    result += \"==\";\n  } else if (remaining === 2) {\n    const chunk = (bytes[i]! << 16) | (bytes[i + 1]! << 8);\n    result += BASE64_ALPHABET[(chunk >> 18) & 63];\n    result += BASE64_ALPHABET[(chunk >> 12) & 63];\n    result += BASE64_ALPHABET[(chunk >> 6) & 63];\n    result += \"=\";\n  }\n\n  return result;\n}\n\n/**\n * UTF-8-safe Base64 encode. Unlike native `btoa`, this does not corrupt or\n * throw on non-Latin1 input (e.g. Turkish or emoji characters) and does not\n * depend on Node-only `Buffer`, so behavior is identical across runtimes.\n */\nexport function base64Encode(input: string): string {\n  const bytes = new TextEncoder().encode(input);\n  return bytesToBase64(bytes);\n}\n\nconst BASE64_LOOKUP: Record<string, number> = Object.fromEntries(\n  [...BASE64_ALPHABET].map((char, index) => [char, index])\n);\n\nfunction base64ToBytes(input: string): Uint8Array | null {\n  if (input.length === 0) return new Uint8Array(0);\n  if (input.length % 4 !== 0) return null;\n\n  const clean = input.replace(/=+$/, \"\");\n\n  const bytes: number[] = [];\n  let buffer = 0;\n  let bits = 0;\n\n  for (const char of clean) {\n    const value = BASE64_LOOKUP[char];\n    if (value === undefined) return null;\n    buffer = (buffer << 6) | value;\n    bits += 6;\n    if (bits >= 8) {\n      bits -= 8;\n      bytes.push((buffer >> bits) & 0xff);\n    }\n  }\n\n  return new Uint8Array(bytes);\n}\n\n/**\n * Base64 decode. Does not throw on invalid Base64 input or on a decoded byte\n * sequence that isn't valid UTF-8 — returns `null` in both cases instead,\n * so callers never need to wrap this in try/catch.\n */\nexport function base64Decode(input: string): string | null {\n  const bytes = base64ToBytes(input);\n  if (bytes === null) return null;\n\n  try {\n    return new TextDecoder(\"utf-8\", { fatal: true }).decode(bytes);\n  } catch {\n    return null;\n  }\n}\n"],"mappings":";AAAA,IAAM,kBAAkB;AAExB,SAAS,cAAc,OAA2B;AAChD,MAAI,SAAS;AACb,MAAI,IAAI;AAER,SAAO,IAAI,IAAI,MAAM,QAAQ,KAAK,GAAG;AACnC,UAAM,QAAS,MAAM,CAAC,KAAM,KAAO,MAAM,IAAI,CAAC,KAAM,IAAK,MAAM,IAAI,CAAC;AACpE,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,IAAK,EAAE;AAC3C,cAAU,gBAAgB,QAAQ,EAAE;AAAA,EACtC;AAEA,QAAM,YAAY,MAAM,SAAS;AACjC,MAAI,cAAc,GAAG;AACnB,UAAM,QAAQ,MAAM,CAAC,KAAM;AAC3B,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU;AAAA,EACZ,WAAW,cAAc,GAAG;AAC1B,UAAM,QAAS,MAAM,CAAC,KAAM,KAAO,MAAM,IAAI,CAAC,KAAM;AACpD,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,IAAK,EAAE;AAC3C,cAAU;AAAA,EACZ;AAEA,SAAO;AACT;AAOO,SAAS,aAAa,OAAuB;AAClD,QAAM,QAAQ,IAAI,YAAY,EAAE,OAAO,KAAK;AAC5C,SAAO,cAAc,KAAK;AAC5B;AAEA,IAAM,gBAAwC,OAAO;AAAA,EACnD,CAAC,GAAG,eAAe,EAAE,IAAI,CAAC,MAAM,UAAU,CAAC,MAAM,KAAK,CAAC;AACzD;AAEA,SAAS,cAAc,OAAkC;AACvD,MAAI,MAAM,WAAW,EAAG,QAAO,IAAI,WAAW,CAAC;AAC/C,MAAI,MAAM,SAAS,MAAM,EAAG,QAAO;AAEnC,QAAM,QAAQ,MAAM,QAAQ,OAAO,EAAE;AAErC,QAAM,QAAkB,CAAC;AACzB,MAAI,SAAS;AACb,MAAI,OAAO;AAEX,aAAW,QAAQ,OAAO;AACxB,UAAM,QAAQ,cAAc,IAAI;AAChC,QAAI,UAAU,OAAW,QAAO;AAChC,aAAU,UAAU,IAAK;AACzB,YAAQ;AACR,QAAI,QAAQ,GAAG;AACb,cAAQ;AACR,YAAM,KAAM,UAAU,OAAQ,GAAI;AAAA,IACpC;AAAA,EACF;AAEA,SAAO,IAAI,WAAW,KAAK;AAC7B;AAOO,SAAS,aAAa,OAA8B;AACzD,QAAM,QAAQ,cAAc,KAAK;AACjC,MAAI,UAAU,KAAM,QAAO;AAE3B,MAAI;AACF,WAAO,IAAI,YAAY,SAAS,EAAE,OAAO,KAAK,CAAC,EAAE,OAAO,KAAK;AAAA,EAC/D,QAAQ;AACN,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/index.cjs

@@ -0,0 +1,122 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  base64Decode: () => base64Decode,
+  base64Encode: () => base64Encode,
+  byteLength: () => byteLength,
+  safeJsonParse: () => safeJsonParse,
+  stringLength: () => stringLength
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/encoding/base64.ts
+var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function bytesToBase64(bytes) {
+  let result = "";
+  let i = 0;
+  for (; i + 2 < bytes.length; i += 3) {
+    const chunk = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+    result += BASE64_ALPHABET[chunk >> 18 & 63];
+    result += BASE64_ALPHABET[chunk >> 12 & 63];
+    result += BASE64_ALPHABET[chunk >> 6 & 63];
+    result += BASE64_ALPHABET[chunk & 63];
+  }
+  const remaining = bytes.length - i;
+  if (remaining === 1) {
+    const chunk = bytes[i] << 16;
+    result += BASE64_ALPHABET[chunk >> 18 & 63];
+    result += BASE64_ALPHABET[chunk >> 12 & 63];
+    result += "==";
+  } else if (remaining === 2) {
+    const chunk = bytes[i] << 16 | bytes[i + 1] << 8;
+    result += BASE64_ALPHABET[chunk >> 18 & 63];
+    result += BASE64_ALPHABET[chunk >> 12 & 63];
+    result += BASE64_ALPHABET[chunk >> 6 & 63];
+    result += "=";
+  }
+  return result;
+}
+function base64Encode(input) {
+  const bytes = new TextEncoder().encode(input);
+  return bytesToBase64(bytes);
+}
+var BASE64_LOOKUP = Object.fromEntries(
+  [...BASE64_ALPHABET].map((char, index) => [char, index])
+);
+function base64ToBytes(input) {
+  if (input.length === 0) return new Uint8Array(0);
+  if (input.length % 4 !== 0) return null;
+  const clean = input.replace(/=+$/, "");
+  const bytes = [];
+  let buffer = 0;
+  let bits = 0;
+  for (const char of clean) {
+    const value = BASE64_LOOKUP[char];
+    if (value === void 0) return null;
+    buffer = buffer << 6 | value;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      bytes.push(buffer >> bits & 255);
+    }
+  }
+  return new Uint8Array(bytes);
+}
+function base64Decode(input) {
+  const bytes = base64ToBytes(input);
+  if (bytes === null) return null;
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return null;
+  }
+}
+
+// src/text/length.ts
+function stringLength(input) {
+  if (typeof Intl !== "undefined" && "Segmenter" in Intl) {
+    const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+    return [...segmenter.segment(input)].length;
+  }
+  return [...input].length;
+}
+function byteLength(input) {
+  return new TextEncoder().encode(input).length;
+}
+
+// src/data/json.ts
+function safeJsonParse(input, fallback) {
+  try {
+    return JSON.parse(input);
+  } catch {
+    return fallback ?? null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  base64Decode,
+  base64Encode,
+  byteLength,
+  safeJsonParse,
+  stringLength
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/encoding/base64.ts","../src/text/length.ts","../src/data/json.ts"],"sourcesContent":["export * from \"./encoding/index.js\";\nexport * from \"./text/index.js\";\nexport * from \"./data/index.js\";\n","const BASE64_ALPHABET = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n\nfunction bytesToBase64(bytes: Uint8Array): string {\n  let result = \"\";\n  let i = 0;\n\n  for (; i + 2 < bytes.length; i += 3) {\n    const chunk = (bytes[i]! << 16) | (bytes[i + 1]! << 8) | bytes[i + 2]!;\n    result += BASE64_ALPHABET[(chunk >> 18) & 63];\n    result += BASE64_ALPHABET[(chunk >> 12) & 63];\n    result += BASE64_ALPHABET[(chunk >> 6) & 63];\n    result += BASE64_ALPHABET[chunk & 63];\n  }\n\n  const remaining = bytes.length - i;\n  if (remaining === 1) {\n    const chunk = bytes[i]! << 16;\n    result += BASE64_ALPHABET[(chunk >> 18) & 63];\n    result += BASE64_ALPHABET[(chunk >> 12) & 63];\n    result += \"==\";\n  } else if (remaining === 2) {\n    const chunk = (bytes[i]! << 16) | (bytes[i + 1]! << 8);\n    result += BASE64_ALPHABET[(chunk >> 18) & 63];\n    result += BASE64_ALPHABET[(chunk >> 12) & 63];\n    result += BASE64_ALPHABET[(chunk >> 6) & 63];\n    result += \"=\";\n  }\n\n  return result;\n}\n\n/**\n * UTF-8-safe Base64 encode. Unlike native `btoa`, this does not corrupt or\n * throw on non-Latin1 input (e.g. Turkish or emoji characters) and does not\n * depend on Node-only `Buffer`, so behavior is identical across runtimes.\n */\nexport function base64Encode(input: string): string {\n  const bytes = new TextEncoder().encode(input);\n  return bytesToBase64(bytes);\n}\n\nconst BASE64_LOOKUP: Record<string, number> = Object.fromEntries(\n  [...BASE64_ALPHABET].map((char, index) => [char, index])\n);\n\nfunction base64ToBytes(input: string): Uint8Array | null {\n  if (input.length === 0) return new Uint8Array(0);\n  if (input.length % 4 !== 0) return null;\n\n  const clean = input.replace(/=+$/, \"\");\n\n  const bytes: number[] = [];\n  let buffer = 0;\n  let bits = 0;\n\n  for (const char of clean) {\n    const value = BASE64_LOOKUP[char];\n    if (value === undefined) return null;\n    buffer = (buffer << 6) | value;\n    bits += 6;\n    if (bits >= 8) {\n      bits -= 8;\n      bytes.push((buffer >> bits) & 0xff);\n    }\n  }\n\n  return new Uint8Array(bytes);\n}\n\n/**\n * Base64 decode. Does not throw on invalid Base64 input or on a decoded byte\n * sequence that isn't valid UTF-8 — returns `null` in both cases instead,\n * so callers never need to wrap this in try/catch.\n */\nexport function base64Decode(input: string): string | null {\n  const bytes = base64ToBytes(input);\n  if (bytes === null) return null;\n\n  try {\n    return new TextDecoder(\"utf-8\", { fatal: true }).decode(bytes);\n  } catch {\n    return null;\n  }\n}\n","/**\n * Visual-character-accurate length. Native `.length` counts UTF-16 code\n * units, which over-counts emoji and other supplementary-plane characters\n * (e.g. `\"😀\".length === 2`). Uses `Intl.Segmenter` (grapheme granularity)\n * when available, falling back to Unicode code-point counting otherwise —\n * still more accurate than native `.length` on older runtimes.\n */\nexport function stringLength(input: string): number {\n  if (typeof Intl !== \"undefined\" && \"Segmenter\" in Intl) {\n    const segmenter = new Intl.Segmenter(undefined, { granularity: \"grapheme\" });\n    return [...segmenter.segment(input)].length;\n  }\n  return [...input].length;\n}\n\n/**\n * UTF-8 byte length — useful for storage/column-size limits, distinct from\n * `stringLength` (visual character count). A single emoji is 1 character\n * but up to 4 bytes.\n */\nexport function byteLength(input: string): number {\n  return new TextEncoder().encode(input).length;\n}\n","/**\n * `JSON.parse` wrapped in try/catch. Returns `fallback` (or `null` if no\n * fallback is given) on invalid input instead of throwing, so callers never\n * need their own try/catch for the common \"might not be JSON\" case.\n */\nexport function safeJsonParse<T = unknown>(input: string, fallback?: T): T | null {\n  try {\n    return JSON.parse(input) as T;\n  } catch {\n    return fallback ?? null;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,IAAM,kBAAkB;AAExB,SAAS,cAAc,OAA2B;AAChD,MAAI,SAAS;AACb,MAAI,IAAI;AAER,SAAO,IAAI,IAAI,MAAM,QAAQ,KAAK,GAAG;AACnC,UAAM,QAAS,MAAM,CAAC,KAAM,KAAO,MAAM,IAAI,CAAC,KAAM,IAAK,MAAM,IAAI,CAAC;AACpE,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,IAAK,EAAE;AAC3C,cAAU,gBAAgB,QAAQ,EAAE;AAAA,EACtC;AAEA,QAAM,YAAY,MAAM,SAAS;AACjC,MAAI,cAAc,GAAG;AACnB,UAAM,QAAQ,MAAM,CAAC,KAAM;AAC3B,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU;AAAA,EACZ,WAAW,cAAc,GAAG;AAC1B,UAAM,QAAS,MAAM,CAAC,KAAM,KAAO,MAAM,IAAI,CAAC,KAAM;AACpD,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,IAAK,EAAE;AAC3C,cAAU;AAAA,EACZ;AAEA,SAAO;AACT;AAOO,SAAS,aAAa,OAAuB;AAClD,QAAM,QAAQ,IAAI,YAAY,EAAE,OAAO,KAAK;AAC5C,SAAO,cAAc,KAAK;AAC5B;AAEA,IAAM,gBAAwC,OAAO;AAAA,EACnD,CAAC,GAAG,eAAe,EAAE,IAAI,CAAC,MAAM,UAAU,CAAC,MAAM,KAAK,CAAC;AACzD;AAEA,SAAS,cAAc,OAAkC;AACvD,MAAI,MAAM,WAAW,EAAG,QAAO,IAAI,WAAW,CAAC;AAC/C,MAAI,MAAM,SAAS,MAAM,EAAG,QAAO;AAEnC,QAAM,QAAQ,MAAM,QAAQ,OAAO,EAAE;AAErC,QAAM,QAAkB,CAAC;AACzB,MAAI,SAAS;AACb,MAAI,OAAO;AAEX,aAAW,QAAQ,OAAO;AACxB,UAAM,QAAQ,cAAc,IAAI;AAChC,QAAI,UAAU,OAAW,QAAO;AAChC,aAAU,UAAU,IAAK;AACzB,YAAQ;AACR,QAAI,QAAQ,GAAG;AACb,cAAQ;AACR,YAAM,KAAM,UAAU,OAAQ,GAAI;AAAA,IACpC;AAAA,EACF;AAEA,SAAO,IAAI,WAAW,KAAK;AAC7B;AAOO,SAAS,aAAa,OAA8B;AACzD,QAAM,QAAQ,cAAc,KAAK;AACjC,MAAI,UAAU,KAAM,QAAO;AAE3B,MAAI;AACF,WAAO,IAAI,YAAY,SAAS,EAAE,OAAO,KAAK,CAAC,EAAE,OAAO,KAAK;AAAA,EAC/D,QAAQ;AACN,WAAO;AAAA,EACT;AACF;;;AC5EO,SAAS,aAAa,OAAuB;AAClD,MAAI,OAAO,SAAS,eAAe,eAAe,MAAM;AACtD,UAAM,YAAY,IAAI,KAAK,UAAU,QAAW,EAAE,aAAa,WAAW,CAAC;AAC3E,WAAO,CAAC,GAAG,UAAU,QAAQ,KAAK,CAAC,EAAE;AAAA,EACvC;AACA,SAAO,CAAC,GAAG,KAAK,EAAE;AACpB;AAOO,SAAS,WAAW,OAAuB;AAChD,SAAO,IAAI,YAAY,EAAE,OAAO,KAAK,EAAE;AACzC;;;ACjBO,SAAS,cAA2B,OAAe,UAAwB;AAChF,MAAI;AACF,WAAO,KAAK,MAAM,KAAK;AAAA,EACzB,QAAQ;AACN,WAAO,YAAY;AAAA,EACrB;AACF;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,3 @@
+export { base64Decode, base64Encode } from './encoding/index.cjs';
+export { byteLength, stringLength } from './text/index.cjs';
+export { safeJsonParse } from './data/index.cjs';

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { base64Decode, base64Encode } from './encoding/index.js';
+export { byteLength, stringLength } from './text/index.js';
+export { safeJsonParse } from './data/index.js';

package/dist/index.mjs

@@ -0,0 +1,91 @@
+// src/encoding/base64.ts
+var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function bytesToBase64(bytes) {
+  let result = "";
+  let i = 0;
+  for (; i + 2 < bytes.length; i += 3) {
+    const chunk = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+    result += BASE64_ALPHABET[chunk >> 18 & 63];
+    result += BASE64_ALPHABET[chunk >> 12 & 63];
+    result += BASE64_ALPHABET[chunk >> 6 & 63];
+    result += BASE64_ALPHABET[chunk & 63];
+  }
+  const remaining = bytes.length - i;
+  if (remaining === 1) {
+    const chunk = bytes[i] << 16;
+    result += BASE64_ALPHABET[chunk >> 18 & 63];
+    result += BASE64_ALPHABET[chunk >> 12 & 63];
+    result += "==";
+  } else if (remaining === 2) {
+    const chunk = bytes[i] << 16 | bytes[i + 1] << 8;
+    result += BASE64_ALPHABET[chunk >> 18 & 63];
+    result += BASE64_ALPHABET[chunk >> 12 & 63];
+    result += BASE64_ALPHABET[chunk >> 6 & 63];
+    result += "=";
+  }
+  return result;
+}
+function base64Encode(input) {
+  const bytes = new TextEncoder().encode(input);
+  return bytesToBase64(bytes);
+}
+var BASE64_LOOKUP = Object.fromEntries(
+  [...BASE64_ALPHABET].map((char, index) => [char, index])
+);
+function base64ToBytes(input) {
+  if (input.length === 0) return new Uint8Array(0);
+  if (input.length % 4 !== 0) return null;
+  const clean = input.replace(/=+$/, "");
+  const bytes = [];
+  let buffer = 0;
+  let bits = 0;
+  for (const char of clean) {
+    const value = BASE64_LOOKUP[char];
+    if (value === void 0) return null;
+    buffer = buffer << 6 | value;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      bytes.push(buffer >> bits & 255);
+    }
+  }
+  return new Uint8Array(bytes);
+}
+function base64Decode(input) {
+  const bytes = base64ToBytes(input);
+  if (bytes === null) return null;
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return null;
+  }
+}
+
+// src/text/length.ts
+function stringLength(input) {
+  if (typeof Intl !== "undefined" && "Segmenter" in Intl) {
+    const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+    return [...segmenter.segment(input)].length;
+  }
+  return [...input].length;
+}
+function byteLength(input) {
+  return new TextEncoder().encode(input).length;
+}
+
+// src/data/json.ts
+function safeJsonParse(input, fallback) {
+  try {
+    return JSON.parse(input);
+  } catch {
+    return fallback ?? null;
+  }
+}
+export {
+  base64Decode,
+  base64Encode,
+  byteLength,
+  safeJsonParse,
+  stringLength
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/encoding/base64.ts","../src/text/length.ts","../src/data/json.ts"],"sourcesContent":["const BASE64_ALPHABET = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n\nfunction bytesToBase64(bytes: Uint8Array): string {\n  let result = \"\";\n  let i = 0;\n\n  for (; i + 2 < bytes.length; i += 3) {\n    const chunk = (bytes[i]! << 16) | (bytes[i + 1]! << 8) | bytes[i + 2]!;\n    result += BASE64_ALPHABET[(chunk >> 18) & 63];\n    result += BASE64_ALPHABET[(chunk >> 12) & 63];\n    result += BASE64_ALPHABET[(chunk >> 6) & 63];\n    result += BASE64_ALPHABET[chunk & 63];\n  }\n\n  const remaining = bytes.length - i;\n  if (remaining === 1) {\n    const chunk = bytes[i]! << 16;\n    result += BASE64_ALPHABET[(chunk >> 18) & 63];\n    result += BASE64_ALPHABET[(chunk >> 12) & 63];\n    result += \"==\";\n  } else if (remaining === 2) {\n    const chunk = (bytes[i]! << 16) | (bytes[i + 1]! << 8);\n    result += BASE64_ALPHABET[(chunk >> 18) & 63];\n    result += BASE64_ALPHABET[(chunk >> 12) & 63];\n    result += BASE64_ALPHABET[(chunk >> 6) & 63];\n    result += \"=\";\n  }\n\n  return result;\n}\n\n/**\n * UTF-8-safe Base64 encode. Unlike native `btoa`, this does not corrupt or\n * throw on non-Latin1 input (e.g. Turkish or emoji characters) and does not\n * depend on Node-only `Buffer`, so behavior is identical across runtimes.\n */\nexport function base64Encode(input: string): string {\n  const bytes = new TextEncoder().encode(input);\n  return bytesToBase64(bytes);\n}\n\nconst BASE64_LOOKUP: Record<string, number> = Object.fromEntries(\n  [...BASE64_ALPHABET].map((char, index) => [char, index])\n);\n\nfunction base64ToBytes(input: string): Uint8Array | null {\n  if (input.length === 0) return new Uint8Array(0);\n  if (input.length % 4 !== 0) return null;\n\n  const clean = input.replace(/=+$/, \"\");\n\n  const bytes: number[] = [];\n  let buffer = 0;\n  let bits = 0;\n\n  for (const char of clean) {\n    const value = BASE64_LOOKUP[char];\n    if (value === undefined) return null;\n    buffer = (buffer << 6) | value;\n    bits += 6;\n    if (bits >= 8) {\n      bits -= 8;\n      bytes.push((buffer >> bits) & 0xff);\n    }\n  }\n\n  return new Uint8Array(bytes);\n}\n\n/**\n * Base64 decode. Does not throw on invalid Base64 input or on a decoded byte\n * sequence that isn't valid UTF-8 — returns `null` in both cases instead,\n * so callers never need to wrap this in try/catch.\n */\nexport function base64Decode(input: string): string | null {\n  const bytes = base64ToBytes(input);\n  if (bytes === null) return null;\n\n  try {\n    return new TextDecoder(\"utf-8\", { fatal: true }).decode(bytes);\n  } catch {\n    return null;\n  }\n}\n","/**\n * Visual-character-accurate length. Native `.length` counts UTF-16 code\n * units, which over-counts emoji and other supplementary-plane characters\n * (e.g. `\"😀\".length === 2`). Uses `Intl.Segmenter` (grapheme granularity)\n * when available, falling back to Unicode code-point counting otherwise —\n * still more accurate than native `.length` on older runtimes.\n */\nexport function stringLength(input: string): number {\n  if (typeof Intl !== \"undefined\" && \"Segmenter\" in Intl) {\n    const segmenter = new Intl.Segmenter(undefined, { granularity: \"grapheme\" });\n    return [...segmenter.segment(input)].length;\n  }\n  return [...input].length;\n}\n\n/**\n * UTF-8 byte length — useful for storage/column-size limits, distinct from\n * `stringLength` (visual character count). A single emoji is 1 character\n * but up to 4 bytes.\n */\nexport function byteLength(input: string): number {\n  return new TextEncoder().encode(input).length;\n}\n","/**\n * `JSON.parse` wrapped in try/catch. Returns `fallback` (or `null` if no\n * fallback is given) on invalid input instead of throwing, so callers never\n * need their own try/catch for the common \"might not be JSON\" case.\n */\nexport function safeJsonParse<T = unknown>(input: string, fallback?: T): T | null {\n  try {\n    return JSON.parse(input) as T;\n  } catch {\n    return fallback ?? null;\n  }\n}\n"],"mappings":";AAAA,IAAM,kBAAkB;AAExB,SAAS,cAAc,OAA2B;AAChD,MAAI,SAAS;AACb,MAAI,IAAI;AAER,SAAO,IAAI,IAAI,MAAM,QAAQ,KAAK,GAAG;AACnC,UAAM,QAAS,MAAM,CAAC,KAAM,KAAO,MAAM,IAAI,CAAC,KAAM,IAAK,MAAM,IAAI,CAAC;AACpE,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,IAAK,EAAE;AAC3C,cAAU,gBAAgB,QAAQ,EAAE;AAAA,EACtC;AAEA,QAAM,YAAY,MAAM,SAAS;AACjC,MAAI,cAAc,GAAG;AACnB,UAAM,QAAQ,MAAM,CAAC,KAAM;AAC3B,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU;AAAA,EACZ,WAAW,cAAc,GAAG;AAC1B,UAAM,QAAS,MAAM,CAAC,KAAM,KAAO,MAAM,IAAI,CAAC,KAAM;AACpD,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,KAAM,EAAE;AAC5C,cAAU,gBAAiB,SAAS,IAAK,EAAE;AAC3C,cAAU;AAAA,EACZ;AAEA,SAAO;AACT;AAOO,SAAS,aAAa,OAAuB;AAClD,QAAM,QAAQ,IAAI,YAAY,EAAE,OAAO,KAAK;AAC5C,SAAO,cAAc,KAAK;AAC5B;AAEA,IAAM,gBAAwC,OAAO;AAAA,EACnD,CAAC,GAAG,eAAe,EAAE,IAAI,CAAC,MAAM,UAAU,CAAC,MAAM,KAAK,CAAC;AACzD;AAEA,SAAS,cAAc,OAAkC;AACvD,MAAI,MAAM,WAAW,EAAG,QAAO,IAAI,WAAW,CAAC;AAC/C,MAAI,MAAM,SAAS,MAAM,EAAG,QAAO;AAEnC,QAAM,QAAQ,MAAM,QAAQ,OAAO,EAAE;AAErC,QAAM,QAAkB,CAAC;AACzB,MAAI,SAAS;AACb,MAAI,OAAO;AAEX,aAAW,QAAQ,OAAO;AACxB,UAAM,QAAQ,cAAc,IAAI;AAChC,QAAI,UAAU,OAAW,QAAO;AAChC,aAAU,UAAU,IAAK;AACzB,YAAQ;AACR,QAAI,QAAQ,GAAG;AACb,cAAQ;AACR,YAAM,KAAM,UAAU,OAAQ,GAAI;AAAA,IACpC;AAAA,EACF;AAEA,SAAO,IAAI,WAAW,KAAK;AAC7B;AAOO,SAAS,aAAa,OAA8B;AACzD,QAAM,QAAQ,cAAc,KAAK;AACjC,MAAI,UAAU,KAAM,QAAO;AAE3B,MAAI;AACF,WAAO,IAAI,YAAY,SAAS,EAAE,OAAO,KAAK,CAAC,EAAE,OAAO,KAAK;AAAA,EAC/D,QAAQ;AACN,WAAO;AAAA,EACT;AACF;;;AC5EO,SAAS,aAAa,OAAuB;AAClD,MAAI,OAAO,SAAS,eAAe,eAAe,MAAM;AACtD,UAAM,YAAY,IAAI,KAAK,UAAU,QAAW,EAAE,aAAa,WAAW,CAAC;AAC3E,WAAO,CAAC,GAAG,UAAU,QAAQ,KAAK,CAAC,EAAE;AAAA,EACvC;AACA,SAAO,CAAC,GAAG,KAAK,EAAE;AACpB;AAOO,SAAS,WAAW,OAAuB;AAChD,SAAO,IAAI,YAAY,EAAE,OAAO,KAAK,EAAE;AACzC;;;ACjBO,SAAS,cAA2B,OAAe,UAAwB;AAChF,MAAI;AACF,WAAO,KAAK,MAAM,KAAK;AAAA,EACzB,QAAQ;AACN,WAAO,YAAY;AAAA,EACrB;AACF;","names":[]}

package/dist/text/index.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/text/index.ts
+var text_exports = {};
+__export(text_exports, {
+  byteLength: () => byteLength,
+  stringLength: () => stringLength
+});
+module.exports = __toCommonJS(text_exports);
+
+// src/text/length.ts
+function stringLength(input) {
+  if (typeof Intl !== "undefined" && "Segmenter" in Intl) {
+    const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+    return [...segmenter.segment(input)].length;
+  }
+  return [...input].length;
+}
+function byteLength(input) {
+  return new TextEncoder().encode(input).length;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  byteLength,
+  stringLength
+});
+//# sourceMappingURL=index.cjs.map

package/dist/text/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/text/index.ts","../../src/text/length.ts"],"sourcesContent":["export { stringLength, byteLength } from \"./length.js\";\n","/**\n * Visual-character-accurate length. Native `.length` counts UTF-16 code\n * units, which over-counts emoji and other supplementary-plane characters\n * (e.g. `\"😀\".length === 2`). Uses `Intl.Segmenter` (grapheme granularity)\n * when available, falling back to Unicode code-point counting otherwise —\n * still more accurate than native `.length` on older runtimes.\n */\nexport function stringLength(input: string): number {\n  if (typeof Intl !== \"undefined\" && \"Segmenter\" in Intl) {\n    const segmenter = new Intl.Segmenter(undefined, { granularity: \"grapheme\" });\n    return [...segmenter.segment(input)].length;\n  }\n  return [...input].length;\n}\n\n/**\n * UTF-8 byte length — useful for storage/column-size limits, distinct from\n * `stringLength` (visual character count). A single emoji is 1 character\n * but up to 4 bytes.\n */\nexport function byteLength(input: string): number {\n  return new TextEncoder().encode(input).length;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACOO,SAAS,aAAa,OAAuB;AAClD,MAAI,OAAO,SAAS,eAAe,eAAe,MAAM;AACtD,UAAM,YAAY,IAAI,KAAK,UAAU,QAAW,EAAE,aAAa,WAAW,CAAC;AAC3E,WAAO,CAAC,GAAG,UAAU,QAAQ,KAAK,CAAC,EAAE;AAAA,EACvC;AACA,SAAO,CAAC,GAAG,KAAK,EAAE;AACpB;AAOO,SAAS,WAAW,OAAuB;AAChD,SAAO,IAAI,YAAY,EAAE,OAAO,KAAK,EAAE;AACzC;","names":[]}

package/dist/text/index.d.cts

@@ -0,0 +1,16 @@
+/**
+ * Visual-character-accurate length. Native `.length` counts UTF-16 code
+ * units, which over-counts emoji and other supplementary-plane characters
+ * (e.g. `"😀".length === 2`). Uses `Intl.Segmenter` (grapheme granularity)
+ * when available, falling back to Unicode code-point counting otherwise —
+ * still more accurate than native `.length` on older runtimes.
+ */
+declare function stringLength(input: string): number;
+/**
+ * UTF-8 byte length — useful for storage/column-size limits, distinct from
+ * `stringLength` (visual character count). A single emoji is 1 character
+ * but up to 4 bytes.
+ */
+declare function byteLength(input: string): number;
+
+export { byteLength, stringLength };

package/dist/text/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Visual-character-accurate length. Native `.length` counts UTF-16 code
+ * units, which over-counts emoji and other supplementary-plane characters
+ * (e.g. `"😀".length === 2`). Uses `Intl.Segmenter` (grapheme granularity)
+ * when available, falling back to Unicode code-point counting otherwise —
+ * still more accurate than native `.length` on older runtimes.
+ */
+declare function stringLength(input: string): number;
+/**
+ * UTF-8 byte length — useful for storage/column-size limits, distinct from
+ * `stringLength` (visual character count). A single emoji is 1 character
+ * but up to 4 bytes.
+ */
+declare function byteLength(input: string): number;
+
+export { byteLength, stringLength };

package/dist/text/index.mjs

@@ -0,0 +1,16 @@
+// src/text/length.ts
+function stringLength(input) {
+  if (typeof Intl !== "undefined" && "Segmenter" in Intl) {
+    const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+    return [...segmenter.segment(input)].length;
+  }
+  return [...input].length;
+}
+function byteLength(input) {
+  return new TextEncoder().encode(input).length;
+}
+export {
+  byteLength,
+  stringLength
+};
+//# sourceMappingURL=index.mjs.map

package/dist/text/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/text/length.ts"],"sourcesContent":["/**\n * Visual-character-accurate length. Native `.length` counts UTF-16 code\n * units, which over-counts emoji and other supplementary-plane characters\n * (e.g. `\"😀\".length === 2`). Uses `Intl.Segmenter` (grapheme granularity)\n * when available, falling back to Unicode code-point counting otherwise —\n * still more accurate than native `.length` on older runtimes.\n */\nexport function stringLength(input: string): number {\n  if (typeof Intl !== \"undefined\" && \"Segmenter\" in Intl) {\n    const segmenter = new Intl.Segmenter(undefined, { granularity: \"grapheme\" });\n    return [...segmenter.segment(input)].length;\n  }\n  return [...input].length;\n}\n\n/**\n * UTF-8 byte length — useful for storage/column-size limits, distinct from\n * `stringLength` (visual character count). A single emoji is 1 character\n * but up to 4 bytes.\n */\nexport function byteLength(input: string): number {\n  return new TextEncoder().encode(input).length;\n}\n"],"mappings":";AAOO,SAAS,aAAa,OAAuB;AAClD,MAAI,OAAO,SAAS,eAAe,eAAe,MAAM;AACtD,UAAM,YAAY,IAAI,KAAK,UAAU,QAAW,EAAE,aAAa,WAAW,CAAC;AAC3E,WAAO,CAAC,GAAG,UAAU,QAAQ,KAAK,CAAC,EAAE;AAAA,EACvC;AACA,SAAO,CAAC,GAAG,KAAK,EAAE;AACpB;AAOO,SAAS,WAAW,OAAuB;AAChD,SAAO,IAAI,YAAY,EAAE,OAAO,KAAK,EAAE;AACzC;","names":[]}

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@berkayyalcin/utilkit",
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Zero-dependency devkit for everyday JavaScript/TypeScript utilities: Unicode-safe Base64, correct string length, and safe JSON parsing.",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./encoding": {
+      "import": {
+        "types": "./dist/encoding/index.d.ts",
+        "default": "./dist/encoding/index.mjs"
+      },
+      "require": {
+        "types": "./dist/encoding/index.d.cts",
+        "default": "./dist/encoding/index.cjs"
+      }
+    },
+    "./text": {
+      "import": {
+        "types": "./dist/text/index.d.ts",
+        "default": "./dist/text/index.mjs"
+      },
+      "require": {
+        "types": "./dist/text/index.d.cts",
+        "default": "./dist/text/index.cjs"
+      }
+    },
+    "./data": {
+      "import": {
+        "types": "./dist/data/index.d.ts",
+        "default": "./dist/data/index.mjs"
+      },
+      "require": {
+        "types": "./dist/data/index.d.cts",
+        "default": "./dist/data/index.cjs"
+      }
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "encoding": ["./dist/encoding/index.d.ts"],
+      "text": ["./dist/text/index.d.ts"],
+      "data": ["./dist/data/index.d.ts"]
+    }
+  },
+  "files": ["dist"],
+  "sideEffects": false,
+  "license": "MIT",
+  "author": "Berkay Yalçın",
+  "homepage": "https://github.com/berkayyalcin7/utilkit#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/berkayyalcin7/utilkit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/berkayyalcin7/utilkit/issues"
+  },
+  "keywords": ["utility", "base64", "unicode", "json", "typescript", "zero-dependency", "devkit"],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run lint && npm run typecheck && npm run test && npm run build"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.17.0",
+    "@vitest/coverage-v8": "^3.0.0",
+    "eslint": "^9.17.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.18.0",
+    "vitest": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}