base-up/dist/index.js

A modern TypeScript utility library.

var __defProp = Object.defineProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};

// src/all.ts
var all_exports = {};
__export(all_exports, {
  allKeysOf: () => allKeysOf,
  assert: () => assert,
  assertEqual: () => assertEqual,
  assertInstanceOf: () => assertInstanceOf,
  assertNeverType: () => assertNeverType,
  assertTypeEquality: () => assertTypeEquality,
  call: () => call,
  capitalize: () => capitalize,
  cartesianProductOf: () => cartesianProductOf,
  chunk: () => chunk,
  clamp: () => clamp,
  createComparatorFromIsAtMost: () => createComparatorFromIsAtMost,
  createComparatorFromIsLessThan: () => createComparatorFromIsLessThan,
  createNGrams: () => createNGrams,
  curry: () => curry,
  differenceOf: () => differenceOf,
  drop: () => drop,
  dropLast: () => dropLast,
  elementAt: () => elementAt,
  equals: () => equals,
  every: () => every,
  everyIterable: () => everyIterable,
  factorialOf: () => factorialOf,
  filter: () => filter,
  firstOf: () => firstOf,
  flatMap: () => flatMap,
  flatten: () => flatten,
  forever: () => forever,
  fromEntries: () => fromEntries,
  getNestedProperty: () => getNestedProperty,
  getNextSequentialNumber: () => getNextSequentialNumber,
  groupBy: () => groupBy,
  has: () => has,
  identity: () => identity,
  includes: () => includes,
  indexOf: () => indexOf,
  indexesOf: () => indexesOf,
  insertAt: () => insertAt,
  intersectionOf: () => intersectionOf,
  isBigint: () => isBigint,
  isBoolean: () => isBoolean,
  isDisjoint: () => isDisjoint,
  isEmpty: () => isEmpty,
  isFalsy: () => isFalsy,
  isFixedLengthArray: () => isFixedLengthArray,
  isFunction: () => isFunction,
  isInIntegerRangeThrough: () => isInIntegerRangeThrough,
  isInIntegerRangeUntil: () => isInIntegerRangeUntil,
  isInstanceOf: () => isInstanceOf,
  isLexicographicAtMost: () => isLexicographicAtMost,
  isLexicographicLessThan: () => isLexicographicLessThan,
  isLowercaseLetter: () => isLowercaseLetter,
  isMaxLengthArray: () => isMaxLengthArray,
  isMinLengthArray: () => isMinLengthArray,
  isNotBigint: () => isNotBigint,
  isNotBoolean: () => isNotBoolean,
  isNotEmpty: () => isNotEmpty,
  isNotFunction: () => isNotFunction,
  isNotInstanceOf: () => isNotInstanceOf,
  isNotNull: () => isNotNull,
  isNotNullish: () => isNotNullish,
  isNotNumber: () => isNotNumber,
  isNotObject: () => isNotObject,
  isNotOneOf: () => isNotOneOf,
  isNotString: () => isNotString,
  isNotSymbol: () => isNotSymbol,
  isNotUndefined: () => isNotUndefined,
  isNull: () => isNull,
  isNullish: () => isNullish,
  isNumber: () => isNumber,
  isObject: () => isObject,
  isOneOf: () => isOneOf,
  isString: () => isString,
  isSubsetOf: () => isSubsetOf,
  isSymbol: () => isSymbol,
  isTruthy: () => isTruthy,
  isUndefined: () => isUndefined,
  isUnique: () => isUnique,
  isUppercaseLetter: () => isUppercaseLetter,
  join: () => join,
  lastIndexOf: () => lastIndexOf,
  lastOf: () => lastOf,
  map: () => map,
  mapOf: () => mapOf,
  maxBy: () => maxBy,
  maxOf: () => maxOf,
  merge: () => merge,
  minBy: () => minBy,
  minOf: () => minOf,
  modOf: () => modOf,
  modeBy: () => modeBy,
  modeOf: () => modeOf,
  moveTo: () => moveTo,
  omit: () => omit,
  padEnd: () => padEnd,
  padStart: () => padStart,
  partition: () => partition,
  permutationOf: () => permutationOf,
  pipe: () => pipe,
  prefixesOf: () => prefixesOf,
  push: () => push,
  randomIntegerThrough: () => randomIntegerThrough,
  randomIntegerUntil: () => randomIntegerUntil,
  remove: () => remove,
  removeAll: () => removeAll,
  removeAt: () => removeAt,
  removeDuplicates: () => removeDuplicates,
  removeDuplicatesBy: () => removeDuplicatesBy,
  removePrefix: () => removePrefix,
  removeSuffix: () => removeSuffix,
  repeat: () => repeat,
  repeatApply: () => repeatApply,
  reverse: () => reverse,
  sequentialNumbersThrough: () => sequentialNumbersThrough,
  sequentialNumbersUntil: () => sequentialNumbersUntil,
  setMembership: () => setMembership,
  setOf: () => setOf,
  shuffle: () => shuffle,
  some: () => some,
  someIterable: () => someIterable,
  sort: () => sort,
  sortBy: () => sortBy,
  split: () => split,
  splitIntoWords: () => splitIntoWords,
  sumOf: () => sumOf,
  take: () => take,
  takeWhile: () => takeWhile,
  toCamelCase: () => toCamelCase,
  toCamelCasedPropertiesDeeply: () => toCamelCasedPropertiesDeeply,
  toKebabCase: () => toKebabCase,
  toMultiset: () => toMultiset,
  toNumber: () => toNumber,
  toSnakeCase: () => toSnakeCase,
  toSnakeCasedPropertiesDeeply: () => toSnakeCasedPropertiesDeeply,
  toString: () => toString,
  toggleMembership: () => toggleMembership,
  trim: () => trim,
  trimEnd: () => trimEnd,
  trimStart: () => trimStart,
  unionOf: () => unionOf,
  uniqueRandomIntegersUntil: () => uniqueRandomIntegersUntil,
  unshift: () => unshift,
  zip: () => zip,
  zipAll: () => zipAll,
  zipWith: () => zipWith
});

