flappa-doormal 2.5.3 → 2.6.0

package/AGENTS.md

@@ -203,6 +203,11 @@ The `breakpoints` option provides a post-processing mechanism for limiting segme
 ```typescript
 interface SegmentationOptions {
   rules: SplitRule[];
+  // Optional preprocessing step: regex replacements applied per-page BEFORE segmentation
+  // - default flags: 'gu' (and g+u are always enforced)
+  // - pageIds omitted: apply to all pages
+  // - pageIds: []: apply to no pages (skip)
+  replace?: Array<{ regex: string; replacement: string; flags?: string; pageIds?: number[] }>;
   maxPages?: number;           // Maximum pages a segment can span
   breakpoints?: string[];      // Ordered array of regex patterns (supports token expansion)
   prefer?: 'longer' | 'shorter'; // Select last or first match within window
@@ -420,6 +425,11 @@ Useful options (recent additions):
 - **`normalizeArabicDiacritics`**: `true` by default so tokens match diacritized forms (e.g. `وأَخْبَرَنَا` → `{{naql}}`).
 - **`whitespace`**: `'regex'` (default) uses `\\s*` placeholders; `'space'` uses literal spaces in returned signatures.
 
+**Note on brackets in returned signatures**:
+- `analyzeCommonLineStarts()` emits **template-like** signatures.
+- It intentionally **does not escape literal `()` / `[]`** (e.g. `(ح)` stays `(ح)`), because template patterns auto-escape `()[]` later.
+- If you reuse a signature inside a raw `regex` rule, you may need to escape literal brackets yourself.
+
 Examples:
 
 ```typescript

package/README.md

