@stacksjs/strings 0.70.56 → 0.70.58

package/dist/case.js

@@ -0,0 +1,133 @@
+export function capitalize(str) {
+  return str[0] ? str[0].toUpperCase() + str.slice(1).toLowerCase() : "";
+}
+export function lowercase(str) {
+  return str.toLowerCase();
+}
+const SPLIT_LOWER_UPPER_RE = /([\p{Ll}\d])(\p{Lu})/gu, SPLIT_UPPER_UPPER_RE = /(\p{Lu})(\p{Lu}\p{Ll})/gu, SPLIT_SEPARATE_NUMBER_RE = /(\d)\p{Ll}|(\p{L})\d/u, DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu, SPLIT_REPLACE_VALUE = "$1\x00$2", DEFAULT_PREFIX_SUFFIX_CHARACTERS = "";
+export function split(value) {
+  let result = value.trim();
+  result = result.replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+  result = result.replace(DEFAULT_STRIP_REGEXP, "\x00");
+  let start = 0, end = result.length;
+  while (result.charAt(start) === "\x00")
+    start++;
+  if (start === end)
+    return [];
+  while (result.charAt(end - 1) === "\x00")
+    end--;
+  return result.slice(start, end).split(/\0/g);
+}
+export function splitSeparateNumbers(value) {
+  const words = split(value);
+  for (let i = 0;i < words.length; i++) {
+    const word = words[i];
+    if (word === void 0)
+      continue;
+    const match = SPLIT_SEPARATE_NUMBER_RE.exec(word);
+    if (match) {
+      const offset = match.index + (match[1] ?? match[2] ?? "").length;
+      words.splice(i, 1, word.slice(0, offset), word.slice(offset));
+    }
+  }
+  return words;
+}
+export function noCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+  return prefix + words.map(lowerFactory(options?.locale)).join(options?.delimiter ?? " ") + suffix;
+}
+export function camelCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options), lower = lowerFactory(options?.locale), upper = upperFactory(options?.locale), transform = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
+  return prefix + words.map((word, index) => {
+    if (index === 0)
+      return lower(word);
+    return transform(word, index);
+  }).join(options?.delimiter ?? "") + suffix;
+}
+export function pascalCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options), lower = lowerFactory(options?.locale), upper = upperFactory(options?.locale), transform = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
+  return prefix + words.map(transform).join(options?.delimiter ?? "") + suffix;
+}
+export function pascalSnakeCase(input, options) {
+  return capitalCase(input, { delimiter: "_", ...options });
+}
+export function capitalCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options), lower = lowerFactory(options?.locale), upper = upperFactory(options?.locale);
+  return prefix + words.map(capitalCaseTransformFactory(lower, upper)).join(options?.delimiter ?? " ") + suffix;
+}
+export function constantCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+  return prefix + words.map(upperFactory(options?.locale)).join(options?.delimiter ?? "_") + suffix;
+}
+export function dotCase(input, options) {
+  return noCase(input, { delimiter: ".", ...options });
+}
+export function kebabCase(input, options) {
+  return noCase(input, { delimiter: "-", ...options });
+}
+export function pathCase(input, options) {
+  return noCase(input, { delimiter: "/", ...options });
+}
+export function sentenceCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options), lower = lowerFactory(options?.locale), upper = upperFactory(options?.locale), transform = capitalCaseTransformFactory(lower, upper);
+  return prefix + words.map((word, index) => {
+    if (index === 0)
+      return transform(word);
+    return lower(word);
+  }).join(options?.delimiter ?? " ") + suffix;
+}
+export function snakeCase(input, options) {
+  return noCase(input, { delimiter: "_", ...options });
+}
+export function trainCase(input, options) {
+  return capitalCase(input, { delimiter: "-", ...options });
+}
+export function paramCase(input, options) {
+  return kebabCase(input, options);
+}
+function lowerFactory(locale) {
+  return locale === !1 ? (input) => input.toLowerCase() : (input) => input.toLocaleLowerCase(locale);
+}
+function upperFactory(locale) {
+  return locale === !1 ? (input) => input.toUpperCase() : (input) => input.toLocaleUpperCase(locale);
+}
+function capitalCaseTransformFactory(lower, upper) {
+  return (word) => {
+    if (!word)
+      return word;
+    return `${upper(word[0] ?? "")}${lower(word.slice(1))}`;
+  };
+}
+function pascalCaseTransformFactory(lower, upper) {
+  return (word, index) => {
+    if (!word)
+      return word;
+    const char0 = word[0] ?? "";
+    return (index > 0 && char0 >= "0" && char0 <= "9" ? `_${char0}` : upper(char0)) + lower(word.slice(1));
+  };
+}
+function splitPrefixSuffix(input, options = {}) {
+  const splitFn = options.split ?? split, prefixCharacters = options.prefixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS, suffixCharacters = options.suffixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+  let prefixIndex = 0, suffixIndex = input.length;
+  while (prefixIndex < input.length) {
+    const char = input.charAt(prefixIndex);
+    if (!prefixCharacters.includes(char))
+      break;
+    prefixIndex++;
+  }
+  while (suffixIndex > prefixIndex) {
+    const index = suffixIndex - 1, char = input.charAt(index);
+    if (!suffixCharacters.includes(char))
+      break;
+    suffixIndex = index;
+  }
+  return [
+    input.slice(0, prefixIndex),
+    splitFn(input.slice(prefixIndex, suffixIndex)),
+    input.slice(suffixIndex)
+  ];
+}
+
+export * from "./sponge-case";
+export * from "./swap-case";
+export * from "./title-case";