// src/Array/FixedLengthArray.ts
function isFixedLengthArray(self, length) {
  return Array.isArray(self) && self.length === length;
}

// src/Array/MaxLengthArray.ts
function isMaxLengthArray(self, length) {
  return Array.isArray(self) && self.length <= length;
}

// src/Array/MinLengthArray.ts
function isMinLengthArray(self, length) {
  return Array.isArray(self) && self.length >= length;
}

// src/number/range.ts
function isInIntegerRangeUntil(value, n, m) {
  if (!Number.isInteger(n)) throw new TypeError(`${n} is not an integer`);
  if (!Number.isInteger(m)) throw new TypeError(`${m} is not an integer`);
  return Number.isInteger(value) && Math.min(n, m) <= value && value < Math.max(n, m);
}
function isInIntegerRangeThrough(value, n, m) {
  if (!Number.isInteger(n)) throw new TypeError(`${n} is not an integer`);
  if (!Number.isInteger(m)) throw new TypeError(`${m} is not an integer`);
  return Number.isInteger(value) && Math.min(n, m) <= value && value <= Math.max(n, m);
}
function randomIntegerUntil(first, second) {
  const [from, to] = second === void 0 ? [0, first] : [first, second];
  if (from === to) {
    throw RangeError(`The arguments of randomIntegerUntil are the same value(${to}).
Must be different values.`);
  }
  return Math.trunc(Math.random() * (to - from)) + from;
}
function randomIntegerThrough(first, second) {
  const from = second === void 0 ? 0 : first;
  const to = second === void 0 ? first : second;
  return Math.trunc(Math.random() * (to + 1 - from)) + from;
}

// src/Array/other.ts
function shuffle(self) {
  const result = [];
  for (let i = 0; i < self.length; ++i) {
    const j = randomIntegerThrough(i);
    if (j < i) {
      result.push(result[j]);
    }
    result[j] = self[i];
  }
  return result;
}

// src/collectionPredicate.ts
function isEmpty(self) {
  for (const _ of self) {
    return false;
  }
  return true;
}
function isNotEmpty(self) {
  for (const _ of self) {
    return true;
  }
  return false;
}
function every(self, f) {
  return self.every(f);
}
function some(self, f) {
  return self.some(f);
}
function everyIterable(self, f) {
  for (const value of self) {
    if (!f(value)) return false;
  }
  return true;
}
function someIterable(self, f) {
  for (const value of self) {
    if (f(value)) return true;
  }
  return false;
}
function includes(self, value, fromIndex) {
  return self.includes(value, fromIndex);
}
function isUnique(self) {
  const set = /* @__PURE__ */ new Set();
  for (const value of self) {
    if (set.has(value)) return false;
    set.add(value);
  }
  return true;
}

