moderndash 0.0.9 → 0.0.11

package/dist/index.cjs

@@ -0,0 +1,711 @@
+"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, {
+  after: () => after,
+  before: () => before,
+  camelCase: () => camelCase,
+  capitalize: () => capitalize,
+  chunk: () => chunk,
+  countBy: () => countBy,
+  debounce: () => debounce,
+  deburr: () => deburr,
+  difference: () => difference,
+  differenceBy: () => differenceBy,
+  differenceWith: () => differenceWith,
+  dropRightWhile: () => dropRightWhile,
+  dropWhile: () => dropWhile,
+  escape: () => escape,
+  escapeRegExp: () => escapeRegExp,
+  groupBy: () => groupBy,
+  intersection: () => intersection,
+  intersectionBy: () => intersectionBy,
+  intersectionWith: () => intersectionWith,
+  isEmpty: () => isEmpty,
+  isEqual: () => isEqual,
+  isEqualWith: () => isEqualWith,
+  isPlainObject: () => isPlainObject,
+  kebabCase: () => kebabCase,
+  memoize: () => memoize,
+  once: () => once,
+  pascalCase: () => pascalCase,
+  pick: () => pick,
+  sample: () => sample,
+  sampleSize: () => sampleSize,
+  shuffle: () => shuffle,
+  snakeCase: () => snakeCase,
+  sortBy: () => sortBy,
+  startCase: () => startCase,
+  stripSpecialChars: () => stripSpecialChars,
+  takeRightWhile: () => takeRightWhile,
+  takeWhile: () => takeWhile,
+  throttle: () => throttle,
+  times: () => times,
+  unescapeHTML: () => unescapeHTML,
+  uniq: () => uniq,
+  uniqBy: () => uniqBy,
+  uniqWith: () => uniqWith,
+  unzip: () => unzip,
+  unzipWith: () => unzipWith,
+  zip: () => zip,
+  zipWith: () => zipWith
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/array/chunk.ts
+function chunk(chunkSize, array) {
+  const sizeInteger = Math.trunc(chunkSize);
+  if (array.length === 0 || sizeInteger < 1) {
+    return [];
+  }
+  const chunkedArray = [];
+  let i = 0;
+  while (i < array.length) {
+    chunkedArray.push(array.slice(i, i + sizeInteger));
+    i += sizeInteger;
+  }
+  return chunkedArray;
+}
+
+// src/array/differenceWith.ts
+function differenceWith(comparator, ...arrays) {
+  const difference2 = [];
+  const [firstArray, ...restArrays] = arrays;
+  firstArray.forEach((element) => {
+    if (!restArrays.some((array) => array.some((item) => comparator(item, element)))) {
+      difference2.push(element);
+    }
+  });
+  return difference2;
+}
+
+// src/lang/isEqual.ts
+function isEqual(value1, value2) {
+  if (value1 === value2)
+    return true;
+  if (Array.isArray(value1) && Array.isArray(value2)) {
+    return isSameArray(value1, value2);
+  }
+  if (value1 instanceof RegExp && value2 instanceof RegExp) {
+    return value1.toString() === value2.toString();
+  }
+  if (isObject(value1) && isObject(value2)) {
+    return isSameObject(value1, value2);
+  }
+  return false;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+function isSameObject(value1, value2) {
+  const keys1 = Object.keys(value1);
+  const keys2 = Object.keys(value2);
+  if (!isEqual(keys1, keys2))
+    return false;
+  for (const key of keys1) {
+    if (!isEqual(value1[key], value2[key]))
+      return false;
+  }
+  return true;
+}
+function isSameArray(value1, value2) {
+  if (value1.length !== value2.length)
+    return false;
+  for (const [i, element] of value1.entries()) {
+    if (!isEqual(element, value2[i]))
+      return false;
+  }
+  return true;
+}
+
+// src/array/difference.ts
+function difference(...arrays) {
+  return differenceWith(isEqual, ...arrays);
+}
+
+// src/helpers/typeofChecks.ts
+function isObjectKey(key) {
+  return typeof key === "string" || typeof key === "number" || typeof key === "symbol";
+}
+
+// src/helpers/shortHands.ts
+function getPropertyShorthand(key) {
+  return (object) => object[key];
+}
+function getIterateFunction(iteratee) {
+  if (typeof iteratee === "function") {
+    return iteratee;
+  } else if (isObjectKey(iteratee)) {
+    return getPropertyShorthand(iteratee);
+  } else {
+    throw new TypeError("Expected iteratee to be a function or a property name");
+  }
+}
+
+// src/lang/isEqualWith.ts
+function isEqualWith(a, b, customizer) {
+  return isEqual(customizer(a), customizer(b));
+}
+
+// src/array/differenceBy.ts
+function differenceBy(iteratee, ...arrays) {
+  const iterateeFunction = getIterateFunction(iteratee);
+  return differenceWith((a, b) => isEqualWith(a, b, iterateeFunction), ...arrays);
+}
+
+// src/array/dropRightWhile.ts
+function dropRightWhile(predicate, array) {
+  let i = array.length;
+  while (i > 0 && predicate(array[i - 1])) {
+    i--;
+  }
+  return array.slice(0, i);
+}
+
+// src/array/dropWhile.ts
+function dropWhile(predicate, array) {
+  const index = array.findIndex((x) => !predicate(x));
+  return array.slice(index === -1 ? array.length : index);
+}
+
+// src/array/intersectionWith.ts
+function intersectionWith(comparator, ...arrays) {
+  const intersection2 = [];
+  const [firstArray, ...restArrays] = arrays;
+  firstArray.forEach((element) => {
+    if (restArrays.every((array) => array.some((item) => comparator(item, element)))) {
+      intersection2.push(element);
+    }
+  });
+  return intersection2;
+}
+
+// src/array/intersection.ts
+function intersection(...arrays) {
+  return intersectionWith(isEqual, ...arrays);
+}
+
+// src/array/intersectionBy.ts
+function intersectionBy(iteratee, ...arrays) {
+  const iterateeFunction = getIterateFunction(iteratee);
+  return intersectionWith((a, b) => isEqualWith(a, b, iterateeFunction), ...arrays);
+}
+
+// src/array/sample.ts
+function sample(array) {
+  if (array.length === 0) {
+    return void 0;
+  }
+  const randomIndex = Math.floor(Math.random() * array.length);
+  return array[randomIndex];
+}
+
+// src/array/sampleSize.ts
+function sampleSize(size, array) {
+  const sampleArray = [];
+  if (array.length === 0 || size <= 0) {
+    return sampleArray;
+  }
+  for (let i = 0; i < size; i++) {
+    sampleArray.push(sample(array));
+  }
+  return sampleArray;
+}
+
+// src/array/shuffle.ts
+function shuffle(array) {
+  const shuffledArray = [...array];
+  let currentIndex = shuffledArray.length;
+  let temporaryValue;
+  let randomIndex;
+  while (0 !== currentIndex) {
+    randomIndex = Math.floor(Math.random() * currentIndex);
+    currentIndex -= 1;
+    temporaryValue = shuffledArray[currentIndex];
+    shuffledArray[currentIndex] = shuffledArray[randomIndex];
+    shuffledArray[randomIndex] = temporaryValue;
+  }
+  return shuffledArray;
+}
+
+// src/array/takeRightWhile.ts
+function takeRightWhile(predicate, array) {
+  const result = [];
+  for (let i = array.length - 1; i >= 0; i--) {
+    if (predicate(array[i])) {
+      result.unshift(array[i]);
+    } else {
+      break;
+    }
+  }
+  return result;
+}
+
+// src/array/takeWhile.ts
+function takeWhile(predicate, array) {
+  const result = [];
+  for (const element of array) {
+    if (predicate(element)) {
+      result.push(element);
+    } else {
+      break;
+    }
+  }
+  return result;
+}
+
+// src/array/uniqWith.ts
+function uniqWith(comparator, array) {
+  return array.filter((value, index, self) => {
+    return self.findIndex((otherValue) => comparator(value, otherValue)) === index;
+  });
+}
+
+// src/array/uniq.ts
+function uniq(array) {
+  return uniqWith(isEqual, array);
+}
+
+// src/array/uniqBy.ts
+function uniqBy(iteratee, array) {
+  const iterateeFunction = getIterateFunction(iteratee);
+  return uniqWith((a, b) => iterateeFunction(a) === iterateeFunction(b), array);
+}
+
+// src/array/unzipWith.ts
+function unzipWith(iteratee, array) {
+  const result = [];
+  for (const elements of array) {
+    result.push(iteratee(...elements));
+  }
+  return result;
+}
+
+// src/array/unzip.ts
+function unzip(array) {
+  return unzipWith((...t) => t, array);
+}
+
+// src/array/zipWith.ts
+function zipWith(combineFunc, ...arrays) {
+  const len = Math.min(...arrays.map((a) => a.length));
+  const zipped = [];
+  for (let i = 0; i < len; i++) {
+    zipped[i] = combineFunc(...arrays.map((a) => a[i]));
+  }
+  return zipped;
+}
+
+// src/array/zip.ts
+function zip(...arrays) {
+  return zipWith((...t) => t, ...arrays);
+}
+
+// src/helpers/collections.ts
+function getValuesFromCollection(collection) {
+  return Array.isArray(collection) ? collection : Object.values(collection);
+}
+
+// src/collection/countBy.ts
+function countBy(collection, iteratee) {
+  const result = {};
+  const values = getValuesFromCollection(collection);
+  for (const value of values) {
+    const key = iteratee(value);
+    if (result[key] === void 0) {
+      result[key] = 1;
+    } else {
+      result[key] += 1;
+    }
+  }
+  return result;
+}
+
+// src/collection/groupBy.ts
+function groupBy(collection, iteratee) {
+  const result = {};
+  const values = getValuesFromCollection(collection);
+  for (const value of values) {
+    const key = iteratee(value);
+    result[key] = result[key] ?? [];
+    result[key].push(value);
+  }
+  return result;
+}
+
+// src/collection/sortBy.ts
+function sortBy(iteratee, array) {
+  return array.sort((a, b) => {
+    const aValue = iteratee(a);
+    const bValue = iteratee(b);
+    if (aValue < bValue) {
+      return -1;
+    }
+    if (aValue > bValue) {
+      return 1;
+    }
+    return 0;
+  });
+}
+
+// src/function/after.ts
+function after(n, func) {
+  let count = 1;
+  return (...args) => {
+    if (count >= n) {
+      return func(...args);
+    }
+    count += 1;
+  };
+}
+
+// src/function/before.ts
+function before(n, func) {
+  let count = 0;
+  let result;
+  return (...args) => {
+    if (count < n) {
+      count += 1;
+      result = func(...args);
+    }
+    return result;
+  };
+}
+
+// src/function/debounce.ts
+function debounce(fn, wait = 0, options = {}) {
+  let lastArgs;
+  let lastThis;
+  let result;
+  let timerId;
+  let lastCallTime;
+  let lastInvokeTime = 0;
+  const maxing = options.maxWait ?? false;
+  const leading = options.leading ?? false;
+  const trailing = options.trailing ?? true;
+  const maxWait = options.maxWait ?? 0;
+  function invokeFunc(time) {
+    const args = lastArgs;
+    const thisArg = lastThis;
+    lastArgs = lastThis = void 0;
+    lastInvokeTime = time;
+    result = fn.apply(thisArg, args);
+    return result;
+  }
+  function leadingEdge(time) {
+    lastInvokeTime = time;
+    timerId = setTimeout(timerExpired, wait);
+    return leading ? invokeFunc(time) : result;
+  }
+  function remainingWait(time) {
+    const timeSinceLastCall = time - lastCallTime;
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    const timeWaiting = wait - timeSinceLastCall;
+    return maxing ? Math.min(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+  }
+  function shouldInvoke(time) {
+    if (lastCallTime === void 0)
+      return true;
+    const timeSinceLastCall = time - lastCallTime;
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    return timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+  }
+  function timerExpired() {
+    const time = Date.now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+  function trailingEdge(time) {
+    timerId = void 0;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = void 0;
+    return result;
+  }
+  function cancel() {
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = void 0;
+  }
+  function flush() {
+    return timerId === void 0 ? result : trailingEdge(Date.now());
+  }
+  function debounced(...args) {
+    const time = Date.now();
+    const isInvoking = shouldInvoke(time);
+    lastArgs = args;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timerId === void 0) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        clearTimeout(timerId);
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === void 0) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+
+// src/function/memoize.ts
+var defaultResolver = (...args) => JSON.stringify(args);
+function memoize(func, resolver = defaultResolver) {
+  const cache = /* @__PURE__ */ new Map();
+  const memoizedFunc = (...args) => {
+    const key = resolver(...args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = func(...args);
+    cache.set(key, result);
+    return result;
+  };
+  memoizedFunc.cache = cache;
+  return memoizedFunc;
+}
+
+// src/function/once.ts
+function once(func) {
+  return before(1, func);
+}
+
+// src/function/throttle.ts
+function throttle(func, wait = 0, options = {}) {
+  return debounce(func, wait, {
+    leading: options.leading ?? true,
+    maxWait: wait,
+    trailing: options.trailing ?? true
+  });
+}
+
+// src/function/times.ts
+function times(n, func) {
+  const result = [];
+  for (let i = 0; i < n; i++) {
+    result.push(func(i));
+  }
+  return result;
+}
+
+// src/lang/isEmpty.ts
+function isEmpty(value) {
+  if (value === null || value === void 0) {
+    return true;
+  }
+  if (typeof value === "string" || Array.isArray(value)) {
+    return value.length === 0;
+  }
+  if (value instanceof Map || value instanceof Set) {
+    return value.size === 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length === 0;
+  }
+  return false;
+}
+
+// src/lang/isPlainObject.ts
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && value.constructor === Object;
+}
+
+// src/object/pick.ts
+function pick(object, keys) {
+  const result = {};
+  for (const key of keys) {
+    result[key] = object[key];
+  }
+  return result;
+}
+
+// src/string/deburr.ts
+function deburr(str) {
+  return str.replace(/[^\u0000-\u007E]/g, (chr) => chr.normalize("NFD").replace(/[\u0300-\u036F]/g, ""));
+}
+
+// src/helpers/stringModifiers.ts
+function splitWords(str) {
+  str = deburr(str);
+  const regex = new RegExp(
+    "[^\\dA-Za-z]|(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])"
+  );
+  return str.split(regex).filter(Boolean);
+}
+
+// src/string/camelCase.ts
+function camelCase(str) {
+  const words = splitWords(str);
+  const camelCase2 = words.map((word, index) => {
+    if (index === 0) {
+      return word.toLowerCase();
+    }
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+  });
+  return camelCase2.join("");
+}
+
+// src/string/capitalize.ts
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/string/escape.ts
+function escape(str) {
+  const escapeChars = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    "'": "&#39;",
+    '"': "&quot;"
+  };
+  return str.replace(/["&'<>]/g, (char) => escapeChars[char] || char);
+}
+
+// src/string/escapeRegExp.ts
+function escapeRegExp(str) {
+  return str.replace(/[$()*+.?[\\\]^{|}]/g, "\\$&");
+}
+
+// src/string/kebabCase.ts
+function kebabCase(str) {
+  const words = splitWords(str);
+  let kebabCase2 = "";
+  for (const word of words) {
+    kebabCase2 += word.toLowerCase() + "-";
+  }
+  return kebabCase2.slice(0, -1);
+}
+
+// src/string/pascalCase.ts
+function pascalCase(str) {
+  const words = splitWords(str);
+  let pascalCase2 = "";
+  for (const word of words) {
+    pascalCase2 += word.charAt(0).toUpperCase() + word.slice(1);
+  }
+  return pascalCase2;
+}
+
+// src/string/snakeCase.ts
+function snakeCase(str) {
+  const words = splitWords(str);
+  let snakeCase2 = "";
+  for (const word of words) {
+    if (snakeCase2.length > 0) {
+      snakeCase2 += "_";
+    }
+    snakeCase2 += word.toLowerCase();
+  }
+  return snakeCase2;
+}
+
+// src/string/startCase.ts
+function startCase(str) {
+  const words = splitWords(str);
+  let startCase2 = "";
+  for (const word of words) {
+    startCase2 += word.charAt(0).toUpperCase() + word.slice(1).toLowerCase() + " ";
+  }
+  return startCase2.trimEnd();
+}
+
+// src/string/stripSpecialChars.ts
+function stripSpecialChars(str) {
+  str = deburr(str);
+  return str.replace(/[^\s\w]/gi, "");
+}
+
+// src/string/unescape.ts
+function unescapeHTML(html) {
+  const entityMap = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'"
+  };
+  return html.replace(/&(?:amp|#38|lt|#60|gt|#62|apos|#39|quot|#34);/g, (entity) => entityMap[entity] || entity);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  after,
+  before,
+  camelCase,
+  capitalize,
+  chunk,
+  countBy,
+  debounce,
+  deburr,
+  difference,
+  differenceBy,
+  differenceWith,
+  dropRightWhile,
+  dropWhile,
+  escape,
+  escapeRegExp,
+  groupBy,
+  intersection,
+  intersectionBy,
+  intersectionWith,
+  isEmpty,
+  isEqual,
+  isEqualWith,
+  isPlainObject,
+  kebabCase,
+  memoize,
+  once,
+  pascalCase,
+  pick,
+  sample,
+  sampleSize,
+  shuffle,
+  snakeCase,
+  sortBy,
+  startCase,
+  stripSpecialChars,
+  takeRightWhile,
+  takeWhile,
+  throttle,
+  times,
+  unescapeHTML,
+  uniq,
+  uniqBy,
+  uniqWith,
+  unzip,
+  unzipWith,
+  zip,
+  zipWith
+});
+//# sourceMappingURL=index.cjs.map