@utilix-tech/sdk 0.1.0

package/dist/tools/data.d.cts

@@ -0,0 +1 @@
+export { C as CsvParseResult, E as EnvEntry, a as EnvParseResult, I as IniSection, P as ParseOptions, b as ParsedIni, T as TomlFormatResult, V as ValidationResult, X as XmlFormatResult, c as XmlToJsonOptions, e as csvToJson, f as detectDelimiter, g as envToExport, h as envToJson, i as formatToml, j as formatXml, k as getSection, l as getSectionNames, m as getTomlStats, n as getXmlStats, o as getYamlStats, p as iniToJson, q as jsonToIni, r as jsonToToml, s as jsonToXml, t as minifyToml, u as minifyXml, v as parseCsv, w as parseEnv, x as parseIni, y as parseXmlToObject, z as stringifyIni, A as toCsvString, B as tomlToJson, D as validateEnvKey, F as validateIni, G as validateToml, H as validateXml, J as validateYaml, K as xmlToJson } from '../data-rMjWNiOJ.cjs';

package/dist/tools/data.d.ts

@@ -0,0 +1 @@
+export { C as CsvParseResult, E as EnvEntry, a as EnvParseResult, I as IniSection, P as ParseOptions, b as ParsedIni, T as TomlFormatResult, V as ValidationResult, X as XmlFormatResult, c as XmlToJsonOptions, e as csvToJson, f as detectDelimiter, g as envToExport, h as envToJson, i as formatToml, j as formatXml, k as getSection, l as getSectionNames, m as getTomlStats, n as getXmlStats, o as getYamlStats, p as iniToJson, q as jsonToIni, r as jsonToToml, s as jsonToXml, t as minifyToml, u as minifyXml, v as parseCsv, w as parseEnv, x as parseIni, y as parseXmlToObject, z as stringifyIni, A as toCsvString, B as tomlToJson, D as validateEnvKey, F as validateIni, G as validateToml, H as validateXml, J as validateYaml, K as xmlToJson } from '../data-rMjWNiOJ.js';

package/dist/tools/data.js

@@ -0,0 +1,2 @@
+export { csvToJson, detectDelimiter, envToExport, envToJson, formatToml, formatXml, getSection, getSectionNames, getTomlStats, getXmlStats, getYamlStats, iniToJson, jsonToIni, jsonToToml, jsonToXml, minifyToml, minifyXml, parseCsv, parseEnv, parseIni, parseXmlToObject, stringifyIni, toCsvString, tomlToJson, validateEnvKey, validateIni, validateToml, validateXml, validateYaml, xmlToJson } from '../chunk-UC656APA.js';
+import '../chunk-MLKGABMK.js';

package/dist/tools/encoding.cjs

@@ -0,0 +1,261 @@
+'use strict';
+
+// src/tools/encoding.ts
+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;
+}
+
+exports.ALPHABETS = ALPHABETS;
+exports.base32Decode = base32Decode;
+exports.base32DecodeBytes = base32DecodeBytes;
+exports.base32Encode = base32Encode;
+exports.base32EncodeBytes = base32EncodeBytes;
+exports.decodeBase64 = decodeBase64;
+exports.decodeHtmlEntities = decodeHtmlEntities;
+exports.decodeUrl = decodeUrl;
+exports.diffSegments = diffSegments;
+exports.encodeBase64 = encodeBase64;
+exports.encodeHtmlEntities = encodeHtmlEntities;
+exports.encodeHtmlEntitiesAll = encodeHtmlEntitiesAll;
+exports.encodeUrl = encodeUrl;
+exports.isValidBase32 = isValidBase32;

package/dist/tools/encoding.d.cts

@@ -0,0 +1 @@
+export { A as ALPHABETS, B as Base32Alphabet, a as Base64DecodeResult, b as Base64EncodeResult, c as Base64Error, d as Base64Variant, D as DecodeResult, E as EncodeResult, U as UrlEncodeError, f as UrlEncodeMode, g as UrlEncodeResult, h as UrlResult, i as base32Decode, j as base32DecodeBytes, k as base32Encode, l as base32EncodeBytes, m as decodeBase64, n as decodeHtmlEntities, o as decodeUrl, p as diffSegments, q as encodeBase64, r as encodeHtmlEntities, s as encodeHtmlEntitiesAll, t as encodeMode, u as encodeUrl, v as isValidBase32 } from '../encoding-7gmq-vkV.cjs';

package/dist/tools/encoding.d.ts

@@ -0,0 +1 @@
+export { A as ALPHABETS, B as Base32Alphabet, a as Base64DecodeResult, b as Base64EncodeResult, c as Base64Error, d as Base64Variant, D as DecodeResult, E as EncodeResult, U as UrlEncodeError, f as UrlEncodeMode, g as UrlEncodeResult, h as UrlResult, i as base32Decode, j as base32DecodeBytes, k as base32Encode, l as base32EncodeBytes, m as decodeBase64, n as decodeHtmlEntities, o as decodeUrl, p as diffSegments, q as encodeBase64, r as encodeHtmlEntities, s as encodeHtmlEntitiesAll, t as encodeMode, u as encodeUrl, v as isValidBase32 } from '../encoding-7gmq-vkV.js';

package/dist/tools/encoding.js

@@ -0,0 +1,2 @@
+export { ALPHABETS, base32Decode, base32DecodeBytes, base32Encode, base32EncodeBytes, decodeBase64, decodeHtmlEntities, decodeUrl, diffSegments, encodeBase64, encodeHtmlEntities, encodeHtmlEntitiesAll, encodeUrl, isValidBase32 } from '../chunk-ROTPLW7T.js';
+import '../chunk-MLKGABMK.js';