// src/collectionUpdate.ts
function push(self, ...args) {
  return [...self, ...args];
}
function unshift(self, ...args) {
  return [...args, ...self];
}
function insertAt(self, at, ...values) {
  const cloned = [...self];
  if (isInIntegerRangeThrough(at, 0, self.length)) {
    cloned.splice(at, 0, ...values);
  }
  return cloned;
}
function removeAt(self, i) {
  const cloned = [...self];
  if (isInIntegerRangeUntil(i, 0, self.length)) {
    cloned.splice(i, 1);
  }
  return cloned;
}
function removeAll(self, value) {
  return self.filter((x) => x !== value);
}
function remove(self, value) {
  const index = self.findIndex((x) => x !== value);
  const cloned = [...self];
  if (index === -1) return cloned;
  cloned.splice(index, 1);
  return cloned;
}
function removePrefix(self, prefix) {
  if (self.startsWith(prefix)) {
    return self.slice(prefix.length);
  }
  return self;
}
function removeSuffix(self, suffix) {
  if (self.endsWith(suffix)) {
    return self.slice(0, self.length - suffix.length);
  }
  return self;
}
function moveTo(self, from, to) {
  const cloned = [...self];
  if (isInIntegerRangeUntil(from, 0, self.length) && isInIntegerRangeUntil(to, 0, self.length)) {
    const [removed] = cloned.splice(from, 1);
    cloned.splice(to, 0, removed);
  }
  return cloned;
}

// src/filter.ts
function filter(self, f) {
  return self.filter(f);
}
function partition(self, f) {
  const matched = [];
  const unmatched = [];
  for (const value of self) {
    if (f(value)) {
      matched.push(value);
    } else {
      unmatched.push(value);
    }
  }
  return [matched, unmatched];
}
function take(self, n) {
  const result = [];
  const iterator = self[Symbol.iterator]();
  for (let element = iterator.next(); !element.done && result.length < n; element = iterator.next()) {
    result.push(element.value);
  }
  iterator.return?.();
  return result;
}
function drop(self, n = 1) {
  return self.slice(Math.max(n, 0));
}
function dropLast(self, n = 1) {
  return self.slice(0, Math.max(self.length - n, 0));
}
function takeWhile(self, f) {
  const result = [];
  for (const value of self) {
    if (!f(value)) return result;
    result.push(value);
  }
  return result;
}
function firstOf(self) {
  return self[0];
}
function lastOf(self) {
  return self[self.length - 1];
}
function indexOf(self, value, fromIndex) {
  const index = self.indexOf(value, fromIndex);
  if (index === -1) return void 0;
  return index;
}
function lastIndexOf(self, value, fromIndex) {
  const index = self.lastIndexOf(value, fromIndex);
  if (index === -1) return void 0;
  return index;
}
function indexesOf(self, value) {
  const result = [];
  for (let i = 0; i < self.length; i++) {
    if (self[i] === value) {
      result.push(i);
    }
  }
  return result;
}
function maxOf(self) {
  if (!isNotEmpty(self)) return void 0;
  const [firstElement, ...rest] = self;
  let candidateElement = firstElement;
  for (const element of rest) {
    if (candidateElement < element) {
      candidateElement = element;
    }
  }
  return candidateElement;
}
function maxBy(self, by) {
  if (!isNotEmpty(self)) return void 0;
  const [firstElement, ...rest] = self;
  let candidateElement = firstElement;
  let maxValue = by(firstElement);
  for (const element of rest) {
    const value = by(element);
    if (maxValue < value) {
      candidateElement = element;
      maxValue = value;
    }
  }
  return candidateElement;
}
function minOf(self) {
  if (!isNotEmpty(self)) return void 0;
  const [firstElement, ...rest] = self;
  let candidateElement = firstElement;
  for (const element of rest) {
    if (candidateElement > element) {
      candidateElement = element;
    }
  }
  return candidateElement;
}
function minBy(self, by) {
  if (!isNotEmpty(self)) return void 0;
  const [firstElement, ...rest] = self;
  let candidateElement = firstElement;
  let minValue = by(firstElement);
  for (const element of rest) {
    const value = by(element);
    if (minValue > value) {
      candidateElement = element;
      minValue = value;
    }
  }
  return candidateElement;
}
function elementAt(self, n) {
  const iterator = self[Symbol.iterator]();
  let i;
  let element;
  for (i = 0, element = iterator.next(); i < n && !element.done; ++i, element = iterator.next()) {
  }
  iterator.return?.();
  return element.value;
}
function modeOf(self) {
  const map2 = /* @__PURE__ */ new Map();
  let maxCount = 0;
  let candidateValue;
  for (const value of self) {
    const nextCount = (map2.get(value) ?? 0) + 1;
    if (maxCount < nextCount) {
      maxCount = nextCount;
      candidateValue = value;
    }
    map2.set(value, nextCount);
  }
  return candidateValue;
}
function modeBy(self, by) {
  const map2 = /* @__PURE__ */ new Map();
  let maxCount = 0;
  let candidateValue;
  for (const value of self) {
    const key = by(value);
    const nextCount = (map2.get(key) ?? 0) + 1;
    if (maxCount < nextCount) {
      maxCount = nextCount;
      candidateValue = value;
    }
    map2.set(key, nextCount);
  }
  return candidateValue;
}

