@nyaomaru/divider 1.5.0 → 1.5.2

package/dist/index.cjs

@@ -0,0 +1,193 @@
+"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 index_exports = {};
+__export(index_exports, {
+  divider: () => divider,
+  dividerFirst: () => dividerFirst,
+  dividerLast: () => dividerLast,
+  dividerLoop: () => dividerLoop
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/is.ts
+var isString = (arg) => typeof arg === "string";
+var isNumber = (arg) => typeof arg === "number";
+function isOptions(arg) {
+  return typeof arg === "object" && arg !== null && "flatten" in arg;
+}
+function isEmptyArray(input) {
+  return Array.isArray(input) && input.length === 0;
+}
+function isPositiveInteger(value) {
+  return Number.isInteger(value) && value > 0;
+}
+function isValidInput(input) {
+  return isString(input) || Array.isArray(input) && input.every(isString);
+}
+
+// src/utils/regex.ts
+var regexCache = /* @__PURE__ */ new Map();
+function getRegex(separators) {
+  if (isEmptyArray(separators)) return null;
+  const key = JSON.stringify(separators);
+  if (!regexCache.has(key)) {
+    const pattern = separators.reduce(
+      (acc, sep) => acc + escapeRegExp(sep),
+      ""
+    );
+    regexCache.set(key, new RegExp(`[${pattern}]`, "g"));
+  }
+  return regexCache.get(key);
+}
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/utils/slice.ts
+function sliceByIndexes(input, indexes) {
+  if (isEmptyArray(indexes)) return [input];
+  const parts = [];
+  let start = 0;
+  for (const index of indexes) {
+    if (index <= start || input.length <= index) continue;
+    parts.push(input.slice(start, index));
+    start = index;
+  }
+  if (start < input.length) {
+    parts.push(input.slice(start));
+  }
+  return parts;
+}
+
+// src/utils/sort.ts
+function sortAscending(numbers) {
+  return [...numbers].sort((a, b) => a - b);
+}
+
+// src/core/parser.ts
+function divideString(input, numSeparators, strSeparators) {
+  if (isEmptyArray(numSeparators) && isEmptyArray(strSeparators)) {
+    return [input];
+  }
+  const regex = getRegex(strSeparators);
+  const sortedNumSeparators = sortAscending(numSeparators);
+  const parts = sliceByIndexes(input, sortedNumSeparators);
+  return regex ? parts.flatMap((part) => part.split(regex)).filter(Boolean) : parts;
+}
+
+// src/utils/array.ts
+function ensureArray(input) {
+  return Array.isArray(input) ? input : [input];
+}
+
+// src/utils/options.ts
+function extractOptions(args) {
+  const clonedArgs = [...args];
+  const lastArg = clonedArgs.at(-1);
+  const options = isOptions(lastArg) ? (clonedArgs.pop(), lastArg) : {};
+  const cleanedArgs = clonedArgs.filter(
+    (arg) => isString(arg) || isNumber(arg)
+  );
+  return {
+    cleanedArgs,
+    options
+  };
+}
+
+// src/utils/separator.ts
+function classifySeparators(args) {
+  return args.reduce(
+    (acc, arg) => {
+      if (isNumber(arg)) acc.numSeparators.push(arg);
+      else if (isString(arg)) acc.strSeparators.push(arg);
+      return acc;
+    },
+    { numSeparators: [], strSeparators: [] }
+  );
+}
+
+// src/core/divider.ts
+function divider(input, ...args) {
+  if (!isValidInput(input)) {
+    console.warn(
+      "divider: 'input' must be a string or an array of strings. So returning an empty array."
+    );
+    return [];
+  }
+  if (isEmptyArray(args)) {
+    return ensureArray(input);
+  }
+  const { cleanedArgs, options } = extractOptions(args);
+  const { numSeparators, strSeparators } = classifySeparators(cleanedArgs);
+  if (isString(input)) {
+    return divideString(input, numSeparators, strSeparators);
+  }
+  const result = input.map(
+    (item) => divideString(item, numSeparators, strSeparators)
+  );
+  return options.flatten ? result.flat() : result;
+}
+
+// src/core/divider-first.ts
+function dividerFirst(input, ...args) {
+  const result = divider(input, ...args, { flatten: true });
+  return result[0] ?? "";
+}
+
+// src/core/divider-last.ts
+function dividerLast(input, ...args) {
+  const result = divider(input, ...args, { flatten: true });
+  return result.at(-1) ?? "";
+}
+
+// src/utils/chunk.ts
+function generateIndexes(text, size) {
+  const indexes = [];
+  for (let i = size; i < text.length; i += size) {
+    indexes.push(i);
+  }
+  return indexes;
+}
+
+// src/core/divider-loop.ts
+function dividerLoop(input, size, options) {
+  if (!isPositiveInteger(size)) {
+    console.warn("dividerLoop: chunk size must be a positive number");
+    return [];
+  }
+  if (isString(input)) {
+    const indexes = generateIndexes(input, size);
+    return divider(input, ...indexes);
+  }
+  const result = input.map((item) => {
+    const indexes = generateIndexes(item, size);
+    return divider(item, ...indexes);
+  });
+  const flatten = options?.flatten ?? false;
+  return flatten ? result.flat() : result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  divider,
+  dividerFirst,
+  dividerLast,
+  dividerLoop
+});

package/dist/index.d.cts

@@ -0,0 +1,16 @@
+type DividerResult<T extends string | string[], F extends boolean = false> = T extends string ? string[] : F extends true ? string[] : string[][];
+type DividerOptions<F extends boolean> = {
+    flatten?: F;
+};
+type DividerSeparators = (number | string)[];
+type DividerArgs<F extends boolean> = DividerSeparators | [...DividerSeparators, DividerOptions<F>];
+
+declare function divider<T extends string | string[], F extends boolean>(input: T, ...args: DividerArgs<F>): DividerResult<T, F>;
+
+declare function dividerFirst(input: string | string[], ...args: DividerSeparators): string;
+
+declare function dividerLast(input: string | string[], ...args: DividerSeparators): string;
+
+declare function dividerLoop<T extends string | string[], F extends boolean>(input: T, size: number, options?: DividerOptions<F>): DividerResult<T, F>;
+
+export { type DividerResult, divider, dividerFirst, dividerLast, dividerLoop };

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+type DividerResult<T extends string | string[], F extends boolean = false> = T extends string ? string[] : F extends true ? string[] : string[][];
+type DividerOptions<F extends boolean> = {
+    flatten?: F;
+};
+type DividerSeparators = (number | string)[];
+type DividerArgs<F extends boolean> = DividerSeparators | [...DividerSeparators, DividerOptions<F>];
+
+declare function divider<T extends string | string[], F extends boolean>(input: T, ...args: DividerArgs<F>): DividerResult<T, F>;
+
+declare function dividerFirst(input: string | string[], ...args: DividerSeparators): string;
+
+declare function dividerLast(input: string | string[], ...args: DividerSeparators): string;
+
+declare function dividerLoop<T extends string | string[], F extends boolean>(input: T, size: number, options?: DividerOptions<F>): DividerResult<T, F>;
+
+export { type DividerResult, divider, dividerFirst, dividerLast, dividerLoop };

package/dist/index.js

@@ -0,0 +1,163 @@
+// src/utils/is.ts
+var isString = (arg) => typeof arg === "string";
+var isNumber = (arg) => typeof arg === "number";
+function isOptions(arg) {
+  return typeof arg === "object" && arg !== null && "flatten" in arg;
+}
+function isEmptyArray(input) {
+  return Array.isArray(input) && input.length === 0;
+}
+function isPositiveInteger(value) {
+  return Number.isInteger(value) && value > 0;
+}
+function isValidInput(input) {
+  return isString(input) || Array.isArray(input) && input.every(isString);
+}
+
+// src/utils/regex.ts
+var regexCache = /* @__PURE__ */ new Map();
+function getRegex(separators) {
+  if (isEmptyArray(separators)) return null;
+  const key = JSON.stringify(separators);
+  if (!regexCache.has(key)) {
+    const pattern = separators.reduce(
+      (acc, sep) => acc + escapeRegExp(sep),
+      ""
+    );
+    regexCache.set(key, new RegExp(`[${pattern}]`, "g"));
+  }
+  return regexCache.get(key);
+}
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/utils/slice.ts
+function sliceByIndexes(input, indexes) {
+  if (isEmptyArray(indexes)) return [input];
+  const parts = [];
+  let start = 0;
+  for (const index of indexes) {
+    if (index <= start || input.length <= index) continue;
+    parts.push(input.slice(start, index));
+    start = index;
+  }
+  if (start < input.length) {
+    parts.push(input.slice(start));
+  }
+  return parts;
+}
+
+// src/utils/sort.ts
+function sortAscending(numbers) {
+  return [...numbers].sort((a, b) => a - b);
+}
+
+// src/core/parser.ts
+function divideString(input, numSeparators, strSeparators) {
+  if (isEmptyArray(numSeparators) && isEmptyArray(strSeparators)) {
+    return [input];
+  }
+  const regex = getRegex(strSeparators);
+  const sortedNumSeparators = sortAscending(numSeparators);
+  const parts = sliceByIndexes(input, sortedNumSeparators);
+  return regex ? parts.flatMap((part) => part.split(regex)).filter(Boolean) : parts;
+}
+
+// src/utils/array.ts
+function ensureArray(input) {
+  return Array.isArray(input) ? input : [input];
+}
+
+// src/utils/options.ts
+function extractOptions(args) {
+  const clonedArgs = [...args];
+  const lastArg = clonedArgs.at(-1);
+  const options = isOptions(lastArg) ? (clonedArgs.pop(), lastArg) : {};
+  const cleanedArgs = clonedArgs.filter(
+    (arg) => isString(arg) || isNumber(arg)
+  );
+  return {
+    cleanedArgs,
+    options
+  };
+}
+
+// src/utils/separator.ts
+function classifySeparators(args) {
+  return args.reduce(
+    (acc, arg) => {
+      if (isNumber(arg)) acc.numSeparators.push(arg);
+      else if (isString(arg)) acc.strSeparators.push(arg);
+      return acc;
+    },
+    { numSeparators: [], strSeparators: [] }
+  );
+}
+
+// src/core/divider.ts
+function divider(input, ...args) {
+  if (!isValidInput(input)) {
+    console.warn(
+      "divider: 'input' must be a string or an array of strings. So returning an empty array."
+    );
+    return [];
+  }
+  if (isEmptyArray(args)) {
+    return ensureArray(input);
+  }
+  const { cleanedArgs, options } = extractOptions(args);
+  const { numSeparators, strSeparators } = classifySeparators(cleanedArgs);
+  if (isString(input)) {
+    return divideString(input, numSeparators, strSeparators);
+  }
+  const result = input.map(
+    (item) => divideString(item, numSeparators, strSeparators)
+  );
+  return options.flatten ? result.flat() : result;
+}
+
+// src/core/divider-first.ts
+function dividerFirst(input, ...args) {
+  const result = divider(input, ...args, { flatten: true });
+  return result[0] ?? "";
+}
+
+// src/core/divider-last.ts
+function dividerLast(input, ...args) {
+  const result = divider(input, ...args, { flatten: true });
+  return result.at(-1) ?? "";
+}
+
+// src/utils/chunk.ts
+function generateIndexes(text, size) {
+  const indexes = [];
+  for (let i = size; i < text.length; i += size) {
+    indexes.push(i);
+  }
+  return indexes;
+}
+
+// src/core/divider-loop.ts
+function dividerLoop(input, size, options) {
+  if (!isPositiveInteger(size)) {
+    console.warn("dividerLoop: chunk size must be a positive number");
+    return [];
+  }
+  if (isString(input)) {
+    const indexes = generateIndexes(input, size);
+    return divider(input, ...indexes);
+  }
+  const result = input.map((item) => {
+    const indexes = generateIndexes(item, size);
+    return divider(item, ...indexes);
+  });
+  const flatten = options?.flatten ?? false;
+  return flatten ? result.flat() : result;
+}
+export {
+  divider,
+  dividerFirst,
+  dividerLast,
+  dividerLoop
+};

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "@nyaomaru/divider",
   "type": "module",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "description": "To divide string or string[] with a given separator",
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
-  "types": "dist/types/index.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
   "exports": {
-    "import": "./dist/esm/index.js",
-    "require": "./dist/cjs/index.js",
-    "types": "./dist/types/index.d.ts"
+    "import": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "require": {
+      "types": "./dist/index.d.cts",
+      "default": "./dist/index.cjs"
+    }
   },
   "keywords": [
     "divider",
@@ -41,6 +45,8 @@
     "prettier": "^3.5.1",
     "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2",
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.3",
     "typescript": "^5.7.3"
   },
   "engines": {
@@ -53,6 +59,6 @@
   "scripts": {
     "test": "jest",
     "lint": "eslint .",
-    "build": "tsc --project tsconfig.json && tsc --project tsconfig.cjs.json"
+    "build": "tsup"
   }
 }

package/dist/cjs/core/divider-first.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dividerFirst = dividerFirst;
-const divider_1 = require("@/core/divider");
-function dividerFirst(input, ...args) {
-    var _a;
-    const result = (0, divider_1.divider)(input, ...args, { flatten: true });
-    return (_a = result[0]) !== null && _a !== void 0 ? _a : '';
-}

package/dist/cjs/core/divider-last.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dividerLast = dividerLast;
-const divider_1 = require("@/core/divider");
-function dividerLast(input, ...args) {
-    var _a;
-    const result = (0, divider_1.divider)(input, ...args, { flatten: true });
-    return (_a = result.at(-1)) !== null && _a !== void 0 ? _a : '';
-}

package/dist/cjs/core/divider-loop.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dividerLoop = dividerLoop;
-const is_1 = require("@/utils/is");
-const chunk_1 = require("@/utils/chunk");
-const divider_1 = require("@/core/divider");
-function dividerLoop(input, size, options) {
-    var _a;
-    if (!(0, is_1.isPositiveInteger)(size)) {
-        console.warn('dividerLoop: chunk size must be a positive number');
-        return [];
-    }
-    if ((0, is_1.isString)(input)) {
-        const indexes = (0, chunk_1.generateIndexes)(input, size);
-        return (0, divider_1.divider)(input, ...indexes);
-    }
-    const result = input.map((item) => {
-        const indexes = (0, chunk_1.generateIndexes)(item, size);
-        return (0, divider_1.divider)(item, ...indexes);
-    });
-    const flatten = (_a = options === null || options === void 0 ? void 0 : options.flatten) !== null && _a !== void 0 ? _a : false;
-    return (flatten ? result.flat() : result);
-}

package/dist/cjs/core/divider-number-string.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dividerNumberString = dividerNumberString;
-const is_1 = require("@/utils/is");
-function dividerNumberString(input, options) {
-    const regex = /\d+|\D+/g;
-    const divide = (str) => {
-        return (str.match(regex) || []).filter(Boolean);
-    };
-    if ((0, is_1.isString)(input)) {
-        return divide(input);
-    }
-    const result = input.map(divide);
-    return ((options === null || options === void 0 ? void 0 : options.flatten) ? result.flat() : result);
-}

package/dist/cjs/core/divider.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.divider = divider;
-const parser_1 = require("@/core/parser");
-const is_1 = require("@/utils/is");
-const array_1 = require("@/utils/array");
-function divider(input, ...args) {
-    if (!(0, is_1.isString)(input) && !Array.isArray(input)) {
-        console.warn("divider: 'input' must be a string or an array of strings. So returning an empty array.");
-        return [];
-    }
-    if ((0, is_1.isEmptyArray)(args)) {
-        return (0, array_1.ensureArray)(input);
-    }
-    // Extract the options from the input
-    const clonedArgs = [...args];
-    const lastArg = clonedArgs.at(-1);
-    const options = (0, is_1.isOptions)(lastArg) ? (clonedArgs.pop(), lastArg) : {};
-    // Filter out only numbers and strings
-    const { numSeparators, strSeparators } = clonedArgs.reduce((acc, arg) => {
-        if ((0, is_1.isNumber)(arg)) {
-            acc.numSeparators.push(arg);
-        }
-        else if ((0, is_1.isString)(arg)) {
-            acc.strSeparators.push(arg);
-        }
-        return acc;
-    }, { numSeparators: [], strSeparators: [] });
-    if ((0, is_1.isString)(input)) {
-        return (0, parser_1.divideString)(input, numSeparators, strSeparators);
-    }
-    const result = input.map((item) => (0, parser_1.divideString)(item, numSeparators, strSeparators));
-    return (options.flatten ? result.flat() : result);
-}

package/dist/cjs/core/parser.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.divideString = divideString;
-const is_1 = require("@/utils/is");
-const regex_1 = require("@/utils/regex");
-const slice_1 = require("@/utils/slice");
-const sort_1 = require("@/utils/sort");
-function divideString(input, numSeparators, strSeparators) {
-    if ((0, is_1.isEmptyArray)(numSeparators) && (0, is_1.isEmptyArray)(strSeparators)) {
-        return [input];
-    }
-    // Precompile regex for string separators
-    const regex = (0, regex_1.getRegex)(strSeparators);
-    // Divide by number delimiters
-    const sortedNumSeparators = (0, sort_1.sortAscending)(numSeparators);
-    const parts = (0, slice_1.sliceByIndexes)(input, sortedNumSeparators);
-    // Divide by string delimiters
-    return regex
-        ? parts.flatMap((part) => part.split(regex)).filter(Boolean)
-        : parts;
-}

package/dist/cjs/core/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/index.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dividerLoop = exports.dividerLast = exports.dividerFirst = exports.divider = void 0;
-var divider_1 = require("@/core/divider");
-Object.defineProperty(exports, "divider", { enumerable: true, get: function () { return divider_1.divider; } });
-var divider_first_1 = require("@/core/divider-first");
-Object.defineProperty(exports, "dividerFirst", { enumerable: true, get: function () { return divider_first_1.dividerFirst; } });
-var divider_last_1 = require("@/core/divider-last");
-Object.defineProperty(exports, "dividerLast", { enumerable: true, get: function () { return divider_last_1.dividerLast; } });
-var divider_loop_1 = require("@/core/divider-loop");
-Object.defineProperty(exports, "dividerLoop", { enumerable: true, get: function () { return divider_loop_1.dividerLoop; } });

package/dist/cjs/utils/array.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureArray = ensureArray;
-function ensureArray(input) {
-    return Array.isArray(input) ? input : [input];
-}

package/dist/cjs/utils/chunk.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateIndexes = generateIndexes;
-function generateIndexes(text, size) {
-    const indexes = [];
-    for (let i = size; i < text.length; i += size) {
-        indexes.push(i);
-    }
-    return indexes;
-}

package/dist/cjs/utils/is.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNumber = exports.isString = void 0;
-exports.isOptions = isOptions;
-exports.isEmptyArray = isEmptyArray;
-exports.isPositiveInteger = isPositiveInteger;
-const isString = (arg) => typeof arg === 'string';
-exports.isString = isString;
-const isNumber = (arg) => typeof arg === 'number';
-exports.isNumber = isNumber;
-function isOptions(arg) {
-    return typeof arg === 'object' && arg !== null && 'flatten' in arg;
-}
-function isEmptyArray(input) {
-    return Array.isArray(input) && input.length === 0;
-}
-function isPositiveInteger(value) {
-    return Number.isInteger(value) && value > 0;
-}

package/dist/cjs/utils/regex.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRegex = getRegex;
-const is_1 = require("@/utils/is");
-const regexCache = new Map();
-function getRegex(separators) {
-    if ((0, is_1.isEmptyArray)(separators))
-        return null;
-    const key = JSON.stringify(separators);
-    if (!regexCache.has(key)) {
-        const pattern = separators.reduce((acc, sep) => acc + escapeRegExp(sep), '');
-        regexCache.set(key, new RegExp(`[${pattern}]`, 'g'));
-    }
-    return regexCache.get(key);
-}
-function escapeRegExp(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}

package/dist/cjs/utils/slice.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sliceByIndexes = sliceByIndexes;
-const is_1 = require("@/utils/is");
-function sliceByIndexes(input, indexes) {
-    if ((0, is_1.isEmptyArray)(indexes))
-        return [input];
-    const parts = [];
-    let start = 0;
-    for (const index of indexes) {
-        if (index <= start || input.length <= index)
-            continue;
-        parts.push(input.slice(start, index));
-        start = index;
-    }
-    if (start < input.length) {
-        parts.push(input.slice(start));
-    }
-    return parts;
-}

package/dist/cjs/utils/sort.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortAscending = sortAscending;
-function sortAscending(numbers) {
-    return [...numbers].sort((a, b) => a - b);
-}

package/dist/esm/core/divider-first.js

@@ -1,6 +0,0 @@
-import { divider } from '@/core/divider';
-export function dividerFirst(input, ...args) {
-    var _a;
-    const result = divider(input, ...args, { flatten: true });
-    return (_a = result[0]) !== null && _a !== void 0 ? _a : '';
-}

package/dist/esm/core/divider-last.js

@@ -1,6 +0,0 @@
-import { divider } from '@/core/divider';
-export function dividerLast(input, ...args) {
-    var _a;
-    const result = divider(input, ...args, { flatten: true });
-    return (_a = result.at(-1)) !== null && _a !== void 0 ? _a : '';
-}

package/dist/esm/core/divider-loop.js

@@ -1,20 +0,0 @@
-import { isString, isPositiveInteger } from '@/utils/is';
-import { generateIndexes } from '@/utils/chunk';
-import { divider } from '@/core/divider';
-export function dividerLoop(input, size, options) {
-    var _a;
-    if (!isPositiveInteger(size)) {
-        console.warn('dividerLoop: chunk size must be a positive number');
-        return [];
-    }
-    if (isString(input)) {
-        const indexes = generateIndexes(input, size);
-        return divider(input, ...indexes);
-    }
-    const result = input.map((item) => {
-        const indexes = generateIndexes(item, size);
-        return divider(item, ...indexes);
-    });
-    const flatten = (_a = options === null || options === void 0 ? void 0 : options.flatten) !== null && _a !== void 0 ? _a : false;
-    return (flatten ? result.flat() : result);
-}

package/dist/esm/core/divider-number-string.js

@@ -1,12 +0,0 @@
-import { isString } from '@/utils/is';
-export function dividerNumberString(input, options) {
-    const regex = /\d+|\D+/g;
-    const divide = (str) => {
-        return (str.match(regex) || []).filter(Boolean);
-    };
-    if (isString(input)) {
-        return divide(input);
-    }
-    const result = input.map(divide);
-    return ((options === null || options === void 0 ? void 0 : options.flatten) ? result.flat() : result);
-}

package/dist/esm/core/divider.js

@@ -1,31 +0,0 @@
-import { divideString } from '@/core/parser';
-import { isString, isNumber, isOptions, isEmptyArray } from '@/utils/is';
-import { ensureArray } from '@/utils/array';
-export function divider(input, ...args) {
-    if (!isString(input) && !Array.isArray(input)) {
-        console.warn("divider: 'input' must be a string or an array of strings. So returning an empty array.");
-        return [];
-    }
-    if (isEmptyArray(args)) {
-        return ensureArray(input);
-    }
-    // Extract the options from the input
-    const clonedArgs = [...args];
-    const lastArg = clonedArgs.at(-1);
-    const options = isOptions(lastArg) ? (clonedArgs.pop(), lastArg) : {};
-    // Filter out only numbers and strings
-    const { numSeparators, strSeparators } = clonedArgs.reduce((acc, arg) => {
-        if (isNumber(arg)) {
-            acc.numSeparators.push(arg);
-        }
-        else if (isString(arg)) {
-            acc.strSeparators.push(arg);
-        }
-        return acc;
-    }, { numSeparators: [], strSeparators: [] });
-    if (isString(input)) {
-        return divideString(input, numSeparators, strSeparators);
-    }
-    const result = input.map((item) => divideString(item, numSeparators, strSeparators));
-    return (options.flatten ? result.flat() : result);
-}

package/dist/esm/core/parser.js

@@ -1,18 +0,0 @@
-import { isEmptyArray } from '@/utils/is';
-import { getRegex } from '@/utils/regex';
-import { sliceByIndexes } from '@/utils/slice';
-import { sortAscending } from '@/utils/sort';
-export function divideString(input, numSeparators, strSeparators) {
-    if (isEmptyArray(numSeparators) && isEmptyArray(strSeparators)) {
-        return [input];
-    }
-    // Precompile regex for string separators
-    const regex = getRegex(strSeparators);
-    // Divide by number delimiters
-    const sortedNumSeparators = sortAscending(numSeparators);
-    const parts = sliceByIndexes(input, sortedNumSeparators);
-    // Divide by string delimiters
-    return regex
-        ? parts.flatMap((part) => part.split(regex)).filter(Boolean)
-        : parts;
-}

package/dist/esm/core/types.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/index.js

@@ -1,4 +0,0 @@
-export { divider } from '@/core/divider';
-export { dividerFirst } from '@/core/divider-first';
-export { dividerLast } from '@/core/divider-last';
-export { dividerLoop } from '@/core/divider-loop';

package/dist/esm/utils/array.js

@@ -1,3 +0,0 @@
-export function ensureArray(input) {
-    return Array.isArray(input) ? input : [input];
-}

package/dist/esm/utils/chunk.js

@@ -1,7 +0,0 @@
-export function generateIndexes(text, size) {
-    const indexes = [];
-    for (let i = size; i < text.length; i += size) {
-        indexes.push(i);
-    }
-    return indexes;
-}

package/dist/esm/utils/is.js

@@ -1,11 +0,0 @@
-export const isString = (arg) => typeof arg === 'string';
-export const isNumber = (arg) => typeof arg === 'number';
-export function isOptions(arg) {
-    return typeof arg === 'object' && arg !== null && 'flatten' in arg;
-}
-export function isEmptyArray(input) {
-    return Array.isArray(input) && input.length === 0;
-}
-export function isPositiveInteger(value) {
-    return Number.isInteger(value) && value > 0;
-}

package/dist/esm/utils/regex.js

@@ -1,15 +0,0 @@
-import { isEmptyArray } from '@/utils/is';
-const regexCache = new Map();
-export function getRegex(separators) {
-    if (isEmptyArray(separators))
-        return null;
-    const key = JSON.stringify(separators);
-    if (!regexCache.has(key)) {
-        const pattern = separators.reduce((acc, sep) => acc + escapeRegExp(sep), '');
-        regexCache.set(key, new RegExp(`[${pattern}]`, 'g'));
-    }
-    return regexCache.get(key);
-}
-function escapeRegExp(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}

package/dist/esm/utils/slice.js

@@ -1,17 +0,0 @@
-import { isEmptyArray } from '@/utils/is';
-export function sliceByIndexes(input, indexes) {
-    if (isEmptyArray(indexes))
-        return [input];
-    const parts = [];
-    let start = 0;
-    for (const index of indexes) {
-        if (index <= start || input.length <= index)
-            continue;
-        parts.push(input.slice(start, index));
-        start = index;
-    }
-    if (start < input.length) {
-        parts.push(input.slice(start));
-    }
-    return parts;
-}

package/dist/esm/utils/sort.js

@@ -1,3 +0,0 @@
-export function sortAscending(numbers) {
-    return [...numbers].sort((a, b) => a - b);
-}

package/dist/types/core/divider-first.d.ts

@@ -1,2 +0,0 @@
-import type { DividerSeparators } from '@/core/types';
-export declare function dividerFirst(input: string | string[], ...args: DividerSeparators): string;

package/dist/types/core/divider-last.d.ts

@@ -1,2 +0,0 @@
-import type { DividerSeparators } from '@/core/types';
-export declare function dividerLast(input: string | string[], ...args: DividerSeparators): string;

package/dist/types/core/divider-loop.d.ts

@@ -1,2 +0,0 @@
-import type { DividerOptions, DividerResult } from '@/core/types';
-export declare function dividerLoop<T extends string | string[], F extends boolean>(input: T, size: number, options?: DividerOptions<F>): DividerResult<T, F>;

package/dist/types/core/divider-number-string.d.ts

@@ -1,2 +0,0 @@
-import type { DividerOptions, DividerResult } from '@/core/types';
-export declare function dividerNumberString<T extends string | string[], F extends boolean = false>(input: T, options?: DividerOptions<F>): DividerResult<T, F>;

package/dist/types/core/divider.d.ts

@@ -1,2 +0,0 @@
-import type { DividerResult, DividerArgs } from '@/core/types';
-export declare function divider<T extends string | string[], F extends boolean>(input: T, ...args: DividerArgs<F>): DividerResult<T, F>;

package/dist/types/core/parser.d.ts

@@ -1 +0,0 @@
-export declare function divideString(input: string, numSeparators: number[], strSeparators: string[]): string[];

package/dist/types/core/types.d.ts

@@ -1,6 +0,0 @@
-export type DividerResult<T extends string | string[], F extends boolean = false> = T extends string ? string[] : F extends true ? string[] : string[][];
-export type DividerOptions<F extends boolean> = {
-    flatten?: F;
-};
-export type DividerSeparators = (number | string)[];
-export type DividerArgs<F extends boolean> = DividerSeparators | [...DividerSeparators, DividerOptions<F>];

package/dist/types/index.d.ts

@@ -1,5 +0,0 @@
-export { divider } from '@/core/divider';
-export { dividerFirst } from '@/core/divider-first';
-export { dividerLast } from '@/core/divider-last';
-export { dividerLoop } from '@/core/divider-loop';
-export type { DividerResult } from '@/core/types';

package/dist/types/utils/array.d.ts

@@ -1 +0,0 @@
-export declare function ensureArray<T>(input: T | T[]): T[];

package/dist/types/utils/chunk.d.ts

@@ -1 +0,0 @@
-export declare function generateIndexes(text: string, size: number): number[];

package/dist/types/utils/is.d.ts

@@ -1,7 +0,0 @@
-export declare const isString: (arg: unknown) => arg is string;
-export declare const isNumber: (arg: unknown) => arg is number;
-export declare function isOptions(arg: unknown): arg is {
-    flatten?: boolean;
-};
-export declare function isEmptyArray<T>(input: T[]): boolean;
-export declare function isPositiveInteger(value: unknown): boolean;

package/dist/types/utils/regex.d.ts

@@ -1 +0,0 @@
-export declare function getRegex(separators: string[]): RegExp | null;

package/dist/types/utils/slice.d.ts

@@ -1 +0,0 @@
-export declare function sliceByIndexes(input: string, indexes: number[]): string[];

package/dist/types/utils/sort.d.ts

@@ -1 +0,0 @@
-export declare function sortAscending(numbers: number[]): number[];