@utilix-tech/sdk 0.1.0

package/dist/chunk-MLKGABMK.js

@@ -0,0 +1,7 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export { __export };

package/dist/chunk-ROTPLW7T.js

@@ -0,0 +1,265 @@
+import { __export } from './chunk-MLKGABMK.js';
+
+// src/tools/encoding.ts
+var encoding_exports = {};
+__export(encoding_exports, {
+  ALPHABETS: () => ALPHABETS,
+  base32Decode: () => base32Decode,
+  base32DecodeBytes: () => base32DecodeBytes,
+  base32Encode: () => base32Encode,
+  base32EncodeBytes: () => base32EncodeBytes,
+  decodeBase64: () => decodeBase64,
+  decodeHtmlEntities: () => decodeHtmlEntities,
+  decodeUrl: () => decodeUrl,
+  diffSegments: () => diffSegments,
+  encodeBase64: () => encodeBase64,
+  encodeHtmlEntities: () => encodeHtmlEntities,
+  encodeHtmlEntitiesAll: () => encodeHtmlEntitiesAll,
+  encodeUrl: () => encodeUrl,
+  isValidBase32: () => isValidBase32
+});
+function toUrlSafe(b64) {
+  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromUrlSafe(b64url) {
+  const base64 = b64url.replace(/-/g, "+").replace(/_/g, "/");
+  return base64 + "=".repeat((4 - base64.length % 4) % 4);
+}
+function encodeBase64(input, variant = "standard") {
+  if (!input) return { ok: false, error: "No input provided" };
+  try {
+    const bytes = Buffer.from(input, "utf8");
+    const b64 = bytes.toString("base64");
+    const output = variant === "urlsafe" ? toUrlSafe(b64) : b64;
+    return { ok: true, output, inputBytes: bytes.length, outputChars: output.length };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+function decodeBase64(input, variant = "standard") {
+  const trimmed = input.trim();
+  if (!trimmed) return { ok: false, error: "No input provided" };
+  try {
+    const b64 = variant === "urlsafe" ? fromUrlSafe(trimmed) : trimmed;
+    const bytes = Buffer.from(b64, "base64");
+    const output = bytes.toString("utf8");
+    return { ok: true, output, outputBytes: bytes.length };
+  } catch {
+    return { ok: false, error: "Invalid Base64 \u2014 check the input and variant setting" };
+  }
+}
+function encodeUrl(input, mode = "component") {
+  if (!input) return { ok: false, error: "No input provided" };
+  try {
+    const output = mode === "component" ? encodeURIComponent(input) : encodeURI(input);
+    return { ok: true, output, changed: output !== input };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+function decodeUrl(input, mode = "component") {
+  const trimmed = input.trim();
+  if (!trimmed) return { ok: false, error: "No input provided" };
+  try {
+    const output = mode === "component" ? decodeURIComponent(trimmed) : decodeURI(trimmed);
+    return { ok: true, output, changed: output !== trimmed };
+  } catch {
+    return { ok: false, error: "Invalid percent-encoding \u2014 check the input" };
+  }
+}
+function diffSegments(original, encoded) {
+  if (original === encoded) return [{ text: original, changed: false }];
+  const segments = [];
+  let i = 0;
+  let j = 0;
+  while (i < original.length && j < encoded.length) {
+    if (original[i] === encoded[j]) {
+      const start = j;
+      while (j < encoded.length && i < original.length && original[i] === encoded[j]) {
+        i++;
+        j++;
+      }
+      segments.push({ text: encoded.slice(start, j), changed: false });
+    } else {
+      const start = j;
+      while (j < encoded.length && (j === start || encoded[j] === "%" || /[0-9A-F]/i.test(encoded[j]))) {
+        if (encoded[j] === "%") {
+          j += 3;
+          i++;
+        } else {
+          break;
+        }
+      }
+      if (j === start) {
+        j++;
+        i++;
+      }
+      segments.push({ text: encoded.slice(start, j), changed: true });
+    }
+  }
+  if (j < encoded.length) segments.push({ text: encoded.slice(j), changed: true });
+  return segments;
+}
+var NAMED_ENTITIES = {
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&apos;": "'",
+  "&nbsp;": " ",
+  "&copy;": "\xA9",
+  "&reg;": "\xAE",
+  "&trade;": "\u2122",
+  "&mdash;": "\u2014",
+  "&ndash;": "\u2013",
+  "&hellip;": "\u2026"
+};
+function encodeHtmlEntities(input) {
+  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function decodeHtmlEntities(input) {
+  let result = input;
+  for (const [entity, char] of Object.entries(NAMED_ENTITIES)) {
+    result = result.split(entity).join(char);
+  }
+  result = result.replace(/&#(\d+);/g, (_match, dec) => {
+    return String.fromCodePoint(parseInt(dec, 10));
+  });
+  result = result.replace(/&#[xX]([0-9a-fA-F]+);/g, (_match, hex) => {
+    return String.fromCodePoint(parseInt(hex, 16));
+  });
+  return result;
+}
+function encodeHtmlEntitiesAll(input) {
+  let result = "";
+  for (const char of input) {
+    const code = char.codePointAt(0);
+    if (char === "&" || char === "<" || char === ">" || char === '"' || char === "'") {
+      result += `&#${code};`;
+    } else if (code > 127) {
+      result += `&#${code};`;
+    } else {
+      result += char;
+    }
+  }
+  return result;
+}
+var ALPHABETS = {
+  "standard": "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+  "hex": "0123456789ABCDEFGHIJKLMNOPQRSTUV",
+  "crockford": "0123456789ABCDEFGHJKMNPQRSTVWXYZ",
+  "z-base-32": "ybndrfg8ejkmcpqxot1uwisza345h769"
+};
+function stringToBytes(str) {
+  const bytes = [];
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    if (code < 128) {
+      bytes.push(code);
+    } else if (code < 2048) {
+      bytes.push(192 | code >> 6, 128 | code & 63);
+    } else {
+      bytes.push(224 | code >> 12, 128 | code >> 6 & 63, 128 | code & 63);
+    }
+  }
+  return new Uint8Array(bytes);
+}
+function bytesToString(bytes) {
+  let str = "";
+  let i = 0;
+  while (i < bytes.length) {
+    const byte = bytes[i];
+    if (byte < 128) {
+      str += String.fromCharCode(byte);
+      i++;
+    } else if ((byte & 224) === 192) {
+      str += String.fromCharCode((byte & 31) << 6 | bytes[i + 1] & 63);
+      i += 2;
+    } else {
+      str += String.fromCharCode((byte & 15) << 12 | (bytes[i + 1] & 63) << 6 | bytes[i + 2] & 63);
+      i += 3;
+    }
+  }
+  return str;
+}
+function base32EncodeBytes(bytes, alphabet = "standard") {
+  const alpha = ALPHABETS[alphabet];
+  let result = "";
+  let buffer = 0;
+  let bitsLeft = 0;
+  for (let i = 0; i < bytes.length; i++) {
+    buffer = buffer << 8 | bytes[i];
+    bitsLeft += 8;
+    while (bitsLeft >= 5) {
+      bitsLeft -= 5;
+      result += alpha[buffer >> bitsLeft & 31];
+    }
+  }
+  if (bitsLeft > 0) {
+    result += alpha[buffer << 5 - bitsLeft & 31];
+  }
+  while (result.length % 8 !== 0) {
+    result += "=";
+  }
+  return result;
+}
+function base32DecodeBytes(input, alphabet = "standard") {
+  const alpha = ALPHABETS[alphabet];
+  const stripped = input.toUpperCase().replace(/=+$/, "");
+  const normalizedInput = alphabet === "z-base-32" ? input.replace(/=+$/, "") : stripped;
+  const bytes = [];
+  let buffer = 0;
+  let bitsLeft = 0;
+  for (let i = 0; i < normalizedInput.length; i++) {
+    const char = normalizedInput[i];
+    const val = alpha.indexOf(char);
+    if (val === -1) {
+      return { error: `Invalid character '${char}' for ${alphabet} alphabet` };
+    }
+    buffer = buffer << 5 | val;
+    bitsLeft += 5;
+    if (bitsLeft >= 8) {
+      bitsLeft -= 8;
+      bytes.push(buffer >> bitsLeft & 255);
+    }
+  }
+  return new Uint8Array(bytes);
+}
+function base32Encode(input, alphabet = "standard") {
+  const bytes = stringToBytes(input);
+  return base32EncodeBytes(bytes, alphabet);
+}
+function base32Decode(input, alphabet = "standard") {
+  const result = base32DecodeBytes(input, alphabet);
+  if (typeof result === "object" && "error" in result) {
+    return result;
+  }
+  return bytesToString(result);
+}
+function isValidBase32(input, alphabet = "standard") {
+  if (input.length === 0) return true;
+  const alpha = ALPHABETS[alphabet];
+  const paddingIndex = input.indexOf("=");
+  let dataPart;
+  let paddingPart;
+  if (paddingIndex === -1) {
+    dataPart = input;
+    paddingPart = "";
+  } else {
+    dataPart = input.slice(0, paddingIndex);
+    paddingPart = input.slice(paddingIndex);
+  }
+  if (!/^=*$/.test(paddingPart)) return false;
+  for (let i = 0; i < dataPart.length; i++) {
+    const char = alphabet === "z-base-32" ? dataPart[i] : dataPart[i].toUpperCase();
+    if (alpha.indexOf(char) === -1) return false;
+  }
+  if (paddingPart.length > 0) {
+    if (input.length % 8 !== 0) return false;
+  }
+  const rem = dataPart.length % 8;
+  if (rem === 1 || rem === 3 || rem === 6) return false;
+  return true;
+}
+
+export { ALPHABETS, base32Decode, base32DecodeBytes, base32Encode, base32EncodeBytes, decodeBase64, decodeHtmlEntities, decodeUrl, diffSegments, encodeBase64, encodeHtmlEntities, encodeHtmlEntitiesAll, encodeUrl, encoding_exports, isValidBase32 };