@nyaomaru/divider 2.0.6 → 2.0.8

package/dist/index.cjs

@@ -122,7 +122,10 @@ function isNoneMode(value) {
 function normalizeSeparators(separators) {
   return Array.from(new Set(separators)).filter(
     (separator) => !isEmptyString(separator)
-  );
+  ).sort((left, right) => right.length - left.length);
+}
+function createCacheKey(normalizedSeparators) {
+  return normalizedSeparators.join(CACHE_KEY_SEPARATOR);
 }
 var RegexCache = class {
   cache = /* @__PURE__ */ new Map();
@@ -138,6 +141,15 @@ var RegexCache = class {
    */
   get(separators) {
     const key = this.createKey(separators);
+    return this.getByKey(key);
+  }
+  /**
+   * Retrieves a cached RegExp for a precomputed cache key.
+   *
+   * @param key - Cache key string
+   * @returns Cached RegExp or null if not found
+   */
+  getByKey(key) {
     const regex = this.cache.get(key);
     if (regex) {
       this.cache.delete(key);
@@ -153,6 +165,15 @@ var RegexCache = class {
    */
   set(separators, regex) {
     const key = this.createKey(separators);
+    this.setByKey(key, regex);
+  }
+  /**
+   * Stores a RegExp in the cache for a precomputed cache key.
+   *
+   * @param key - Cache key string
+   * @param regex - Compiled RegExp to cache
+   */
+  setByKey(key, regex) {
     if (this.cache.has(key)) {
       this.cache.delete(key);
     }
@@ -173,7 +194,7 @@ var RegexCache = class {
    */
   createKey(separators) {
     const normalizedSeparators = normalizeSeparators(separators);
-    return normalizedSeparators.join(CACHE_KEY_SEPARATOR);
+    return createCacheKey(normalizedSeparators);
   }
   /**
    * Gets current cache size for debugging/monitoring.
@@ -194,15 +215,16 @@ var RegexCache = class {
 var regexCache = new RegexCache();
 function getRegex(separators) {
   if (isEmptyArray(separators)) return null;
-  const cached = regexCache.get(separators);
-  if (cached) return cached;
   const uniqueSeparators = normalizeSeparators(separators);
   if (uniqueSeparators.length === 0) {
     return null;
   }
+  const cacheKey = createCacheKey(uniqueSeparators);
+  const cached = regexCache.getByKey(cacheKey);
+  if (cached) return cached;
   const pattern = uniqueSeparators.map(escapeRegExp).join("|");
   const regex = new RegExp(`(?:${pattern})`, "g");
-  regexCache.set(separators, regex);
+  regexCache.setByKey(cacheKey, regex);
   return regex;
 }
 function escapeRegExp(str) {
@@ -326,6 +348,13 @@ function classifySeparators(args) {
   );
 }
 
+// src/utils/transform-divider-input.ts
+function transformDividerInput(input, transform, options) {
+  const result = isString(input) ? transform(input) : input.map(transform);
+  const resolvedOptions = options ?? {};
+  return applyDividerOptions(result, resolvedOptions);
+}
+
 // src/core/divider.ts
 function divider(input, ...args) {
   if (!isValidInput(input)) {
@@ -342,8 +371,7 @@ function divider(input, ...args) {
   const applyDivision = (str) => divideString(str, numSeparators, strSeparators, {
     preserveEmpty: options.preserveEmpty
   });
-  const result = isString(input) ? applyDivision(input) : input.map(applyDivision);
-  return applyDividerOptions(result, options);
+  return transformDividerInput(input, applyDivision, options);
 }
 
 // src/core/divider-first.ts
@@ -394,15 +422,15 @@ function dividerLoop(input, size, options) {
     console.warn("dividerLoop: chunk size must be a positive number");
     return [];
   }
-  const resolvedOptions = options ?? {};
   const {
     startOffset = PERFORMANCE_CONSTANTS.DEFAULT_START_OFFSET,
     maxChunks = PERFORMANCE_CONSTANTS.DEFAULT_MAX_CHUNKS
-  } = resolvedOptions;
-  const result = isString(input) ? createChunksFromString(input, size, startOffset, maxChunks) : input.map(
-    (str) => createChunksFromString(str, size, startOffset, maxChunks)
+  } = options ?? {};
+  return transformDividerInput(
+    input,
+    (str) => createChunksFromString(str, size, startOffset, maxChunks),
+    options
   );
-  return applyDividerOptions(result, resolvedOptions);
 }
 
 // src/utils/divide.ts
@@ -412,40 +440,54 @@ function divideNumberString(str) {
 
 // src/core/divider-number-string.ts
 function dividerNumberString(input, options) {
-  const result = isString(input) ? divideNumberString(input) : input.map(divideNumberString);
-  const resolvedOptions = options ?? {};
-  return applyDividerOptions(result, resolvedOptions);
+  return transformDividerInput(input, divideNumberString, options);
 }
 
-// src/utils/quoted.ts
-function dividePreserve(input, separator) {
-  if (isEmptyString(input)) return [""];
-  return divider(input, separator, { preserveEmpty: true });
-}
-function countUnescaped(text, quote) {
-  const pair = quote + quote;
+// src/utils/count-unescaped.ts
+var countUnescapedSingleChar = (text, quote) => {
   let count = 0;
-  for (const chunk of dividePreserve(text, pair)) {
-    count += dividePreserve(chunk, quote).length - 1;
+  for (let index = 0; index < text.length; index++) {
+    if (text[index] !== quote) continue;
+    if (text[index + 1] === quote) {
+      index++;
+      continue;
+    }
+    count++;
   }
   return count;
+};
+var countUnescapedMultiChar = (text, quote) => {
+  const escapedPair = quote + quote;
+  const quoteLength = quote.length;
+  const escapedPairLength = escapedPair.length;
+  let count = 0;
+  for (let index = 0; index < text.length; ) {
+    if (text.startsWith(escapedPair, index)) {
+      index += escapedPairLength;
+      continue;
+    }
+    if (text.startsWith(quote, index)) {
+      count++;
+      index += quoteLength;
+      continue;
+    }
+    index++;
+  }
+  return count;
+};
+function countUnescaped(text, quote) {
+  if (isEmptyString(quote)) return 0;
+  if (quote.length === 1) return countUnescapedSingleChar(text, quote);
+  return countUnescapedMultiChar(text, quote);
 }
-function stripOuterQuotes(text, quoteChar, { lenient = true } = {}) {
-  const escapedPair = quoteChar + quoteChar;
-  const isWhitespace = (char) => char === WHITE_SPACE || char === TAB;
-  const restoreEscapedQuotes = (fieldText) => fieldText.split(escapedPair).join(quoteChar);
-  const stripped = stripOuterQuotesRaw(text, quoteChar, lenient, isWhitespace);
-  return restoreEscapedQuotes(stripped);
-}
-function quotedDivide(line, {
-  delimiter = ",",
-  quote = '"',
-  trim = false,
-  lenient = true
-} = {}) {
-  if (isEmptyString(line)) return [""];
-  return buildQuotedFields(line, delimiter, quote, trim, lenient);
+
+// src/utils/divide-preserve.ts
+function dividePreserve(input, separator) {
+  if (isEmptyString(input)) return [""];
+  return divider(input, separator, { preserveEmpty: true });
 }
+
+// src/utils/strip-outer-quotes.ts
 var findNonSpaceBounds = (text, isWhitespace) => {
   let left = 0;
   let right = text.length - 1;
@@ -453,34 +495,70 @@ var findNonSpaceBounds = (text, isWhitespace) => {
   while (right >= left && isWhitespace(text[right])) right--;
   return { left, right };
 };
-var stripMatchedOuterQuotes = (text, left, right) => text.slice(0, left) + text.slice(left + 1, right) + text.slice(right + 1);
-var removeCharAt = (text, index) => text.slice(0, index) + text.slice(index + 1);
-var stripTrailingQuote = (text, quoteChar, isWhitespace) => {
+var stripMatchedOuterQuotes = (text, left, rightQuoteStart, quote) => text.slice(0, left) + text.slice(left + quote.length, rightQuoteStart) + text.slice(rightQuoteStart + quote.length);
+var removeQuoteAt = (text, start, quote) => text.slice(0, start) + text.slice(start + quote.length);
+var stripTrailingQuote = (text, quote, isWhitespace) => {
+  const quoteLength = quote.length;
   let lastNonSpaceIndex = text.length - 1;
   while (lastNonSpaceIndex >= 0 && isWhitespace(text[lastNonSpaceIndex])) {
     lastNonSpaceIndex--;
   }
-  if (lastNonSpaceIndex < 0 || text[lastNonSpaceIndex] !== quoteChar) {
+  const trailingQuoteStart = lastNonSpaceIndex - quoteLength + 1;
+  if (trailingQuoteStart < 0 || !text.startsWith(quote, trailingQuoteStart)) {
     return text;
   }
-  return removeCharAt(text, lastNonSpaceIndex);
+  return removeQuoteAt(text, trailingQuoteStart, quote);
 };
-var stripOuterQuotesRaw = (text, quoteChar, lenient, isWhitespace) => {
+var stripOuterQuotesRaw = (text, quote, lenient, isWhitespace) => {
+  if (quote.length === 0) return text;
   const { left, right } = findNonSpaceBounds(text, isWhitespace);
   if (left > right) return text;
-  if (text[left] !== quoteChar) return text;
-  if (text[right] === quoteChar && right > left) {
-    return stripMatchedOuterQuotes(text, left, right);
+  if (!text.startsWith(quote, left)) return text;
+  const rightQuoteStart = right - quote.length + 1;
+  if (rightQuoteStart >= left + quote.length && text.startsWith(quote, rightQuoteStart)) {
+    return stripMatchedOuterQuotes(text, left, rightQuoteStart, quote);
   }
   if (!lenient) return text;
-  const withoutLeading = removeCharAt(text, left);
-  return stripTrailingQuote(withoutLeading, quoteChar, isWhitespace);
+  const withoutLeading = removeQuoteAt(text, left, quote);
+  return stripTrailingQuote(withoutLeading, quote, isWhitespace);
+};
+function stripOuterQuotes(text, quoteChar, { lenient = true } = {}) {
+  const isWhitespace = (char) => char === WHITE_SPACE || char === TAB;
+  const stripped = stripOuterQuotesRaw(text, quoteChar, lenient, isWhitespace);
+  if (quoteChar.length === 0) return stripped;
+  const escapedPair = quoteChar + quoteChar;
+  return stripped.split(escapedPair).join(quoteChar);
+}
+
+// src/utils/quoted-parser.ts
+var advanceQuoteState = (insideQuotes, segment, quote) => {
+  let nextInsideQuotes = insideQuotes;
+  for (const char of segment) {
+    if (char === quote) nextInsideQuotes = !nextInsideQuotes;
+  }
+  return nextInsideQuotes;
+};
+var flushField = (state, quote, trim, lenient) => {
+  let fieldValue = stripOuterQuotes(state.current, quote, { lenient });
+  if (trim) fieldValue = fieldValue.trim();
+  state.fields.push(fieldValue);
+  state.current = "";
+  state.insideQuotes = false;
+};
+var appendPiece = (state, piece, delimiter, quote, trim, lenient) => {
+  const segment = isEmptyString(state.current) ? piece : delimiter + piece;
+  state.current += segment;
+  state.insideQuotes = quote.length === 1 ? advanceQuoteState(state.insideQuotes, segment, quote) : countUnescaped(state.current, quote) % 2 === 1;
+  if (!state.insideQuotes) {
+    flushField(state, quote, trim, lenient);
+  }
 };
 var buildQuotedFields = (line, delimiter, quote, trim, lenient) => {
   const pieces = dividePreserve(line, delimiter);
   const state = {
     fields: [],
-    current: ""
+    current: "",
+    insideQuotes: false
   };
   for (const piece of pieces) {
     appendPiece(state, piece, delimiter, quote, trim, lenient);
@@ -490,19 +568,15 @@ var buildQuotedFields = (line, delimiter, quote, trim, lenient) => {
   }
   return state.fields;
 };
-var appendPiece = (state, piece, delimiter, quote, trim, lenient) => {
-  state.current = isEmptyString(state.current) ? piece : state.current + delimiter + piece;
-  const insideQuotes = countUnescaped(state.current, quote) % 2 === 1;
-  if (!insideQuotes) {
-    flushField(state, quote, trim, lenient);
-  }
-};
-var flushField = (state, quote, trim, lenient) => {
-  let fieldValue = stripOuterQuotes(state.current, quote, { lenient });
-  if (trim) fieldValue = fieldValue.trim();
-  state.fields.push(fieldValue);
-  state.current = "";
-};
+function quotedDivide(line, {
+  delimiter = ",",
+  quote = '"',
+  trim = false,
+  lenient = true
+} = {}) {
+  if (isEmptyString(line)) return [""];
+  return buildQuotedFields(line, delimiter, quote, trim, lenient);
+}
 
 // src/presets/csv-divider.ts
 function csvDivider(line, options = {}) {
@@ -553,8 +627,27 @@ function tryExtractQuery(input) {
     const url = new URL(input);
     return url.search.startsWith(QUERY_SEPARATORS.QUESTION_MARK) ? url.search.slice(1) : url.search;
   } catch {
-    return input;
+    return extractQueryFromQuestionMark(input);
+  }
+}
+function extractQueryFromQuestionMark(input) {
+  const fragmentIndex = input.indexOf("#");
+  const withoutFragment = fragmentIndex >= 0 ? input.slice(0, fragmentIndex) : input;
+  const questionMarkIndex = withoutFragment.indexOf(
+    QUERY_SEPARATORS.QUESTION_MARK
+  );
+  if (questionMarkIndex < 0) {
+    return withoutFragment;
+  }
+  if (questionMarkIndex === 0) {
+    return withoutFragment.slice(1);
+  }
+  const prefix = withoutFragment.slice(0, questionMarkIndex);
+  const hasQuerySeparatorBefore = prefix.includes(QUERY_SEPARATORS.AMPERSAND) || prefix.includes(QUERY_SEPARATORS.EQUALS);
+  if (hasQuerySeparatorBefore) {
+    return withoutFragment;
   }
+  return withoutFragment.slice(questionMarkIndex + 1);
 }
 function stripLeadingQuestionMark(query) {
   return query.startsWith(QUERY_SEPARATORS.QUESTION_MARK) ? query.slice(1) : query;

package/dist/index.d.cts

@@ -21,21 +21,42 @@ declare const QUERY_DECODE_MODES: {
     readonly RAW: "raw";
 };
 
+/**
+ * Supported exclusion modes used to filter divider output.
+ */
 type DividerExcludeMode = (typeof DIVIDER_EXCLUDE_MODES)[keyof typeof DIVIDER_EXCLUDE_MODES];
+/**
+ * Single string input accepted by divider functions.
+ */
 type StringInput = string;
+/**
+ * Readonly string array input accepted by divider functions.
+ */
 type StringArrayInput = readonly string[];
+/**
+ * Supported input shapes for divider functions.
+ */
 type DividerInput = StringInput | StringArrayInput;
+/**
+ * Flat divider result.
+ */
 type DividerStringResult = string[];
+/**
+ * Nested divider result for `string[]` inputs when `flatten` is not enabled.
+ */
 type DividerArrayResult = string[][];
+/**
+ * Shared options supported by divider functions.
+ */
 type DividerOptions = {
     /** If true, flattens nested arrays into a single array */
-    flatten?: boolean;
+    readonly flatten?: boolean;
     /** If true, trims whitespace from each divided segment */
-    trim?: boolean;
+    readonly trim?: boolean;
     /** If true, retains empty segments produced by division */
-    preserveEmpty?: boolean;
+    readonly preserveEmpty?: boolean;
     /** Controls how empty or whitespace segments are handled */
-    exclude?: DividerExcludeMode;
+    readonly exclude?: DividerExcludeMode;
 };
 /**
  * Represents the absence of user-specified divider options while retaining
@@ -52,37 +73,76 @@ type DividerEmptyOptions = {
     readonly exclude?: never;
 };
 type DividerInferredOptions = DividerOptions | DividerEmptyOptions;
-type HasFlattenOption<TOptions extends DividerInferredOptions> = TOptions extends {
+/**
+ * Computes whether the provided options explicitly enable `flatten`.
+ */
+type IsFlattenEnabled<TOptions extends DividerInferredOptions> = TOptions extends {
     readonly flatten?: infer Flag;
-} ? Flag extends true ? true : false : false;
-type DividerResult<T extends DividerInput, TOptions extends DividerInferredOptions = DividerEmptyOptions> = T extends StringInput ? DividerStringResult : HasFlattenOption<TOptions> extends true ? DividerStringResult : DividerArrayResult;
+} ? [Flag] extends [true] ? true : false : false;
+/**
+ * Resolves the divider output shape from the input and options.
+ */
+type DividerResult<T extends DividerInput, TOptions extends DividerInferredOptions = DividerEmptyOptions> = T extends StringInput ? DividerStringResult : IsFlattenEnabled<TOptions> extends true ? DividerStringResult : DividerArrayResult;
+/**
+ * Numeric separator interpreted as an index.
+ */
+type NumericSeparator = number;
+/**
+ * String separator interpreted as a delimiter.
+ */
+type StringSeparator = string;
+/**
+ * Any supported divider separator.
+ */
+type DividerSeparator = NumericSeparator | StringSeparator;
+/**
+ * A readonly list of separators without options.
+ */
+type DividerSeparators = readonly DividerSeparator[];
+/**
+ * Any single divider argument.
+ */
+type DividerArg = DividerSeparator | DividerOptions;
+/**
+ * Divider arguments with an optional trailing options object.
+ *
+ * WHY: Runtime only consumes options when they are passed last. This tuple
+ * shape keeps the public type contract aligned with that behavior.
+ */
+type DividerArgs = DividerSeparators | readonly [...DividerSeparator[], DividerOptions];
+/**
+ * Extracts trailing divider options from a variadic argument tuple.
+ */
+type ExtractedDividerOptions<TArgs extends readonly unknown[]> = TArgs extends readonly [...unknown[], infer Last] ? Last extends DividerOptions ? Last : DividerEmptyOptions : DividerEmptyOptions;
 /**
  * Computes the divider return type based on the input and provided arguments.
  *
  * WHY: When no arguments are provided, divider returns the input as-is for
  * string arrays. This type keeps the signature aligned with runtime behavior.
  */
-type DividerReturn<T extends DividerInput, TArgs extends DividerArgs> = T extends StringInput ? DividerStringResult : TArgs['length'] extends 0 ? T : HasFlattenOption<ExtractedDividerOptions<TArgs>> extends true ? DividerStringResult : DividerArrayResult;
-type ExtractedDividerOptions<TArgs extends DividerArgs> = TArgs extends readonly [...infer Rest, infer Last] ? Rest extends DividerArg[] ? Last extends DividerOptions ? Last : DividerEmptyOptions : DividerEmptyOptions : DividerEmptyOptions;
+type DividerReturn<T extends DividerInput, TArgs extends DividerArgs> = T extends StringInput ? DividerStringResult : TArgs['length'] extends 0 ? T : IsFlattenEnabled<ExtractedDividerOptions<TArgs>> extends true ? DividerStringResult : DividerArrayResult;
+/**
+ * Additional options supported by `dividerLoop`.
+ */
 type DividerLoopOptions = DividerOptions & {
     /** Starting position for the division (0-based) */
-    startOffset?: number;
+    readonly startOffset?: number;
     /** Maximum number of chunks to produce */
-    maxChunks?: number;
+    readonly maxChunks?: number;
 };
+/**
+ * Represents the absence of loop-specific options while preserving inference.
+ */
 type DividerLoopEmptyOptions = DividerEmptyOptions & {
     /** Placeholder to signal startOffset is intentionally absent */
     readonly startOffset?: never;
     /** Placeholder to signal maxChunks is intentionally absent */
     readonly maxChunks?: never;
 };
+/**
+ * Accepted option shapes for `dividerLoop`.
+ */
 type DividerLoopOptionsLike = DividerLoopOptions | DividerLoopEmptyOptions;
-type NumericSeparator = number;
-type StringSeparator = string;
-type DividerSeparator = NumericSeparator | StringSeparator;
-type DividerSeparators = readonly DividerSeparator[];
-type DividerArg = DividerSeparator | DividerOptions;
-type DividerArgs = readonly DividerArg[];
 
 /**
  * Main divider function that splits input based on numeric positions or string delimiters.
@@ -96,7 +156,7 @@ type DividerArgs = readonly DividerArg[];
  * @param args - Array of separators (numbers/strings) and optional options object
  * @returns Divided string segments based on input type and options
  */
-declare function divider<T extends DividerInput, const TArgs extends readonly DividerArg[]>(input: T, ...args: TArgs): DividerReturn<T, TArgs>;
+declare function divider<T extends DividerInput, const TArgs extends DividerArgs>(input: T, ...args: TArgs): DividerReturn<T, TArgs>;
 
 /**
  * Extracts the first segment after dividing the input using specified separators.
@@ -160,22 +220,22 @@ declare function dividerNumberString<T extends DividerInput, O extends DividerIn
 
 type EmailDividerOptions = Pick<DividerOptions, 'trim'> & {
     /** Split top-level domain from the rest of the email address. */
-    splitTLD?: boolean;
+    readonly splitTLD?: boolean;
 };
 type CsvDividerOptions = Pick<DividerOptions, 'trim'> & {
-    /** Character used for quoting values. */
-    quoteChar?: string;
-    /** Character used to separate CSV fields. */
-    delimiter?: string;
+    /** Quote string used for quoting values. */
+    readonly quoteChar?: string;
+    /** Delimiter string used to separate CSV fields. */
+    readonly delimiter?: string;
 };
 type PathDividerOptions = Pick<DividerOptions, 'trim'> & {
     /** Collapse empty segments produced by leading/trailing or repeated separators. */
-    collapse?: boolean;
+    readonly collapse?: boolean;
 };
 type QueryDecodeMode = (typeof QUERY_DECODE_MODES)[keyof typeof QUERY_DECODE_MODES];
 type QueryDividerOptions = Pick<DividerOptions, 'trim'> & {
     /** Decoding mode: 'auto' applies standard URL decoding; 'raw' leaves values untouched. */
-    mode?: QueryDecodeMode;
+    readonly mode?: QueryDecodeMode;
 };
 
 /**
@@ -183,8 +243,8 @@ type QueryDividerOptions = Pick<DividerOptions, 'trim'> & {
  *
  * @param line - The CSV line string to be divided into fields
  * @param options - Configuration options for CSV parsing
- * @param options.delimiter - The character used to separate fields (default: ',')
- * @param options.quoteChar - The character used to quote fields containing delimiters or newlines (default: '"')
+ * @param options.delimiter - The delimiter string used to separate fields (default: ',')
+ * @param options.quoteChar - The quote string used to wrap fields containing delimiters or newlines (default: '"')
  * @param options.trim - Whether to trim whitespace from field values (default: false)
  * @returns A DividerStringResult containing the parsed CSV fields
  */

package/dist/index.d.ts

@@ -21,21 +21,42 @@ declare const QUERY_DECODE_MODES: {
     readonly RAW: "raw";
 };
 
+/**
+ * Supported exclusion modes used to filter divider output.
+ */
 type DividerExcludeMode = (typeof DIVIDER_EXCLUDE_MODES)[keyof typeof DIVIDER_EXCLUDE_MODES];
+/**
+ * Single string input accepted by divider functions.
+ */
 type StringInput = string;
+/**
+ * Readonly string array input accepted by divider functions.
+ */
 type StringArrayInput = readonly string[];
+/**
+ * Supported input shapes for divider functions.
+ */
 type DividerInput = StringInput | StringArrayInput;
+/**
+ * Flat divider result.
+ */
 type DividerStringResult = string[];
+/**
+ * Nested divider result for `string[]` inputs when `flatten` is not enabled.
+ */
 type DividerArrayResult = string[][];
+/**
+ * Shared options supported by divider functions.
+ */
 type DividerOptions = {
     /** If true, flattens nested arrays into a single array */
-    flatten?: boolean;
+    readonly flatten?: boolean;
     /** If true, trims whitespace from each divided segment */
-    trim?: boolean;
+    readonly trim?: boolean;
     /** If true, retains empty segments produced by division */
-    preserveEmpty?: boolean;
+    readonly preserveEmpty?: boolean;
     /** Controls how empty or whitespace segments are handled */
-    exclude?: DividerExcludeMode;
+    readonly exclude?: DividerExcludeMode;
 };
 /**
  * Represents the absence of user-specified divider options while retaining
@@ -52,37 +73,76 @@ type DividerEmptyOptions = {
     readonly exclude?: never;
 };
 type DividerInferredOptions = DividerOptions | DividerEmptyOptions;
-type HasFlattenOption<TOptions extends DividerInferredOptions> = TOptions extends {
+/**
+ * Computes whether the provided options explicitly enable `flatten`.
+ */
+type IsFlattenEnabled<TOptions extends DividerInferredOptions> = TOptions extends {
     readonly flatten?: infer Flag;
-} ? Flag extends true ? true : false : false;
-type DividerResult<T extends DividerInput, TOptions extends DividerInferredOptions = DividerEmptyOptions> = T extends StringInput ? DividerStringResult : HasFlattenOption<TOptions> extends true ? DividerStringResult : DividerArrayResult;
+} ? [Flag] extends [true] ? true : false : false;
+/**
+ * Resolves the divider output shape from the input and options.
+ */
+type DividerResult<T extends DividerInput, TOptions extends DividerInferredOptions = DividerEmptyOptions> = T extends StringInput ? DividerStringResult : IsFlattenEnabled<TOptions> extends true ? DividerStringResult : DividerArrayResult;
+/**
+ * Numeric separator interpreted as an index.
+ */
+type NumericSeparator = number;
+/**
+ * String separator interpreted as a delimiter.
+ */
+type StringSeparator = string;
+/**
+ * Any supported divider separator.
+ */
+type DividerSeparator = NumericSeparator | StringSeparator;
+/**
+ * A readonly list of separators without options.
+ */
+type DividerSeparators = readonly DividerSeparator[];
+/**
+ * Any single divider argument.
+ */
+type DividerArg = DividerSeparator | DividerOptions;
+/**
+ * Divider arguments with an optional trailing options object.
+ *
+ * WHY: Runtime only consumes options when they are passed last. This tuple
+ * shape keeps the public type contract aligned with that behavior.
+ */
+type DividerArgs = DividerSeparators | readonly [...DividerSeparator[], DividerOptions];
+/**
+ * Extracts trailing divider options from a variadic argument tuple.
+ */
+type ExtractedDividerOptions<TArgs extends readonly unknown[]> = TArgs extends readonly [...unknown[], infer Last] ? Last extends DividerOptions ? Last : DividerEmptyOptions : DividerEmptyOptions;
 /**
  * Computes the divider return type based on the input and provided arguments.
  *
  * WHY: When no arguments are provided, divider returns the input as-is for
  * string arrays. This type keeps the signature aligned with runtime behavior.
  */
-type DividerReturn<T extends DividerInput, TArgs extends DividerArgs> = T extends StringInput ? DividerStringResult : TArgs['length'] extends 0 ? T : HasFlattenOption<ExtractedDividerOptions<TArgs>> extends true ? DividerStringResult : DividerArrayResult;
-type ExtractedDividerOptions<TArgs extends DividerArgs> = TArgs extends readonly [...infer Rest, infer Last] ? Rest extends DividerArg[] ? Last extends DividerOptions ? Last : DividerEmptyOptions : DividerEmptyOptions : DividerEmptyOptions;
+type DividerReturn<T extends DividerInput, TArgs extends DividerArgs> = T extends StringInput ? DividerStringResult : TArgs['length'] extends 0 ? T : IsFlattenEnabled<ExtractedDividerOptions<TArgs>> extends true ? DividerStringResult : DividerArrayResult;
+/**
+ * Additional options supported by `dividerLoop`.
+ */
 type DividerLoopOptions = DividerOptions & {
     /** Starting position for the division (0-based) */
-    startOffset?: number;
+    readonly startOffset?: number;
     /** Maximum number of chunks to produce */
-    maxChunks?: number;
+    readonly maxChunks?: number;
 };
+/**
+ * Represents the absence of loop-specific options while preserving inference.
+ */
 type DividerLoopEmptyOptions = DividerEmptyOptions & {
     /** Placeholder to signal startOffset is intentionally absent */
     readonly startOffset?: never;
     /** Placeholder to signal maxChunks is intentionally absent */
     readonly maxChunks?: never;
 };
+/**
+ * Accepted option shapes for `dividerLoop`.
+ */
 type DividerLoopOptionsLike = DividerLoopOptions | DividerLoopEmptyOptions;
-type NumericSeparator = number;
-type StringSeparator = string;
-type DividerSeparator = NumericSeparator | StringSeparator;
-type DividerSeparators = readonly DividerSeparator[];
-type DividerArg = DividerSeparator | DividerOptions;
-type DividerArgs = readonly DividerArg[];
 
 /**
  * Main divider function that splits input based on numeric positions or string delimiters.
@@ -96,7 +156,7 @@ type DividerArgs = readonly DividerArg[];
  * @param args - Array of separators (numbers/strings) and optional options object
  * @returns Divided string segments based on input type and options
  */
-declare function divider<T extends DividerInput, const TArgs extends readonly DividerArg[]>(input: T, ...args: TArgs): DividerReturn<T, TArgs>;
+declare function divider<T extends DividerInput, const TArgs extends DividerArgs>(input: T, ...args: TArgs): DividerReturn<T, TArgs>;
 
 /**
  * Extracts the first segment after dividing the input using specified separators.
@@ -160,22 +220,22 @@ declare function dividerNumberString<T extends DividerInput, O extends DividerIn
 
 type EmailDividerOptions = Pick<DividerOptions, 'trim'> & {
     /** Split top-level domain from the rest of the email address. */
-    splitTLD?: boolean;
+    readonly splitTLD?: boolean;
 };
 type CsvDividerOptions = Pick<DividerOptions, 'trim'> & {
-    /** Character used for quoting values. */
-    quoteChar?: string;
-    /** Character used to separate CSV fields. */
-    delimiter?: string;
+    /** Quote string used for quoting values. */
+    readonly quoteChar?: string;
+    /** Delimiter string used to separate CSV fields. */
+    readonly delimiter?: string;
 };
 type PathDividerOptions = Pick<DividerOptions, 'trim'> & {
     /** Collapse empty segments produced by leading/trailing or repeated separators. */
-    collapse?: boolean;
+    readonly collapse?: boolean;
 };
 type QueryDecodeMode = (typeof QUERY_DECODE_MODES)[keyof typeof QUERY_DECODE_MODES];
 type QueryDividerOptions = Pick<DividerOptions, 'trim'> & {
     /** Decoding mode: 'auto' applies standard URL decoding; 'raw' leaves values untouched. */
-    mode?: QueryDecodeMode;
+    readonly mode?: QueryDecodeMode;
 };
 
 /**
@@ -183,8 +243,8 @@ type QueryDividerOptions = Pick<DividerOptions, 'trim'> & {
  *
  * @param line - The CSV line string to be divided into fields
  * @param options - Configuration options for CSV parsing
- * @param options.delimiter - The character used to separate fields (default: ',')
- * @param options.quoteChar - The character used to quote fields containing delimiters or newlines (default: '"')
+ * @param options.delimiter - The delimiter string used to separate fields (default: ',')
+ * @param options.quoteChar - The quote string used to wrap fields containing delimiters or newlines (default: '"')
  * @param options.trim - Whether to trim whitespace from field values (default: false)
  * @returns A DividerStringResult containing the parsed CSV fields
  */

package/dist/index.js

@@ -88,7 +88,10 @@ function isNoneMode(value) {
 function normalizeSeparators(separators) {
   return Array.from(new Set(separators)).filter(
     (separator) => !isEmptyString(separator)
-  );
+  ).sort((left, right) => right.length - left.length);
+}
+function createCacheKey(normalizedSeparators) {
+  return normalizedSeparators.join(CACHE_KEY_SEPARATOR);
 }
 var RegexCache = class {
   cache = /* @__PURE__ */ new Map();
@@ -104,6 +107,15 @@ var RegexCache = class {
    */
   get(separators) {
     const key = this.createKey(separators);
+    return this.getByKey(key);
+  }
+  /**
+   * Retrieves a cached RegExp for a precomputed cache key.
+   *
+   * @param key - Cache key string
+   * @returns Cached RegExp or null if not found
+   */
+  getByKey(key) {
     const regex = this.cache.get(key);
     if (regex) {
       this.cache.delete(key);
@@ -119,6 +131,15 @@ var RegexCache = class {
    */
   set(separators, regex) {
     const key = this.createKey(separators);
+    this.setByKey(key, regex);
+  }
+  /**
+   * Stores a RegExp in the cache for a precomputed cache key.
+   *
+   * @param key - Cache key string
+   * @param regex - Compiled RegExp to cache
+   */
+  setByKey(key, regex) {
     if (this.cache.has(key)) {
       this.cache.delete(key);
     }
@@ -139,7 +160,7 @@ var RegexCache = class {
    */
   createKey(separators) {
     const normalizedSeparators = normalizeSeparators(separators);
-    return normalizedSeparators.join(CACHE_KEY_SEPARATOR);
+    return createCacheKey(normalizedSeparators);
   }
   /**
    * Gets current cache size for debugging/monitoring.
@@ -160,15 +181,16 @@ var RegexCache = class {
 var regexCache = new RegexCache();
 function getRegex(separators) {
   if (isEmptyArray(separators)) return null;
-  const cached = regexCache.get(separators);
-  if (cached) return cached;
   const uniqueSeparators = normalizeSeparators(separators);
   if (uniqueSeparators.length === 0) {
     return null;
   }
+  const cacheKey = createCacheKey(uniqueSeparators);
+  const cached = regexCache.getByKey(cacheKey);
+  if (cached) return cached;
   const pattern = uniqueSeparators.map(escapeRegExp).join("|");
   const regex = new RegExp(`(?:${pattern})`, "g");
-  regexCache.set(separators, regex);
+  regexCache.setByKey(cacheKey, regex);
   return regex;
 }
 function escapeRegExp(str) {
@@ -292,6 +314,13 @@ function classifySeparators(args) {
   );
 }
 
+// src/utils/transform-divider-input.ts
+function transformDividerInput(input, transform, options) {
+  const result = isString(input) ? transform(input) : input.map(transform);
+  const resolvedOptions = options ?? {};
+  return applyDividerOptions(result, resolvedOptions);
+}
+
 // src/core/divider.ts
 function divider(input, ...args) {
   if (!isValidInput(input)) {
@@ -308,8 +337,7 @@ function divider(input, ...args) {
   const applyDivision = (str) => divideString(str, numSeparators, strSeparators, {
     preserveEmpty: options.preserveEmpty
   });
-  const result = isString(input) ? applyDivision(input) : input.map(applyDivision);
-  return applyDividerOptions(result, options);
+  return transformDividerInput(input, applyDivision, options);
 }
 
 // src/core/divider-first.ts
@@ -360,15 +388,15 @@ function dividerLoop(input, size, options) {
     console.warn("dividerLoop: chunk size must be a positive number");
     return [];
   }
-  const resolvedOptions = options ?? {};
   const {
     startOffset = PERFORMANCE_CONSTANTS.DEFAULT_START_OFFSET,
     maxChunks = PERFORMANCE_CONSTANTS.DEFAULT_MAX_CHUNKS
-  } = resolvedOptions;
-  const result = isString(input) ? createChunksFromString(input, size, startOffset, maxChunks) : input.map(
-    (str) => createChunksFromString(str, size, startOffset, maxChunks)
+  } = options ?? {};
+  return transformDividerInput(
+    input,
+    (str) => createChunksFromString(str, size, startOffset, maxChunks),
+    options
   );
-  return applyDividerOptions(result, resolvedOptions);
 }
 
 // src/utils/divide.ts
@@ -378,40 +406,54 @@ function divideNumberString(str) {
 
 // src/core/divider-number-string.ts
 function dividerNumberString(input, options) {
-  const result = isString(input) ? divideNumberString(input) : input.map(divideNumberString);
-  const resolvedOptions = options ?? {};
-  return applyDividerOptions(result, resolvedOptions);
+  return transformDividerInput(input, divideNumberString, options);
 }
 
-// src/utils/quoted.ts
-function dividePreserve(input, separator) {
-  if (isEmptyString(input)) return [""];
-  return divider(input, separator, { preserveEmpty: true });
-}
-function countUnescaped(text, quote) {
-  const pair = quote + quote;
+// src/utils/count-unescaped.ts
+var countUnescapedSingleChar = (text, quote) => {
   let count = 0;
-  for (const chunk of dividePreserve(text, pair)) {
-    count += dividePreserve(chunk, quote).length - 1;
+  for (let index = 0; index < text.length; index++) {
+    if (text[index] !== quote) continue;
+    if (text[index + 1] === quote) {
+      index++;
+      continue;
+    }
+    count++;
   }
   return count;
+};
+var countUnescapedMultiChar = (text, quote) => {
+  const escapedPair = quote + quote;
+  const quoteLength = quote.length;
+  const escapedPairLength = escapedPair.length;
+  let count = 0;
+  for (let index = 0; index < text.length; ) {
+    if (text.startsWith(escapedPair, index)) {
+      index += escapedPairLength;
+      continue;
+    }
+    if (text.startsWith(quote, index)) {
+      count++;
+      index += quoteLength;
+      continue;
+    }
+    index++;
+  }
+  return count;
+};
+function countUnescaped(text, quote) {
+  if (isEmptyString(quote)) return 0;
+  if (quote.length === 1) return countUnescapedSingleChar(text, quote);
+  return countUnescapedMultiChar(text, quote);
 }
-function stripOuterQuotes(text, quoteChar, { lenient = true } = {}) {
-  const escapedPair = quoteChar + quoteChar;
-  const isWhitespace = (char) => char === WHITE_SPACE || char === TAB;
-  const restoreEscapedQuotes = (fieldText) => fieldText.split(escapedPair).join(quoteChar);
-  const stripped = stripOuterQuotesRaw(text, quoteChar, lenient, isWhitespace);
-  return restoreEscapedQuotes(stripped);
-}
-function quotedDivide(line, {
-  delimiter = ",",
-  quote = '"',
-  trim = false,
-  lenient = true
-} = {}) {
-  if (isEmptyString(line)) return [""];
-  return buildQuotedFields(line, delimiter, quote, trim, lenient);
+
+// src/utils/divide-preserve.ts
+function dividePreserve(input, separator) {
+  if (isEmptyString(input)) return [""];
+  return divider(input, separator, { preserveEmpty: true });
 }
+
+// src/utils/strip-outer-quotes.ts
 var findNonSpaceBounds = (text, isWhitespace) => {
   let left = 0;
   let right = text.length - 1;
@@ -419,34 +461,70 @@ var findNonSpaceBounds = (text, isWhitespace) => {
   while (right >= left && isWhitespace(text[right])) right--;
   return { left, right };
 };
-var stripMatchedOuterQuotes = (text, left, right) => text.slice(0, left) + text.slice(left + 1, right) + text.slice(right + 1);
-var removeCharAt = (text, index) => text.slice(0, index) + text.slice(index + 1);
-var stripTrailingQuote = (text, quoteChar, isWhitespace) => {
+var stripMatchedOuterQuotes = (text, left, rightQuoteStart, quote) => text.slice(0, left) + text.slice(left + quote.length, rightQuoteStart) + text.slice(rightQuoteStart + quote.length);
+var removeQuoteAt = (text, start, quote) => text.slice(0, start) + text.slice(start + quote.length);
+var stripTrailingQuote = (text, quote, isWhitespace) => {
+  const quoteLength = quote.length;
   let lastNonSpaceIndex = text.length - 1;
   while (lastNonSpaceIndex >= 0 && isWhitespace(text[lastNonSpaceIndex])) {
     lastNonSpaceIndex--;
   }
-  if (lastNonSpaceIndex < 0 || text[lastNonSpaceIndex] !== quoteChar) {
+  const trailingQuoteStart = lastNonSpaceIndex - quoteLength + 1;
+  if (trailingQuoteStart < 0 || !text.startsWith(quote, trailingQuoteStart)) {
     return text;
   }
-  return removeCharAt(text, lastNonSpaceIndex);
+  return removeQuoteAt(text, trailingQuoteStart, quote);
 };
-var stripOuterQuotesRaw = (text, quoteChar, lenient, isWhitespace) => {
+var stripOuterQuotesRaw = (text, quote, lenient, isWhitespace) => {
+  if (quote.length === 0) return text;
   const { left, right } = findNonSpaceBounds(text, isWhitespace);
   if (left > right) return text;
-  if (text[left] !== quoteChar) return text;
-  if (text[right] === quoteChar && right > left) {
-    return stripMatchedOuterQuotes(text, left, right);
+  if (!text.startsWith(quote, left)) return text;
+  const rightQuoteStart = right - quote.length + 1;
+  if (rightQuoteStart >= left + quote.length && text.startsWith(quote, rightQuoteStart)) {
+    return stripMatchedOuterQuotes(text, left, rightQuoteStart, quote);
   }
   if (!lenient) return text;
-  const withoutLeading = removeCharAt(text, left);
-  return stripTrailingQuote(withoutLeading, quoteChar, isWhitespace);
+  const withoutLeading = removeQuoteAt(text, left, quote);
+  return stripTrailingQuote(withoutLeading, quote, isWhitespace);
+};
+function stripOuterQuotes(text, quoteChar, { lenient = true } = {}) {
+  const isWhitespace = (char) => char === WHITE_SPACE || char === TAB;
+  const stripped = stripOuterQuotesRaw(text, quoteChar, lenient, isWhitespace);
+  if (quoteChar.length === 0) return stripped;
+  const escapedPair = quoteChar + quoteChar;
+  return stripped.split(escapedPair).join(quoteChar);
+}
+
+// src/utils/quoted-parser.ts
+var advanceQuoteState = (insideQuotes, segment, quote) => {
+  let nextInsideQuotes = insideQuotes;
+  for (const char of segment) {
+    if (char === quote) nextInsideQuotes = !nextInsideQuotes;
+  }
+  return nextInsideQuotes;
+};
+var flushField = (state, quote, trim, lenient) => {
+  let fieldValue = stripOuterQuotes(state.current, quote, { lenient });
+  if (trim) fieldValue = fieldValue.trim();
+  state.fields.push(fieldValue);
+  state.current = "";
+  state.insideQuotes = false;
+};
+var appendPiece = (state, piece, delimiter, quote, trim, lenient) => {
+  const segment = isEmptyString(state.current) ? piece : delimiter + piece;
+  state.current += segment;
+  state.insideQuotes = quote.length === 1 ? advanceQuoteState(state.insideQuotes, segment, quote) : countUnescaped(state.current, quote) % 2 === 1;
+  if (!state.insideQuotes) {
+    flushField(state, quote, trim, lenient);
+  }
 };
 var buildQuotedFields = (line, delimiter, quote, trim, lenient) => {
   const pieces = dividePreserve(line, delimiter);
   const state = {
     fields: [],
-    current: ""
+    current: "",
+    insideQuotes: false
   };
   for (const piece of pieces) {
     appendPiece(state, piece, delimiter, quote, trim, lenient);
@@ -456,19 +534,15 @@ var buildQuotedFields = (line, delimiter, quote, trim, lenient) => {
   }
   return state.fields;
 };
-var appendPiece = (state, piece, delimiter, quote, trim, lenient) => {
-  state.current = isEmptyString(state.current) ? piece : state.current + delimiter + piece;
-  const insideQuotes = countUnescaped(state.current, quote) % 2 === 1;
-  if (!insideQuotes) {
-    flushField(state, quote, trim, lenient);
-  }
-};
-var flushField = (state, quote, trim, lenient) => {
-  let fieldValue = stripOuterQuotes(state.current, quote, { lenient });
-  if (trim) fieldValue = fieldValue.trim();
-  state.fields.push(fieldValue);
-  state.current = "";
-};
+function quotedDivide(line, {
+  delimiter = ",",
+  quote = '"',
+  trim = false,
+  lenient = true
+} = {}) {
+  if (isEmptyString(line)) return [""];
+  return buildQuotedFields(line, delimiter, quote, trim, lenient);
+}
 
 // src/presets/csv-divider.ts
 function csvDivider(line, options = {}) {
@@ -519,8 +593,27 @@ function tryExtractQuery(input) {
     const url = new URL(input);
     return url.search.startsWith(QUERY_SEPARATORS.QUESTION_MARK) ? url.search.slice(1) : url.search;
   } catch {
-    return input;
+    return extractQueryFromQuestionMark(input);
+  }
+}
+function extractQueryFromQuestionMark(input) {
+  const fragmentIndex = input.indexOf("#");
+  const withoutFragment = fragmentIndex >= 0 ? input.slice(0, fragmentIndex) : input;
+  const questionMarkIndex = withoutFragment.indexOf(
+    QUERY_SEPARATORS.QUESTION_MARK
+  );
+  if (questionMarkIndex < 0) {
+    return withoutFragment;
+  }
+  if (questionMarkIndex === 0) {
+    return withoutFragment.slice(1);
+  }
+  const prefix = withoutFragment.slice(0, questionMarkIndex);
+  const hasQuerySeparatorBefore = prefix.includes(QUERY_SEPARATORS.AMPERSAND) || prefix.includes(QUERY_SEPARATORS.EQUALS);
+  if (hasQuerySeparatorBefore) {
+    return withoutFragment;
   }
+  return withoutFragment.slice(questionMarkIndex + 1);
 }
 function stripLeadingQuestionMark(query) {
   return query.startsWith(QUERY_SEPARATORS.QUESTION_MARK) ? query.slice(1) : query;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nyaomaru/divider",
   "type": "module",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "description": "To divide string or string[] with a given separator",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",