// src/generate.ts
function getNextSequentialNumber() {
  return nextSequentialNumber++;
}
var nextSequentialNumber = 0;
function sequentialNumbersUntil(n, m) {
  const [from, to] = m === void 0 ? [0, n] : [n, m];
  const result = [];
  if (from < to) {
    for (let i = from; i < to; i++) {
      result.push(i);
    }
  } else {
    for (let i = from; i > to; i--) {
      result.push(i);
    }
  }
  return result;
}
function sequentialNumbersThrough(n, m) {
  const [from, to] = m === void 0 ? [0, n] : [n, m];
  const result = [];
  if (from < to) {
    for (let i = from; i <= to; i++) {
      result.push(i);
    }
  } else {
    for (let i = from; i >= to; i--) {
      result.push(i);
    }
  }
  return result;
}
function uniqueRandomIntegersUntil(upperBound, length) {
  return length / upperBound < 0.4 ? retryWhile(upperBound, length) : takeShuffle(upperBound, length);
}
function takeShuffle(upperBound, length) {
  return take(shuffle(sequentialNumbersUntil(upperBound)), length);
}
function retryWhile(upperBound, length) {
  const set = /* @__PURE__ */ new Set();
  const result = [];
  while (result.length < length) {
    const randomInteger = randomIntegerUntil(upperBound);
    if (!set.has(randomInteger)) {
      result.push(randomInteger);
      set.add(randomInteger);
    }
  }
  return result;
}
function repeat(count, ...values) {
  return Array.from({ length: count * values.length }, (_, i) => values[i % values.length]);
}
function repeatApply(length, first, f) {
  if (length === 0) return [];
  const result = [first];
  let value = first;
  for (let i = 1; i < length; i++) {
    value = f(value);
    result.push(value);
  }
  return result;
}
function fromEntries(entries) {
  return Object.fromEntries(entries);
}

// src/combination.ts
function cartesianProductOf(lhs, rhs) {
  const result = [];
  for (const lhsElement of lhs) {
    for (const rhsElement of rhs) {
      result.push([lhsElement, rhsElement]);
    }
  }
  return result;
}
function permutationOf(self, n = self.length) {
  if (n <= 0) return [[]];
  if (self.length <= 1) return [self];
  return sequentialNumbersUntil(self.length).flatMap((i) => {
    const value = self[i];
    return permutationOf(removeAt(self, i), n - 1).map((rest) => [value, ...rest]);
  });
}
function createNGrams(self, n) {
  const result = [];
  if (n < 0) throw new RangeError();
  if (n > self.length) return [];
  for (let i = 0; i + n - 1 < self.length; i++) {
    result.push(self.slice(i, i + n));
  }
  return result;
}
function prefixesOf(self) {
  const result = [[]];
  const prefixes = [];
  for (const element of self) {
    prefixes.push(element);
    result.push([...prefixes]);
  }
  return result;
}

