@nyaomaru/divider 2.0.6 → 2.0.7

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,9 +440,7 @@ 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
@@ -422,13 +448,41 @@ function dividePreserve(input, separator) {
   if (isEmptyString(input)) return [""];
   return divider(input, separator, { preserveEmpty: true });
 }
-function countUnescaped(text, quote) {
-  const pair = quote + quote;
+var countUnescapedSingleChar = (text, quote) => {
+  let count = 0;
+  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 (const chunk of dividePreserve(text, pair)) {
-    count += dividePreserve(chunk, quote).length - 1;
+  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;
@@ -480,7 +534,8 @@ 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,10 +545,18 @@ var buildQuotedFields = (line, delimiter, quote, trim, lenient) => {
   }
   return state.fields;
 };
+var advanceQuoteState = (insideQuotes, segment, quote) => {
+  let nextInsideQuotes = insideQuotes;
+  for (const char of segment) {
+    if (char === quote) nextInsideQuotes = !nextInsideQuotes;
+  }
+  return nextInsideQuotes;
+};
 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) {
+  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);
   }
 };
@@ -502,6 +565,7 @@ var flushField = (state, quote, trim, lenient) => {
   if (trim) fieldValue = fieldValue.trim();
   state.fields.push(fieldValue);
   state.current = "";
+  state.insideQuotes = false;
 };
 
 // src/presets/csv-divider.ts
@@ -553,8 +617,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;
+    readonly quoteChar?: string;
     /** Character used to separate CSV fields. */
-    delimiter?: string;
+    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;
 };
 
 /**

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;
+    readonly quoteChar?: string;
     /** Character used to separate CSV fields. */
-    delimiter?: string;
+    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;
 };
 
 /**

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,9 +406,7 @@ 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
@@ -388,13 +414,41 @@ function dividePreserve(input, separator) {
   if (isEmptyString(input)) return [""];
   return divider(input, separator, { preserveEmpty: true });
 }
-function countUnescaped(text, quote) {
-  const pair = quote + quote;
+var countUnescapedSingleChar = (text, quote) => {
+  let count = 0;
+  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 (const chunk of dividePreserve(text, pair)) {
-    count += dividePreserve(chunk, quote).length - 1;
+  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;
@@ -446,7 +500,8 @@ 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,10 +511,18 @@ var buildQuotedFields = (line, delimiter, quote, trim, lenient) => {
   }
   return state.fields;
 };
+var advanceQuoteState = (insideQuotes, segment, quote) => {
+  let nextInsideQuotes = insideQuotes;
+  for (const char of segment) {
+    if (char === quote) nextInsideQuotes = !nextInsideQuotes;
+  }
+  return nextInsideQuotes;
+};
 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) {
+  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);
   }
 };
@@ -468,6 +531,7 @@ var flushField = (state, quote, trim, lenient) => {
   if (trim) fieldValue = fieldValue.trim();
   state.fields.push(fieldValue);
   state.current = "";
+  state.insideQuotes = false;
 };
 
 // src/presets/csv-divider.ts
@@ -519,8 +583,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.7",
   "description": "To divide string or string[] with a given separator",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",