dencodeme/dist/index.js

Encode/Decode data using various encoding schemes.

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
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, {
  base: () => base,
  base32: () => base32,
  base36: () => base36,
  base64: () => base64,
  binary: () => binary,
  decimal: () => decimal,
  hexadecimal: () => hexadecimal,
  octal: () => octal
});
module.exports = __toCommonJS(src_exports);

// src/util.ts
function getMapper(length) {
  return (a, x, i) => {
    if (i % length == 0)
      a.push("");
    return a[a.length - 1] += x, a;
  };
}
__name(getMapper, "getMapper");
function padStart(data, length) {
  return [...Array((length - data.length % length) % length).fill("0"), ...data].reduce(getMapper(length), []);
}
__name(padStart, "padStart");
function padEnd(data, length) {
  return [...data, ...Array((length - data.length % length) % length).fill("=")].reduce(getMapper(length), []);
}
__name(padEnd, "padEnd");
function quickMap(length, multiplier, reverse = false) {
  return Array(length).fill(0).map((_, x) => multiplier(reverse ? -x + length - 1 : x));
}
__name(quickMap, "quickMap");
function stringToNumber(str, charset3) {
  return str.split("").reverse().map((x) => charset3.indexOf(x)).reduce((a, x, i) => a + (x >= 0 ? x * charset3.length ** i : 0), 0);
}
__name(stringToNumber, "stringToNumber");

// src/base.ts
function base(radix3) {
  const rdx = Math.floor(Math.min(36, Math.max(2, radix3)));
  const max = 255 .toString(rdx).length;
  const charset3 = "0123456789abcdefghijklmnopqrstuvwxyz".slice(0, rdx);
  return {
    charset: charset3,
    radix: rdx,
    regex: new RegExp(`[${charset3}]`, "gi"),
    encode(data, encoding = "utf8") {
      return Buffer.from(data.toString(encoding), encoding).toJSON().data.map((x) => x.toString(rdx).padStart(max, "0")).join("");
    },
    decode(data, encoding) {
      const decoded = Buffer.from(padStart((data.toString().toLowerCase().match(this.regex) ?? []).join(""), max).map((x) => parseInt(x, rdx)));
      return encoding ? decoded.toString(encoding) : decoded;
    }
  };
}
__name(base, "base");

// src/base32.ts
var base32_exports = {};
__export(base32_exports, {
  charset: () => charset,
  decode: () => decode,
  encode: () => encode,
  radix: () => radix,
  regex: () => regex
});
var charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
var radix = 32;
var regex = /[A-Z2-7]/gi;
var bits = quickMap(5, (x) => 2 ** (x * 8), true);
var chars = quickMap(8, (x) => 2 ** (x * 5), true);
var pads = quickMap(5, (x) => (8 - Math.ceil(x * 8 / 5)) % 8, false);
function encode(data, encoding = "utf8") {
  let padding = 0;
  return Buffer.from(data.toString(encoding), encoding).reduce((a, x, i, r) => {
    if (i % 5 == 0)
      a.push(0);
    a[a.length - 1] += x * bits[i % 5];
    if (i + 1 >= r.length)
      padding = pads[r.length % 5];
    return a;
  }, []).map((x, i, r) => chars.slice(0, 8 - Number(i + 1 >= r.length) * padding).map((y) => charset[Math.floor(x / y) % 32]).join("")).join("") + "=".repeat(padding);
}
__name(encode, "encode");
function decode(data, encoding) {
  const decoded = Buffer.from(padEnd((data.toString().toUpperCase().match(regex) ?? []).join(""), 8).flatMap((x) => {
    const value = stringToNumber(x, charset);
    return bits.slice(0, pads.indexOf((x.match(/=/g) ?? []).length) || 5).map((y) => Math.floor(value / y) % 256);
  }));
  return encoding ? decoded.toString(encoding) : decoded;
}
__name(decode, "decode");

// src/base64.ts
var base64_exports = {};
__export(base64_exports, {
  charset: () => charset2,
  decode: () => decode2,
  encode: () => encode2,
  radix: () => radix2,
  regex: () => regex2
});
var charset2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
var radix2 = 64;
var regex2 = /[A-Za-z0-9+/]/gi;
var bits2 = quickMap(3, (x) => 2 ** (x * 8), true);
var chars2 = quickMap(4, (x) => 2 ** (x * 6), true);
var pads2 = quickMap(3, (x) => (4 - Math.ceil(x * 4 / 3)) % 4, false);
function encode2(data, encoding = "utf8") {
  let padding = 0;
  return Buffer.from(data.toString(encoding), encoding).reduce((a, x, i, r) => {
    if (i % 3 == 0)
      a.push(0);
    a[a.length - 1] += x * bits2[i % 3];
    if (i + 1 >= r.length)
      padding = pads2[r.length % 3];
    return a;
  }, []).map((x, i, r) => chars2.slice(0, 4 - Number(i + 1 >= r.length) * padding).map((y) => charset2[Math.floor(x / y) % 64]).join("")).join("") + "=".repeat(padding);
}
__name(encode2, "encode");
function decode2(data, encoding) {
  const decoded = Buffer.from(padEnd((data.toString().replaceAll("-", "+").replaceAll("_", "/").match(regex2) ?? []).join(""), 4).flatMap((x) => {
    const value = stringToNumber(x, charset2);
    return bits2.slice(0, pads2.indexOf((x.match(/=/g) ?? []).length) || 3).map((y) => Math.floor(value / y) % 256);
  }));
  return encoding ? decoded.toString(encoding) : decoded;
}
__name(decode2, "decode");

// src/index.ts
var binary = base(2);
var octal = base(8);
var decimal = base(10);
var hexadecimal = base(16);
var base32 = base32_exports;
var base36 = base(36);
var base64 = base64_exports;
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  base,
  base32,
  base36,
  base64,
  binary,
  decimal,
  hexadecimal,
  octal
});