// src/fusion.ts
function zip(...source) {
  const result = [];
  const length = Math.min(...source.map((array) => array.length));
  for (let i = 0; i < length; i++) {
    result.push(source.map((array) => array[i]));
  }
  return result;
}
function zipWith(f, ...source) {
  const result = [];
  const length = Math.min(...source.map((array) => array.length));
  for (let i = 0; i < length; i++) {
    result.push(f(...source.map((array) => array[i])));
  }
  return result;
}
function zipAll(...source) {
  const result = [];
  const length = Math.max(...source.map((array) => array.length));
  for (let i = 0; i < length; i++) {
    result.push(source.map((array) => array[i]));
  }
  return result;
}
function* zipAllIterable(...source) {
  const iterators = source.map((iterable) => iterable[Symbol.iterator]());
  for (let elements = iterators.map((iterator) => iterator.next()); elements.some((element) => !element.done); elements = iterators.map((iterator) => iterator.next())) {
    yield elements.map((element) => element.value);
  }
  iterators.map((iterator) => iterator.return?.());
}
function merge(lhs, rhs) {
  const result = [];
  const minLength = Math.min(lhs.length, rhs.length);
  for (let i = 0; i < minLength; ++i) {
    result.push(lhs[i], rhs[i]);
  }
  if (lhs.length === minLength) {
    result.push(...rhs.slice(minLength));
  } else {
    result.push(...lhs.slice(minLength));
  }
  return result;
}

// src/comparison.ts
function createComparatorFromIsLessThan(isLessThan) {
  return (lhs, rhs) => {
    if (isLessThan(lhs, rhs)) return -1;
    if (isLessThan(rhs, lhs)) return 1;
    return 0;
  };
}
function createComparatorFromIsAtMost(isAtMost) {
  return (lhs, rhs) => {
    if (isAtMost(lhs, rhs)) {
      if (isAtMost(rhs, lhs)) return 0;
      return -1;
    }
    return 1;
  };
}
function isLexicographicLessThan(lhs, rhs) {
  for (const [lhsElement, rhsElement] of zipAllIterable(lhs, rhs)) {
    if (lhsElement === void 0) return true;
    if (rhsElement === void 0) return false;
    if (lhsElement < rhsElement) return true;
    if (rhsElement < lhsElement) return false;
  }
  return false;
}
function isLexicographicAtMost(lhs, rhs) {
  for (const [lhsElement, rhsElement] of zipAllIterable(lhs, rhs)) {
    if (lhsElement === void 0) return true;
    if (rhsElement === void 0) return false;
    if (lhsElement < rhsElement) return true;
    if (rhsElement < lhsElement) return false;
  }
  return true;
}

// src/Function.ts
function curry(f) {
  return (h) => (...l) => f(h, ...l);
}
function call(f) {
  return f();
}
function identity(value) {
  return value;
}
function pipe(a, ...fs) {
  let value = a;
  for (const f of fs) {
    value = f(value);
  }
  return value;
}

// src/Map.ts
function mapOf(...args) {
  return new Map(args);
}

// src/number/compare.ts
function clamp(min, value, max) {
  return Math.max(min, Math.min(value, max));
}

// src/number/other.ts
var Infinity = globalThis.Number.POSITIVE_INFINITY;
var NegativeInfinity = globalThis.Number.NEGATIVE_INFINITY;
function modOf(a, b) {
  return (a % b + b) % b;
}
function factorialOf(n) {
  if (!Number.isInteger(n)) return Number.NaN;
  if (n < 0) return Number.NaN;
  let result = 1;
  for (let i = 2; i <= n; i++) {
    result *= i;
  }
  return result;
}

// src/object.ts
function omit(self, ...keys) {
  const result = {};
  for (const key in self) {
    if (!keys.includes(key)) {
      result[key] = self[key];
    }
  }
  return result;
}
function getNestedProperty(self, ...keys) {
  if (!isNotEmpty(keys)) return self;
  const firstKey = keys[0];
  if (firstKey in self) {
    return getNestedProperty(self[firstKey], ...drop(keys));
  }
  return void 0;
}

