@mobily/ts-belt/dist/esm/String/index.js

🔧 Fast, modern, and practical utility library for FP in TypeScript.

// node_modules/rescript/lib/es6/caml_option.js
function some(x) {
  if (x === void 0) {
    return {
      BS_PRIVATE_NESTED_SOME_NONE: 0
    };
  } else if (x !== null && x.BS_PRIVATE_NESTED_SOME_NONE !== void 0) {
    return {
      BS_PRIVATE_NESTED_SOME_NONE: x.BS_PRIVATE_NESTED_SOME_NONE + 1 | 0
    };
  } else {
    return x;
  }
}
function undefined_to_opt(x) {
  if (x === void 0) {
    return;
  } else {
    return some(x);
  }
}
function null_to_opt(x) {
  if (x === null) {
    return;
  } else {
    return some(x);
  }
}

// node_modules/rescript/lib/es6/belt_Array.js
function makeByU(l, f) {
  if (l <= 0) {
    return [];
  }
  var res = new Array(l);
  for (var i = 0; i < l; ++i) {
    res[i] = f(i);
  }
  return res;
}
function reduceWithIndexU(a, x, f) {
  var r = x;
  for (var i = 0, i_finish = a.length; i < i_finish; ++i) {
    r = f(r, a[i], i);
  }
  return r;
}

