@splendidlabz/utils 1.6.0 → 1.8.1

package/dist/cjs/node/file-cache.cjs

@@ -0,0 +1,196 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node/file-cache.js
+var file_cache_exports = {};
+__export(file_cache_exports, {
+  createCache: () => createCache,
+  fileCache: () => fileCache,
+  getLastModifiedTime: () => getLastModifiedTime,
+  getLatestModifiedTime: () => getLatestModifiedTime,
+  removeFirstSlash: () => removeFirstSlash
+});
+module.exports = __toCommonJS(file_cache_exports);
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_glob = require("glob");
+var import_node_path = __toESM(require("path"), 1);
+
+// src/lib/objects/nested-property.js
+function getNestedValue(object, path2) {
+  return path2.split(".").reduce((acc, part) => acc?.[part], object);
+}
+
+// src/lib/arrays/sort.js
+function sort(array, { props = null, reverse = false } = {}) {
+  const clone = array.slice();
+  if (props === null) {
+    return clone.sort((a, b) => {
+      const comparison = compareValues(a, b);
+      return reverse ? -comparison : comparison;
+    });
+  }
+  const properties = Array.isArray(props) ? props : [props];
+  return clone.sort((a, b) => {
+    for (const property of properties) {
+      const aValue = getNestedValue(a, property);
+      const bValue = getNestedValue(b, property);
+      if (aValue === bValue) continue;
+      if (aValue == null) return 1;
+      if (bValue == null) return -1;
+      const comparison = compareValues(aValue, bValue);
+      return reverse ? -comparison : comparison;
+    }
+    return 0;
+  });
+}
+function compareValues(a, b) {
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (typeof a === "string" && typeof b === "string") return a.localeCompare(b);
+  const aDate = new Date(a);
+  const bDate = new Date(b);
+  const aTime = aDate.getTime();
+  const bTime = bDate.getTime();
+  if (!isNaN(aTime) && !isNaN(bTime)) return aTime - bTime;
+  return String(a).localeCompare(String(b));
+}
+
+// src/node/file-cache.js
+async function createCache(dir) {
+  const absDirpath = import_node_path.default.join(process.cwd(), dir);
+  await import_promises.default.mkdir(absDirpath, { recursive: true });
+  return {
+    async cacheAt(file) {
+      if (file) {
+        const absFilepath = import_node_path.default.join(absDirpath, file);
+        try {
+          const stat = await import_promises.default.stat(absFilepath);
+          return stat.mtimeMs;
+        } catch (error) {
+          return 0;
+        }
+      } else {
+        return getLastModifiedTime(dir + "/**/*");
+      }
+    },
+    getAbsPath(file) {
+      return import_node_path.default.join(absDirpath, file);
+    },
+    async hasFile(file) {
+      const absFilepath = import_node_path.default.join(absDirpath, file);
+      try {
+        await import_promises.default.stat(absFilepath);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    },
+    async loadFile(file) {
+      try {
+        const absFilepath = import_node_path.default.join(absDirpath, file);
+        return import_promises.default.readFile(absFilepath);
+      } catch (error) {
+        console.warn(`File not found: ${file}`);
+      }
+    },
+    async saveFile(file, data) {
+      const absfilepath = import_node_path.default.join(absDirpath, file);
+      await import_promises.default.writeFile(absfilepath, data);
+    },
+    async loadJSON(file) {
+      const data = await this.loadFile(file);
+      try {
+        return JSON.parse(data.toString());
+      } catch (err) {
+        console.warn(`Error parsing JSON: ${file}`);
+        return {};
+      }
+    },
+    async saveJSON(file, data) {
+      await this.saveFile(file, JSON.stringify(data));
+    }
+  };
+}
+async function fileCache({ dir, file }) {
+  await import_promises.default.mkdir(import_node_path.default.join(process.cwd(), dir), { recursive: true });
+  const cachePath = import_node_path.default.join(process.cwd(), dir, `${file}`);
+  let modifiedAt = 0;
+  try {
+    const stat = await import_promises.default.stat(cachePath);
+    modifiedAt = stat.mtimeMs;
+  } catch (error) {
+  }
+  return {
+    modifiedAt,
+    async load() {
+      return import_promises.default.readFile(cachePath);
+    },
+    async save(data) {
+      await import_promises.default.writeFile(cachePath, data);
+    },
+    async loadJSON() {
+      const data = await import_promises.default.readFile(cachePath);
+      return JSON.parse(data.toString());
+    },
+    async saveJSON(data) {
+      await import_promises.default.writeFile(cachePath, JSON.stringify(data));
+    }
+  };
+}
+async function getLastModifiedTime(globPath) {
+  let files;
+  if (typeof globPath === "string") {
+    files = await (0, import_glob.glob)(removeFirstSlash(globPath));
+  }
+  if (Array.isArray(globPath)) {
+    const a = await Promise.all(
+      globPath.map((path2) => (0, import_glob.glob)(removeFirstSlash(path2)))
+    );
+    files = a.flat();
+  }
+  const stats = await Promise.all(files.map((file) => import_promises.default.stat(file)));
+  const timestamps = stats.map((stat) => Number(stat.mtimeMs));
+  const sorted = sort(timestamps, { props: "mtimeMs", reverse: true });
+  return sorted[0] || 0;
+}
+async function getLatestModifiedTime(globPath) {
+  console.warn(
+    "`getLatestModifiedTime` has been renamed to `getLastModifiedTime` and will be deprecated in future versions. Please use `getLastModifiedTime` instead."
+  );
+  return getLastModifiedTime(globPath);
+}
+function removeFirstSlash(x) {
+  return x.startsWith("/") ? x.slice(1) : x;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCache,
+  fileCache,
+  getLastModifiedTime,
+  getLatestModifiedTime,
+  removeFirstSlash
+});