// src/other.ts
function groupBy(self, by) {
  const result = new globalThis.Map();
  for (const value of self) {
    const key = by(value);
    if (!result.get(key)?.push(value)) {
      result.set(key, [value]);
    }
  }
  return result;
}
function toMultiset(self) {
  const result = new globalThis.Map();
  for (const value of self) {
    const count = result.get(value) ?? 0;
    result.set(value, count + 1);
  }
  return result;
}
function sumOf(self) {
  return self.reduce((lhs, rhs) => lhs + rhs, 0);
}

// src/Promise.ts
var forever = new Promise(() => {
});

// src/projection.ts
function allKeysOf(objectLike) {
  const resultSet = /* @__PURE__ */ new Set();
  const resultArray = [];
  if (objectLike === null || objectLike === void 0) return resultArray;
  const basePrototype = Object.getPrototypeOf({});
  let current = objectLike;
  while (current !== basePrototype) {
    for (const ownPropertyName of Object.getOwnPropertyNames(current)) {
      if (ownPropertyName === "constructor") continue;
      if (!resultSet.has(ownPropertyName)) {
        resultSet.add(ownPropertyName);
        resultArray.push(ownPropertyName);
      }
    }
    for (const ownPropertySymbol of Object.getOwnPropertySymbols(current)) {
      if (!resultSet.has(ownPropertySymbol)) {
        resultSet.add(ownPropertySymbol);
        resultArray.push(ownPropertySymbol);
      }
    }
    current = Object.getPrototypeOf(current);
  }
  return resultArray;
}

// src/transform.ts
function map(self, f) {
  return self.map(f);
}
function flatMap(self, f) {
  return self.flatMap(f);
}
function flatten(self) {
  return self.flat();
}
function join(self, separator = ",") {
  return self.join(separator);
}
function split(self, separator) {
  if (self === "" && separator === "") {
    return [""];
  }
  return self.split(separator);
}
function chunk(array, size) {
  if (size <= 0) {
    throw RangeError(`Size(${size}) must be greater than 0.`);
  }
  const result = [];
  for (let i = 0; i + size <= array.length; i += size) {
    result.push(array.slice(i, i + size));
  }
  return result;
}
function padStart(self, length, value) {
  return self.padStart(length, value);
}
function padEnd(self, length, value) {
  return self.padEnd(length, value);
}
function sort(self) {
  return sortBy(self, identity);
}
function sortBy(self, by) {
  return [...self].sort(createComparatorFromIsLessThan((lhs, rhs) => by(lhs) < by(rhs)));
}
function reverse(self) {
  return [...self].reverse();
}
function removeDuplicates(self) {
  const set = /* @__PURE__ */ new Set();
  const result = [];
  for (const value of self) {
    if (!set.has(value)) {
      set.add(value);
      result.push(value);
    }
  }
  return result;
}
function removeDuplicatesBy(self, by) {
  const set = /* @__PURE__ */ new Set();
  const result = [];
  for (const value of self) {
    const temp = by(value);
    if (!set.has(temp)) {
      set.add(temp);
      result.push(value);
    }
  }
  return result;
}

// src/Set.ts
function setOf(...args) {
  return new Set(args);
}
function toggleMembership(self, value) {
  const cloned = new Set(self);
  if (cloned.has(value)) {
    cloned.delete(value);
  } else {
    cloned.add(value);
  }
  return cloned;
}
function setMembership(self, value, has2) {
  const cloned = new Set(self);
  if (has2) {
    cloned.add(value);
  } else {
    cloned.delete(value);
  }
  return cloned;
}
function has(self, value) {
  return self.has(value);
}
function unionOf(lhs, rhs) {
  const cloned = new Set(lhs);
  for (const value of rhs) {
    cloned.add(value);
  }
  return cloned;
}
function intersectionOf(lhs, rhs) {
  const result = /* @__PURE__ */ new Set();
  const [small, big] = sortBy([lhs, rhs], (set) => set.size);
  for (const value of small) {
    if (big.has(value)) {
      result.add(value);
    }
  }
  return result;
}
function differenceOf(lhs, rhs) {
  const cloned = new Set(lhs);
  for (const value of rhs) {
    cloned.delete(value);
  }
  return cloned;
}
function isDisjoint(lhs, rhs) {
  const [small, big] = sortBy([lhs, rhs], (set) => set.size);
  for (const value of small) {
    if (big.has(value)) {
      return false;
    }
  }
  return true;
}
function isSubsetOf(lhs, rhs) {
  return everyIterable(lhs, (element) => rhs.has(element));
}