// src/String/String.bs.js
function placeholder(param) {
}
function make(value) {
  return String(value);
}
function length(str) {
  return str.length;
}
function _concat(str, appendValue) {
  return str.concat(appendValue);
}
function concat() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _concat(data, args[0]);
    };
  }
  return _concat(arguments[0], arguments[1]);
}
function _append(str, appendValue) {
  return str.concat(appendValue);
}
function append() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _append(data, args[0]);
    };
  }
  return _append(arguments[0], arguments[1]);
}
function _prepend(str, prependValue) {
  return prependValue.concat(str);
}
function prepend() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _prepend(data, args[0]);
    };
  }
  return _prepend(arguments[0], arguments[1]);
}
function _slice(str, start, end) {
  return str.slice(start, end);
}
function slice() {
  if (arguments.length === 2) {
    const args = arguments;
    return function fn(data) {
      return _slice(data, args[0], args[1]);
    };
  }
  return _slice(arguments[0], arguments[1], arguments[2]);
}
function _sliceToEnd(str, start) {
  return str.slice(start);
}
function sliceToEnd() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _sliceToEnd(data, args[0]);
    };
  }
  return _sliceToEnd(arguments[0], arguments[1]);
}
function toLowerCase(str) {
  return str.toLowerCase();
}
function toUpperCase(str) {
  return str.toUpperCase();
}
function trim(str) {
  return str.trim();
}
function trimStart(str) {
  return str.trimStart();
}
function trimEnd(str) {
  return str.trimEnd();
}
function isEmpty(str) {
  return str.length === 0;
}
function isNotEmpty(str) {
  return str.length > 0;
}
function _split(str, delimiter) {
  return str.split(delimiter);
}
function split() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _split(data, args[0]);
    };
  }
  return _split(arguments[0], arguments[1]);
}
function _splitByRe(str, regex) {
  return str.split(regex);
}
function splitByRe() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _splitByRe(data, args[0]);
    };
  }
  return _splitByRe(arguments[0], arguments[1]);
}
function _splitAt(str, index) {
  return [
    str.slice(0, index),
    str.slice(index)
  ];
}
function splitAt() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _splitAt(data, args[0]);
    };
  }
  return _splitAt(arguments[0], arguments[1]);
}
function _includes(str, searchValue) {
  return str.includes(searchValue);
}
function includes() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _includes(data, args[0]);
    };
  }
  return _includes(arguments[0], arguments[1]);
}
function _replace(str, oldValue, newValue) {
  return str.replace(oldValue, newValue);
}
function replace() {
  if (arguments.length === 2) {
    const args = arguments;
    return function fn(data) {
      return _replace(data, args[0], args[1]);
    };
  }
  return _replace(arguments[0], arguments[1], arguments[2]);
}
function _replaceAll(str, oldValue, newValue) {
  var xs = str.split(oldValue);
  return reduceWithIndexU(xs, "", function(acc, str2, index) {
    var value = index < (xs.length - 1 | 0) ? str2.concat(newValue) : str2;
    return acc.concat(value);
  });
}
function replaceAll() {
  if (arguments.length === 2) {
    const args = arguments;
    return function fn(data) {
      return _replaceAll(data, args[0], args[1]);
    };
  }
  return _replaceAll(arguments[0], arguments[1], arguments[2]);
}
function _replaceByRe(str, regex, value) {
  return str.replace(regex, value);
}
function replaceByRe() {
  if (arguments.length === 2) {
    const args = arguments;
    return function fn(data) {
      return _replaceByRe(data, args[0], args[1]);
    };
  }
  return _replaceByRe(arguments[0], arguments[1], arguments[2]);
}
function _remove(str, value) {
  return str.replace(value, "");
}
function remove() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _remove(data, args[0]);
    };
  }
  return _remove(arguments[0], arguments[1]);
}
function _removeAll(str, value) {
  return replaceAll(str, value, "");
}
function removeAll() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _removeAll(data, args[0]);
    };
  }
  return _removeAll(arguments[0], arguments[1]);
}
function _search(str, regex) {
  var index = str.search(regex);
  if (index < 0) {
    return;
  } else {
    return index;
  }
}
function search() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _search(data, args[0]);
    };
  }
  return _search(arguments[0], arguments[1]);
}
function _match(str, regex) {
  return null_to_opt(str.match(regex));
}
function match() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _match(data, args[0]);
    };
  }
  return _match(arguments[0], arguments[1]);
}
function _repeat(str, n) {
  return str.repeat(n);
}
function repeat() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _repeat(data, args[0]);
    };
  }
  return _repeat(arguments[0], arguments[1]);
}
function _indexOf(str, searchValue) {
  var index = str.indexOf(searchValue);
  if (index < 0) {
    return;
  } else {
    return index;
  }
}
function indexOf() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _indexOf(data, args[0]);
    };
  }
  return _indexOf(arguments[0], arguments[1]);
}
function _lastIndexOf(str, searchValue) {
  var index = str.lastIndexOf(searchValue);
  if (index < 0) {
    return;
  } else {
    return index;
  }
}
function lastIndexOf() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _lastIndexOf(data, args[0]);
    };
  }
  return _lastIndexOf(arguments[0], arguments[1]);
}
function _endsWith(str, substr) {
  return str.endsWith(substr);
}
function endsWith() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _endsWith(data, args[0]);
    };
  }
  return _endsWith(arguments[0], arguments[1]);
}
function _startsWith(str, substr) {
  return str.startsWith(substr);
}
function startsWith() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _startsWith(data, args[0]);
    };
  }
  return _startsWith(arguments[0], arguments[1]);
}
function _getUnsafe(str, n) {
  return str[n];
}
function getUnsafe() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _getUnsafe(data, args[0]);
    };
  }
  return _getUnsafe(arguments[0], arguments[1]);
}
function _get(str, n) {
  return undefined_to_opt(str[n]);
}
function get() {
  if (arguments.length === 1) {
    const args = arguments;
    return function fn(data) {
      return _get(data, args[0]);
    };
  }
  return _get(arguments[0], arguments[1]);
}
function toArray(str) {
  return makeByU(str.length, function(index) {
    return str[index];
  });
}
function head(str) {
  return undefined_to_opt(str[0]);
}
function last(str) {
  var n = str.length - 1 | 0;
  return undefined_to_opt(str[n]);
}
export {
  append,
  concat,
  endsWith,
  get,
  getUnsafe,
  head,
  includes,
  indexOf,
  isEmpty,
  isNotEmpty,
  last,
  lastIndexOf,
  length,
  make,
  match,
  placeholder,
  prepend,
  remove,
  removeAll,
  repeat,
  replace,
  replaceAll,
  replaceByRe,
  search,
  slice,
  sliceToEnd,
  split,
  splitAt,
  splitByRe,
  startsWith,
  toArray,
  toLowerCase,
  toUpperCase,
  trim,
  trimEnd,
  trimStart
};