package/dist/cjs/node/file.cjs

@@ -0,0 +1,50 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node/file.js
+var file_exports = {};
+__export(file_exports, {
+  copyFile: () => copyFile,
+  mkdir: () => mkdir
+});
+module.exports = __toCommonJS(file_exports);
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path = __toESM(require("path"), 1);
+async function mkdir(path2) {
+  return import_promises.default.mkdir(path2, { recursive: true });
+}
+async function copyFile(from, to) {
+  const dir = import_node_path.default.dirname(to);
+  await mkdir(dir);
+  await import_promises.default.copyFile(from, to);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  copyFile,
+  mkdir
+});

package/dist/cjs/node/hash.cjs

@@ -0,0 +1,42 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node/hash.js
+var hash_exports = {};
+__export(hash_exports, {
+  sha256Hash: () => sha256Hash
+});
+module.exports = __toCommonJS(hash_exports);
+var import_node_crypto = __toESM(require("crypto"), 1);
+function sha256Hash(string) {
+  return import_node_crypto.default.createHash("sha256").update(string).digest("hex");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sha256Hash
+});

package/dist/cjs/node/index.cjs

@@ -0,0 +1,290 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node/index.js
+var node_exports = {};
+__export(node_exports, {
+  PKCE: () => PKCE,
+  __dirname: () => __dirname,
+  createCache: () => createCache,
+  dirname: () => dirname,
+  fileCache: () => fileCache,
+  getLastModifiedTime: () => getLastModifiedTime,
+  getLatestModifiedTime: () => getLatestModifiedTime,
+  randomString: () => randomString,
+  removeFirstSlash: () => removeFirstSlash,
+  sanitize: () => sanitize2,
+  sha256Hash: () => sha256Hash,
+  uuid: () => uuid
+});
+module.exports = __toCommonJS(node_exports);
+
+// src/node/common.js
+var import_crypto = __toESM(require("crypto"), 1);
+function uuid() {
+  return import_crypto.default.randomUUID();
+}
+
+// src/node/dirname.js
+var import_node_path = __toESM(require("path"), 1);
+var import_node_url = require("url");
+function __dirname(url) {
+  if (!url) throw Error("Please provide 'import.meta.url' to dirname");
+  return import_node_path.default.dirname((0, import_node_url.fileURLToPath)(url));
+}
+function dirname(url) {
+  return __dirname(url);
+}
+
+// src/node/file-cache.js
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_glob = require("glob");
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/lib/objects/nested-property.js
+function getNestedValue(object, path3) {
+  return path3.split(".").reduce((acc, part) => acc?.[part], object);
+}
+
+// src/lib/arrays/sort.js
+function sort(array, { props = null, reverse = false } = {}) {
+  const clone = array.slice();
+  if (props === null) {
+    return clone.sort((a, b) => {
+      const comparison = compareValues(a, b);
+      return reverse ? -comparison : comparison;
+    });
+  }
+  const properties = Array.isArray(props) ? props : [props];
+  return clone.sort((a, b) => {
+    for (const property of properties) {
+      const aValue = getNestedValue(a, property);
+      const bValue = getNestedValue(b, property);
+      if (aValue === bValue) continue;
+      if (aValue == null) return 1;
+      if (bValue == null) return -1;
+      const comparison = compareValues(aValue, bValue);
+      return reverse ? -comparison : comparison;
+    }
+    return 0;
+  });
+}
+function compareValues(a, b) {
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (typeof a === "string" && typeof b === "string") return a.localeCompare(b);
+  const aDate = new Date(a);
+  const bDate = new Date(b);
+  const aTime = aDate.getTime();
+  const bTime = bDate.getTime();
+  if (!isNaN(aTime) && !isNaN(bTime)) return aTime - bTime;
+  return String(a).localeCompare(String(b));
+}
+
+// src/node/file-cache.js
+async function createCache(dir) {
+  const absDirpath = import_node_path2.default.join(process.cwd(), dir);
+  await import_promises.default.mkdir(absDirpath, { recursive: true });
+  return {
+    async cacheAt(file) {
+      if (file) {
+        const absFilepath = import_node_path2.default.join(absDirpath, file);
+        try {
+          const stat = await import_promises.default.stat(absFilepath);
+          return stat.mtimeMs;
+        } catch (error) {
+          return 0;
+        }
+      } else {
+        return getLastModifiedTime(dir + "/**/*");
+      }
+    },
+    getAbsPath(file) {
+      return import_node_path2.default.join(absDirpath, file);
+    },
+    async hasFile(file) {
+      const absFilepath = import_node_path2.default.join(absDirpath, file);
+      try {
+        await import_promises.default.stat(absFilepath);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    },
+    async loadFile(file) {
+      try {
+        const absFilepath = import_node_path2.default.join(absDirpath, file);
+        return import_promises.default.readFile(absFilepath);
+      } catch (error) {
+        console.warn(`File not found: ${file}`);
+      }
+    },
+    async saveFile(file, data) {
+      const absfilepath = import_node_path2.default.join(absDirpath, file);
+      await import_promises.default.writeFile(absfilepath, data);
+    },
+    async loadJSON(file) {
+      const data = await this.loadFile(file);
+      try {
+        return JSON.parse(data.toString());
+      } catch (err) {
+        console.warn(`Error parsing JSON: ${file}`);
+        return {};
+      }
+    },
+    async saveJSON(file, data) {
+      await this.saveFile(file, JSON.stringify(data));
+    }
+  };
+}
+async function fileCache({ dir, file }) {
+  await import_promises.default.mkdir(import_node_path2.default.join(process.cwd(), dir), { recursive: true });
+  const cachePath = import_node_path2.default.join(process.cwd(), dir, `${file}`);
+  let modifiedAt = 0;
+  try {
+    const stat = await import_promises.default.stat(cachePath);
+    modifiedAt = stat.mtimeMs;
+  } catch (error) {
+  }
+  return {
+    modifiedAt,
+    async load() {
+      return import_promises.default.readFile(cachePath);
+    },
+    async save(data) {
+      await import_promises.default.writeFile(cachePath, data);
+    },
+    async loadJSON() {
+      const data = await import_promises.default.readFile(cachePath);
+      return JSON.parse(data.toString());
+    },
+    async saveJSON(data) {
+      await import_promises.default.writeFile(cachePath, JSON.stringify(data));
+    }
+  };
+}
+async function getLastModifiedTime(globPath) {
+  let files;
+  if (typeof globPath === "string") {
+    files = await (0, import_glob.glob)(removeFirstSlash(globPath));
+  }
+  if (Array.isArray(globPath)) {
+    const a = await Promise.all(
+      globPath.map((path3) => (0, import_glob.glob)(removeFirstSlash(path3)))
+    );
+    files = a.flat();
+  }
+  const stats = await Promise.all(files.map((file) => import_promises.default.stat(file)));
+  const timestamps = stats.map((stat) => Number(stat.mtimeMs));
+  const sorted = sort(timestamps, { props: "mtimeMs", reverse: true });
+  return sorted[0] || 0;
+}
+async function getLatestModifiedTime(globPath) {
+  console.warn(
+    "`getLatestModifiedTime` has been renamed to `getLastModifiedTime` and will be deprecated in future versions. Please use `getLastModifiedTime` instead."
+  );
+  return getLastModifiedTime(globPath);
+}
+function removeFirstSlash(x) {
+  return x.startsWith("/") ? x.slice(1) : x;
+}
+
+// src/node/hash.js
+var import_node_crypto = __toESM(require("crypto"), 1);
+function sha256Hash(string) {
+  return import_node_crypto.default.createHash("sha256").update(string).digest("hex");
+}
+
+// src/node/pkce.js
+var import_node_crypto3 = __toESM(require("crypto"), 1);
+
+// src/node/random-string.js
+var import_node_crypto2 = __toESM(require("crypto"), 1);
+function randomString(length = 32) {
+  const bytesNeeded = Math.ceil(length * 3 / 4) + 3;
+  return import_node_crypto2.default.randomBytes(bytesNeeded).toString("base64").slice(0, length);
+}
+
+// src/node/pkce.js
+async function PKCE() {
+  const codeVerifier = await randomString();
+  const codeChallenge = await getCodeChallenge(codeVerifier);
+  return {
+    state: await randomString(),
+    code_verifier: codeVerifier,
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256"
+  };
+}
+async function getCodeChallenge(verifier) {
+  const hash = import_node_crypto3.default.createHash("sha256").update(verifier).digest();
+  return hash.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+
+// src/node/sanitize.js
+var import_sanitize_html = __toESM(require("sanitize-html"), 1);
+
+// src/lib/form/sanitize.js
+function sanitize(value, options = {}) {
+  const { sanitizer, ...rest } = options;
+  if (!sanitizer) throw new Error("sanitizer function is required");
+  if (typeof value === "string") return sanitizer(value, rest);
+  if (Array.isArray(value)) return sanitizeArray(value, { sanitizer, ...rest });
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, val]) => [
+        key,
+        sanitize(val, { sanitizer, ...rest })
+      ])
+    );
+  }
+  return value;
+}
+function sanitizeArray(arr, { sanitizer, ...rest }) {
+  if (!sanitizer) throw new Error("sanitizer function is required");
+  return arr.map((item) => sanitize(item, { sanitizer, ...rest }));
+}
+
+// src/node/sanitize.js
+function sanitize2(value, options = {}) {
+  return sanitize(value, { sanitizer: import_sanitize_html.default, ...options });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PKCE,
+  __dirname,
+  createCache,
+  dirname,
+  fileCache,
+  getLastModifiedTime,
+  getLatestModifiedTime,
+  randomString,
+  removeFirstSlash,
+  sanitize,
+  sha256Hash,
+  uuid
+});