package/dist/detect-indent.js

@@ -0,0 +1,72 @@
+const INDENT_REGEX = /^(?:( )+|\t+)/, INDENT_TYPE_SPACE = "space", INDENT_TYPE_TAB = "tab";
+function makeIndentsMap(string, ignoreSingleSpaces = !0) {
+  const indents = new Map;
+  let previousSize = 0, previousIndentType, key = "";
+  for (const line of string.split(/\n/g)) {
+    if (!line)
+      continue;
+    let indent, indentType, use, weight, entry;
+    const matches = line.match(INDENT_REGEX);
+    if (matches === null) {
+      previousSize = 0;
+      previousIndentType = "";
+    } else {
+      indent = matches[0].length;
+      indentType = matches[1] ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
+      if (ignoreSingleSpaces && indentType === INDENT_TYPE_SPACE && indent === 1)
+        continue;
+      if (indentType !== previousIndentType)
+        previousSize = 0;
+      previousIndentType = indentType;
+      use = 1;
+      weight = 0;
+      const indentDifference = indent - previousSize;
+      previousSize = indent;
+      if (indentDifference === 0) {
+        use = 0;
+        weight = 1;
+      } else {
+        const absoluteIndentDifference = indentDifference > 0 ? indentDifference : -indentDifference;
+        key = encodeIndentsKey(indentType, absoluteIndentDifference);
+      }
+      entry = indents.get(key);
+      entry = entry === void 0 ? [1, 0] : [entry[0] + use, entry[1] + weight];
+      indents.set(key, entry);
+    }
+  }
+  return indents;
+}
+function encodeIndentsKey(indentType, indentAmount) {
+  return (indentType === INDENT_TYPE_SPACE ? "s" : "t") + String(indentAmount);
+}
+function decodeIndentsKey(indentsKey) {
+  const type = indentsKey[0] === "s" ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB, amount = Number(indentsKey.slice(1));
+  return { type, amount };
+}
+function getMostUsedKey(indents) {
+  let result, maxUsed = 0, maxWeight = 0;
+  for (const [key, [usedCount, weight]] of indents)
+    if (usedCount > maxUsed || usedCount === maxUsed && weight > maxWeight) {
+      maxUsed = usedCount;
+      maxWeight = weight;
+      result = key;
+    }
+  return result;
+}
+function makeIndentString(type, amount) {
+  return (type === INDENT_TYPE_SPACE ? " " : "\t").repeat(amount);
+}
+export function detectIndent(string) {
+  if (typeof string !== "string")
+    throw TypeError("Expected a string");
+  let indents = makeIndentsMap(string, !0);
+  if (indents.size === 0)
+    indents = makeIndentsMap(string, !1);
+  const keyOfMostUsedIndent = getMostUsedKey(indents), decoded = keyOfMostUsedIndent !== void 0 ? decodeIndentsKey(keyOfMostUsedIndent) : void 0, type = decoded?.type, amount = decoded?.amount ?? 0, indent = decoded ? makeIndentString(type, amount) : "";
+  return {
+    amount,
+    type,
+    indent
+  };
+}
+export default detectIndent;

package/dist/detect-newline.js

@@ -0,0 +1,16 @@
+export function detectNewline(string) {
+  if (typeof string !== "string")
+    throw TypeError("Expected a string");
+  const newlines = string.match(/\r?\n/g) || [];
+  if (newlines.length === 0)
+    return;
+  const crlf = newlines.filter((newline) => newline === `\r
+`).length, lf = newlines.length - crlf;
+  return crlf > lf ? `\r
+` : `
+`;
+}
+export function detectNewlineGraceful(string) {
+  return typeof string === "string" && detectNewline(string) || `
+`;
+}

package/dist/helpers.js

@@ -0,0 +1,15 @@
+export function toString(v) {
+  return Object.prototype.toString.call(v);
+}
+export function mask(value, character, index, length) {
+  if (character === "")
+    return value;
+  const len = value.length, start = index < 0 ? Math.max(0, len + index) : index;
+  if (start >= len)
+    return value;
+  const maskLen = length === void 0 ? len - start : Math.max(0, length);
+  if (maskLen === 0)
+    return value;
+  const end = Math.min(len, start + maskLen), fill = character.charAt(0).repeat(end - start);
+  return value.slice(0, start) + fill + value.slice(end);
+}