// src/string/case.ts
function isUppercaseLetter(self) {
  return self.length === 1 && "A" <= self && self <= "Z";
}
function isLowercaseLetter(self) {
  return self.length === 1 && "a" <= self && self <= "z";
}
function capitalize(self) {
  if (self === "") return "";
  return self[0].toUpperCase() + self.slice(1);
}
function splitIntoWords(self, separators = ["-", "_", " "]) {
  const result = [];
  let current = self;
  let acc = "";
  while (current.length > 0) {
    if (current.length >= 2 && isLowercaseLetter(current[0]) && isUppercaseLetter(current[1])) {
      result.push(`${acc}${current[0]}`);
      acc = "";
      current = current.slice(1);
    } else if (current.length >= 2 && isUppercaseLetter(current[0]) && isLowercaseLetter(current[1])) {
      if (acc.length > 0) result.push(acc);
      acc = current[0];
      current = current.slice(1);
    } else {
      const matchedSeparator = separators.find((separator) => current.startsWith(separator));
      if (matchedSeparator !== void 0) {
        if (acc.length > 0) result.push(acc);
        acc = "";
        current = current.slice(matchedSeparator.length);
      } else {
        acc += current[0];
        current = current.slice(1);
      }
    }
  }
  if (acc.length > 0) result.push(acc);
  return result;
}
function toSnakeCase(self) {
  return splitIntoWords(self).join("_").toLowerCase();
}
function toKebabCase(self) {
  return splitIntoWords(self).join("-").toLowerCase();
}
function toCamelCase(self) {
  const [first, ...rest] = splitIntoWords(self);
  if (first === void 0) return "";
  return [first.toLowerCase(), ...rest.map((word) => capitalize(word.toLowerCase()))].join("");
}
function toSnakeCasedPropertiesDeeply(self) {
  if (Array.isArray(self)) {
    return self.map(toSnakeCasedPropertiesDeeply);
  }
  if (typeof self !== "object" || self === null) return self;
  const result = { ...self };
  for (const key of Object.keys(self)) {
    const snakeCase = toSnakeCase(key);
    const value = result[key];
    result[snakeCase] = toSnakeCasedPropertiesDeeply(value);
    if (key !== snakeCase) {
      delete result[key];
    }
  }
  return result;
}
function toCamelCasedPropertiesDeeply(self) {
  if (Array.isArray(self)) {
    return self.map(toCamelCasedPropertiesDeeply);
  }
  if (typeof self !== "object" || self === null) return self;
  const result = { ...self };
  for (const key of Object.keys(self)) {
    const camelCase = toCamelCase(key);
    const value = result[key];
    result[camelCase] = toCamelCasedPropertiesDeeply(value);
    if (key !== camelCase) {
      delete result[key];
    }
  }
  return result;
}

// src/string/other.ts
function toNumber(text) {
  return Number(text);
}
function toString(value) {
  return String(value);
}
function trimStart(self) {
  return self.trimStart();
}
function trimEnd(self) {
  return self.trimEnd();
}
function trim(self) {
  return self.trim();
}

// src/type.ts
function assertTypeEquality(..._) {
}
function assert(value, predicate) {
  if (!predicate(value)) {
    throw new Error();
  }
}
function assertEqual(lhs, rhs) {
  if (lhs !== rhs) {
    throw new Error(`Assertion failed: ${lhs} is not equal to ${rhs}.`);
  }
}
function assertInstanceOf(value, ctor) {
  if (!(value instanceof ctor)) {
    throw new TypeError(`Assertion failed: ${value} is not an instance of ${ctor.name}.`);
  }
}
function assertNeverType(mustBeNever) {
  throw new TypeError(`Assertion failed: ${mustBeNever} is not never type.`);
}