package/dist/cjs/node/pkce.cjs

@@ -0,0 +1,62 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node/pkce.js
+var pkce_exports = {};
+__export(pkce_exports, {
+  PKCE: () => PKCE
+});
+module.exports = __toCommonJS(pkce_exports);
+var import_node_crypto2 = __toESM(require("crypto"), 1);
+
+// src/node/random-string.js
+var import_node_crypto = __toESM(require("crypto"), 1);
+function randomString(length = 32) {
+  const bytesNeeded = Math.ceil(length * 3 / 4) + 3;
+  return import_node_crypto.default.randomBytes(bytesNeeded).toString("base64").slice(0, length);
+}
+
+// src/node/pkce.js
+async function PKCE() {
+  const codeVerifier = await randomString();
+  const codeChallenge = await getCodeChallenge(codeVerifier);
+  return {
+    state: await randomString(),
+    code_verifier: codeVerifier,
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256"
+  };
+}
+async function getCodeChallenge(verifier) {
+  const hash = import_node_crypto2.default.createHash("sha256").update(verifier).digest();
+  return hash.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PKCE
+});

package/dist/cjs/node/random-string.cjs

@@ -0,0 +1,43 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node/random-string.js
+var random_string_exports = {};
+__export(random_string_exports, {
+  randomString: () => randomString
+});
+module.exports = __toCommonJS(random_string_exports);
+var import_node_crypto = __toESM(require("crypto"), 1);
+function randomString(length = 32) {
+  const bytesNeeded = Math.ceil(length * 3 / 4) + 3;
+  return import_node_crypto.default.randomBytes(bytesNeeded).toString("base64").slice(0, length);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  randomString
+});