@@ -383,6 +383,12 @@ Key options:
   - `'regex'` (default): uses `\\s*` placeholders between tokens
   - `'space'`: uses literal single spaces (`' '`) between tokens (useful if you don't want `\\s` to later match newlines when reusing these patterns)
 
+**Note on brackets in returned patterns**:
+- `analyzeCommonLineStarts()` returns **template-like signatures**, not “ready-to-run regex”.
+- It intentionally **does not escape literal `()` / `[]`** in the returned `pattern` (e.g. `(ح)` stays `(ح)`).
+- If you paste these signatures into `lineStartsWith` / `lineStartsAfter` / `template`, that’s fine: those template pattern types **auto-escape `()[]`** outside `{{tokens}}`.
+- If you paste them into a raw `regex` rule, you may need to escape literal brackets yourself.
+
 
 ## Prompting LLMs / Agents to Generate Rules (Shamela books)
 
@@ -630,6 +636,16 @@ const pages: Page[] = [
 ];
 
 const options: SegmentationOptions = {
+  // Optional preprocessing step: regex replacements applied per-page BEFORE segmentation.
+  // Useful for normalizing OCR/typos/spacing so rules match consistently.
+  //
+  // Notes:
+  // - `flags` defaults to 'gu'. If provided, `g` and `u` are always enforced.
+  // - `pageIds: []` means "apply to no pages" (skip that rule).
+  // - Remember JSON escaping: to match a literal '.', use regex: "\\\\." in JSON.
+  replace: [
+    { regex: "([\\u0660-\\u0669]+)\\s*[-–—ـ]\\s*", replacement: "$1 - " }
+  ],
   rules: [
     { lineStartsWith: ['## '], split: 'at' }
   ],

package/dist/index.d.mts

@@ -558,6 +558,26 @@ interface Logger {
   /** Log a warning message (potential issues) */
   warn?: (message: string, ...args: unknown[]) => void;
 }
+/**
+ * - Default regex flags: `gu` (global + unicode)
+ * - If `flags` is provided, it is validated and merged with required flags:
+ *   `g` and `u` are always enforced.
+ *
+ * `pageIds` controls which pages a rule applies to:
+ * - `undefined`: apply to all pages
+ * - `[]`: apply to no pages (rule is skipped)
+ * - `[id1, id2, ...]`: apply only to those pages
+ */
+type Replacement = {
+  /** Raw regex source string (no token expansion). Compiled with `u` (and always `g`). */
+  regex: string;
+  /** Replacement string (passed to `String.prototype.replace`). */
+  replacement: string;
+  /** Optional regex flags; `g` and `u` are always enforced. */
+  flags?: string;
+  /** Optional list of page IDs to apply this replacement to. Empty array means skip. */
+  pageIds?: number[];
+};
 /**
  * Segmentation options controlling how pages are split.
  *
@@ -591,6 +611,12 @@ interface Logger {
  * };
  */
 type SegmentationOptions = {
+  /**
+   * Optional pre-processing replacements applied to page content BEFORE segmentation.
+   *
+   * Replacements are applied per-page (not on concatenated content), in array order.
+   */
+  replace?: Replacement[];
   /**
    * Rules applied in order to find split points.
    *
@@ -799,6 +825,30 @@ type Segment = {
  */
 declare const segmentPages: (pages: Page[], options: SegmentationOptions) => Segment[];
 //#endregion
+//#region src/segmentation/replace.d.ts
+/**
+ * A single replacement rule applied by `applyReplacements()` / `SegmentationOptions.replace`.
+ *
+ * Notes:
+ * - `regex` is a raw JavaScript regex source string (no token expansion).
+ * - Default flags are `gu` (global + unicode).
+ * - If `flags` is provided, it is validated and `g` + `u` are always enforced.
+ * - If `pageIds` is omitted, the rule applies to all pages.
+ * - If `pageIds` is `[]`, the rule applies to no pages (rule is skipped).
+ */
+type ReplaceRule = NonNullable<SegmentationOptions['replace']>[number];
+/**
+ * Applies ordered regex replacements to page content (per page).
+ *
+ * - Replacement rules are applied in array order.
+ * - Each rule is applied globally (flag `g` enforced) with unicode mode (flag `u` enforced).
+ * - `pageIds` can scope a rule to specific pages. `pageIds: []` skips the rule entirely.
+ *
+ * This function is intentionally **pure**:
+ * it returns a new pages array only when changes are needed, otherwise it returns the original pages.
+ */
+declare const applyReplacements: (pages: Page[], rules?: ReplaceRule[]) => Page[];
+//#endregion
 //#region src/segmentation/tokens.d.ts
 /**
  * Token-based template system for Arabic text pattern matching.
@@ -1213,5 +1263,5 @@ declare const analyzeTextForRule: (text: string) => {
   detected: DetectedPattern[];
 } | null;
 //#endregion
-export { type Breakpoint, type BreakpointRule, type CommonLineStartPattern, type DetectedPattern, type ExpandResult, type LineStartAnalysisOptions, type LineStartPatternExample, type Logger, type Page, type PageRange, type Segment, type SegmentationOptions, type SplitRule, TOKEN_PATTERNS, analyzeCommonLineStarts, analyzeTextForRule, containsTokens, detectTokenPatterns, escapeRegex, escapeTemplateBrackets, expandCompositeTokensInTemplate, expandTokens, expandTokensWithCaptures, generateTemplateFromText, getAvailableTokens, getTokenPattern, makeDiacriticInsensitive, segmentPages, suggestPatternConfig, templateToRegex };
+export { type Breakpoint, type BreakpointRule, type CommonLineStartPattern, type DetectedPattern, type ExpandResult, type LineStartAnalysisOptions, type LineStartPatternExample, type Logger, type Page, type PageRange, type ReplaceRule, type Segment, type SegmentationOptions, type SplitRule, TOKEN_PATTERNS, analyzeCommonLineStarts, analyzeTextForRule, applyReplacements, containsTokens, detectTokenPatterns, escapeRegex, escapeTemplateBrackets, expandCompositeTokensInTemplate, expandTokens, expandTokensWithCaptures, generateTemplateFromText, getAvailableTokens, getTokenPattern, makeDiacriticInsensitive, segmentPages, suggestPatternConfig, templateToRegex };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/segmentation/fuzzy.ts","../src/segmentation/types.ts","../src/segmentation/segmenter.ts","../src/segmentation/tokens.ts","../src/analysis.ts","../src/detection.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/segmentation/fuzzy.ts","../src/segmentation/types.ts","../src/segmentation/segmenter.ts","../src/segmentation/replace.ts","../src/segmentation/tokens.ts","../src/analysis.ts","../src/detection.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index.mjs

@@ -974,7 +974,33 @@ const escapeTemplateBrackets = (pattern) => {
 		return `\\${bracket}`;
 	});
 };
-const RUMUZ_ATOM = `(?:خت|خغ|بخ|عخ|مق|مت|عس|سي|سن|كن|مد|قد|خد|فد|دل|كد|غد|صد|دت|تم|فق|دق|[خرزيمنصسدفلتقع]|(?<![\\u0660-\\u0669])٤(?![\\u0660-\\u0669]))`;
+const RUMUZ_ATOM = `(?:${[
+	"خت",
+	"خغ",
+	"بخ",
+	"عخ",
+	"مق",
+	"مت",
+	"عس",
+	"سي",
+	"سن",
+	"كن",
+	"مد",
+	"قد",
+	"خد",
+	"فد",
+	"دل",
+	"كد",
+	"غد",
+	"صد",
+	"دت",
+	"دس",
+	"تم",
+	"فق",
+	"دق",
+	"[خرزيمنصسدفلتقع]",
+	"(?<![\\u0660-\\u0669])٤(?![\\u0660-\\u0669])"
+].join("|")})`;
 const RUMUZ_BLOCK = `${RUMUZ_ATOM}(?:\\s+${RUMUZ_ATOM})*`;
 const BASE_TOKENS = {
 	bab: "باب",
@@ -992,7 +1018,9 @@ const BASE_TOKENS = {
 		"سمعت",
 		"أنبأنا",
 		"وحدثنا",
-		"أخبرنا"
+		"أخبرنا",
+		"وحدثني",
+		"وحدثنيه"
 	].join("|"),
 	raqm: "[\\u0660-\\u0669]",
 	raqms: "[\\u0660-\\u0669]+",
@@ -1452,6 +1480,77 @@ const buildRuleRegex = (rule, capturePrefix) => {
 	};
 };
 
+//#endregion
+//#region src/segmentation/replace.ts
+const DEFAULT_REPLACE_FLAGS = "gu";
+const normalizeReplaceFlags = (flags) => {
+	if (!flags) return DEFAULT_REPLACE_FLAGS;
+	const allowed = new Set([
+		"g",
+		"i",
+		"m",
+		"s",
+		"u",
+		"y"
+	]);
+	const set = /* @__PURE__ */ new Set();
+	for (const ch of flags) {
+		if (!allowed.has(ch)) throw new Error(`Invalid replace regex flag: "${ch}" (allowed: gimsyu)`);
+		set.add(ch);
+	}
+	set.add("g");
+	set.add("u");
+	return [
+		"g",
+		"i",
+		"m",
+		"s",
+		"y",
+		"u"
+	].filter((c) => set.has(c)).join("");
+};
+const compileReplaceRules = (rules) => {
+	const compiled = [];
+	for (const r of rules) {
+		if (r.pageIds && r.pageIds.length === 0) continue;
+		const flags = normalizeReplaceFlags(r.flags);
+		const re = new RegExp(r.regex, flags);
+		compiled.push({
+			pageIdSet: r.pageIds ? new Set(r.pageIds) : void 0,
+			re,
+			replacement: r.replacement
+		});
+	}
+	return compiled;
+};
+/**
+* Applies ordered regex replacements to page content (per page).
+*
+* - Replacement rules are applied in array order.
+* - Each rule is applied globally (flag `g` enforced) with unicode mode (flag `u` enforced).
+* - `pageIds` can scope a rule to specific pages. `pageIds: []` skips the rule entirely.
+*
+* This function is intentionally **pure**:
+* it returns a new pages array only when changes are needed, otherwise it returns the original pages.
+*/
+const applyReplacements = (pages, rules) => {
+	if (!rules || rules.length === 0 || pages.length === 0) return pages;
+	const compiled = compileReplaceRules(rules);
+	if (compiled.length === 0) return pages;
+	return pages.map((p) => {
+		let content = p.content;
+		for (const rule of compiled) {
+			if (rule.pageIdSet && !rule.pageIdSet.has(p.id)) continue;
+			content = content.replace(rule.re, rule.replacement);
+		}
+		if (content === p.content) return p;
+		return {
+			...p,
+			content
+		};
+	});
+};
+
 //#endregion
 //#region src/segmentation/fast-fuzzy-prefix.ts
 /**
@@ -2021,12 +2120,13 @@ const convertPageBreaks = (content, startOffset, pageBreaks) => {
 */
 const segmentPages = (pages, options) => {
 	const { rules = [], maxPages = 0, breakpoints = [], prefer = "longer", pageJoiner = "space", logger } = options;
-	const { content: matchContent, normalizedPages: normalizedContent, pageMap } = buildPageMap(pages);
+	const processedPages = options.replace ? applyReplacements(pages, options.replace) : pages;
+	const { content: matchContent, normalizedPages: normalizedContent, pageMap } = buildPageMap(processedPages);
 	let segments = buildSegments(dedupeSplitPoints(collectSplitPointsFromRules(rules, matchContent, pageMap)), matchContent, pageMap, rules);
-	segments = ensureFallbackSegment(segments, pages, normalizedContent, pageJoiner);
+	segments = ensureFallbackSegment(segments, processedPages, normalizedContent, pageJoiner);
 	if (maxPages >= 0 && breakpoints.length) {
 		const patternProcessor = (p) => processPattern(p, false).pattern;
-		return applyBreakpoints(segments, pages, normalizedContent, maxPages, breakpoints, prefer, patternProcessor, logger, pageJoiner);
+		return applyBreakpoints(segments, processedPages, normalizedContent, maxPages, breakpoints, prefer, patternProcessor, logger, pageJoiner);
 	}
 	return segments;
 };
@@ -2122,7 +2222,7 @@ const DEFAULT_OPTIONS = {
 	topK: 40,
 	whitespace: "regex"
 };
-const escapeRegexLiteral = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const escapeSignatureLiteral = (s) => s.replace(/[.*+?^${}|\\{}]/g, "\\$&");
 const TOKEN_PRIORITY_ORDER$1 = [
 	"basmalah",
 	"kitab",
@@ -2170,7 +2270,7 @@ const consumeLeadingPrefixes = (s, pos, out, prefixMatchers, whitespace) => {
 		if (currentPos >= s.length) break;
 		const m = re.exec(s.slice(currentPos));
 		if (!m || m.index !== 0 || !m[0]) continue;
-		currentOut += escapeRegexLiteral(m[0]);
+		currentOut += escapeSignatureLiteral(m[0]);
 		currentPos += m[0].length;
 		matchedAny = true;
 		const wsAfter = /^[ \t]+/u.exec(s.slice(currentPos));
@@ -2239,7 +2339,7 @@ const tokenizeLineStart = (line, tokenNames, prefixChars, includeFirstWordFallba
 		if (matchedAny) {
 			const ch = s[pos];
 			if (ch && isCommonDelimiter(ch)) {
-				out += escapeRegexLiteral(ch);
+				out += escapeSignatureLiteral(ch);
 				pos += 1;
 				continue;
 			}
@@ -2248,14 +2348,14 @@ const tokenizeLineStart = (line, tokenNames, prefixChars, includeFirstWordFallba
 			if (includeFirstWordFallback && !matchedToken) {
 				const firstWord$1 = (s.slice(pos).match(/^[^\s:،؛.?!؟]+/u) ?? [])[0];
 				if (!firstWord$1) break;
-				out += escapeRegexLiteral(firstWord$1);
+				out += escapeSignatureLiteral(firstWord$1);
 			}
 			break;
 		}
 		if (!includeFirstWordFallback) return null;
 		const firstWord = (s.slice(pos).match(/^[^\s:،؛.?!؟]+/u) ?? [])[0];
 		if (!firstWord) return null;
-		out += escapeRegexLiteral(firstWord);
+		out += escapeSignatureLiteral(firstWord);
 		return out;
 	}
 	if (!matchedAny) return null;
@@ -2492,5 +2592,5 @@ const analyzeTextForRule = (text) => {
 };
 
 //#endregion
-export { TOKEN_PATTERNS, analyzeCommonLineStarts, analyzeTextForRule, containsTokens, detectTokenPatterns, escapeRegex, escapeTemplateBrackets, expandCompositeTokensInTemplate, expandTokens, expandTokensWithCaptures, generateTemplateFromText, getAvailableTokens, getTokenPattern, makeDiacriticInsensitive, segmentPages, suggestPatternConfig, templateToRegex };
+export { TOKEN_PATTERNS, analyzeCommonLineStarts, analyzeTextForRule, applyReplacements, containsTokens, detectTokenPatterns, escapeRegex, escapeTemplateBrackets, expandCompositeTokensInTemplate, expandTokens, expandTokensWithCaptures, generateTemplateFromText, getAvailableTokens, getTokenPattern, makeDiacriticInsensitive, segmentPages, suggestPatternConfig, templateToRegex };
 //# sourceMappingURL=index.mjs.map