// src/typePredicate.ts
function equals(self, other) {
  return self === other;
}
function isOneOf(self, ...values) {
  return new Set(values).has(self);
}
function isNotOneOf(self, ...values) {
  return !new Set(values).has(self);
}
var isNull = (value) => value === null;
var isUndefined = (value) => value === void 0;
var isNullish = (value) => value === null || value === void 0;
var isBoolean = (value) => typeof value === "boolean";
var isNumber = (value) => typeof value === "number";
var isBigint = (value) => typeof value === "bigint";
var isString = (value) => typeof value === "string";
var isSymbol = (value) => typeof value === "symbol";
var isFunction = (value) => typeof value === "function";
var isObject = (value) => typeof value === "object";
var isNotNull = (value) => value !== null;
var isNotUndefined = (value) => value !== void 0;
var isNotNullish = (value) => value !== null && value !== void 0;
var isNotBoolean = (value) => typeof value !== "boolean";
var isNotNumber = (value) => typeof value !== "number";
var isNotBigint = (value) => typeof value !== "bigint";
var isNotString = (value) => typeof value !== "string";
var isNotSymbol = (value) => typeof value !== "symbol";
var isNotFunction = (value) => typeof value !== "function";
var isNotObject = (value) => typeof value !== "object";
function isTruthy(value) {
  return Boolean(value);
}
function isFalsy(value) {
  return !value;
}
function isInstanceOf(value, ctor) {
  return value instanceof ctor;
}
function isNotInstanceOf(value, ctor) {
  return !(value instanceof ctor);
}
export {
  all_exports as _,
  allKeysOf,
  assert,
  assertEqual,
  assertInstanceOf,
  assertNeverType,
  assertTypeEquality,
  call,
  capitalize,
  cartesianProductOf,
  chunk,
  clamp,
  createComparatorFromIsAtMost,
  createComparatorFromIsLessThan,
  createNGrams,
  curry,
  differenceOf,
  drop,
  dropLast,
  elementAt,
  equals,
  every,
  everyIterable,
  factorialOf,
  filter,
  firstOf,
  flatMap,
  flatten,
  forever,
  fromEntries,
  getNestedProperty,
  getNextSequentialNumber,
  groupBy,
  has,
  identity,
  includes,
  indexOf,
  indexesOf,
  insertAt,
  intersectionOf,
  isBigint,
  isBoolean,
  isDisjoint,
  isEmpty,
  isFalsy,
  isFixedLengthArray,
  isFunction,
  isInIntegerRangeThrough,
  isInIntegerRangeUntil,
  isInstanceOf,
  isLexicographicAtMost,
  isLexicographicLessThan,
  isLowercaseLetter,
  isMaxLengthArray,
  isMinLengthArray,
  isNotBigint,
  isNotBoolean,
  isNotEmpty,
  isNotFunction,
  isNotInstanceOf,
  isNotNull,
  isNotNullish,
  isNotNumber,
  isNotObject,
  isNotOneOf,
  isNotString,
  isNotSymbol,
  isNotUndefined,
  isNull,
  isNullish,
  isNumber,
  isObject,
  isOneOf,
  isString,
  isSubsetOf,
  isSymbol,
  isTruthy,
  isUndefined,
  isUnique,
  isUppercaseLetter,
  join,
  lastIndexOf,
  lastOf,
  map,
  mapOf,
  maxBy,
  maxOf,
  merge,
  minBy,
  minOf,
  modOf,
  modeBy,
  modeOf,
  moveTo,
  omit,
  padEnd,
  padStart,
  partition,
  permutationOf,
  pipe,
  prefixesOf,
  push,
  randomIntegerThrough,
  randomIntegerUntil,
  remove,
  removeAll,
  removeAt,
  removeDuplicates,
  removeDuplicatesBy,
  removePrefix,
  removeSuffix,
  repeat,
  repeatApply,
  reverse,
  sequentialNumbersThrough,
  sequentialNumbersUntil,
  setMembership,
  setOf,
  shuffle,
  some,
  someIterable,
  sort,
  sortBy,
  split,
  splitIntoWords,
  sumOf,
  take,
  takeWhile,
  toCamelCase,
  toCamelCasedPropertiesDeeply,
  toKebabCase,
  toMultiset,
  toNumber,
  toSnakeCase,
  toSnakeCasedPropertiesDeeply,
  toString,
  toggleMembership,
  trim,
  trimEnd,
  trimStart,
  unionOf,
  uniqueRandomIntegersUntil,
  unshift,
  zip,
  zipAll,
  zipWith
};