@daviddh/llm-markdown-whatsapp 0.0.1

package/packages/core/src/chatSplit/sections.ts

@@ -0,0 +1,243 @@
+/** Result of finding a markdown section */
+export interface MarkdownSectionResult {
+  header: string;
+  content: string;
+  fullSection: string;
+}
+
+/** Result of finding a list section */
+export interface ListSectionResult {
+  start: number;
+  end: number;
+  type: 'numbered' | 'bullet';
+}
+
+/** Constants for section processing */
+const NOT_FOUND = -1;
+const FIRST_ELEMENT = 1;
+const DOUBLE_NEWLINE_LENGTH = 2;
+const ZERO = 0;
+const INCREMENT = 1;
+
+/** Check if text after double newline starts with a markdown header */
+const startsWithMarkdownHeader = (text: string): boolean => /^(?:\*[^*\n]+\*|_[^_\n]+_)\s*\n/v.test(text);
+
+/** Check if text starts with a bullet list item */
+const startsWithBullet = (text: string): boolean => /^[\-•]\s+/v.test(text.trim());
+
+/** Determine end index based on content after double newline */
+const determineEndIndex = (
+  afterDoubleNewline: string,
+  doubleNewlineIndex: number,
+  defaultEndIndex: number
+): number => {
+  if (startsWithMarkdownHeader(afterDoubleNewline)) {
+    return doubleNewlineIndex;
+  }
+  if (startsWithBullet(afterDoubleNewline)) {
+    return defaultEndIndex;
+  }
+  return doubleNewlineIndex;
+};
+
+/** Get line at index safely */
+const getLineAt = (lines: string[], index: number): string | undefined => lines[index];
+
+/**
+ * Detects if text starts with a markdown section header
+ * Returns the header and its content if found
+ */
+export const findMarkdownSection = (text: string): MarkdownSectionResult | null => {
+  const headerMatch = /^(?<header>\*[^*\n]+\*|_[^_\n]+_)\s*\n/v.exec(text);
+
+  if (headerMatch === null) {
+    return null;
+  }
+
+  const { groups } = headerMatch;
+  const header = groups?.header ?? headerMatch[FIRST_ELEMENT] ?? '';
+  const [matchedText = ''] = headerMatch;
+  const afterHeader = text.substring(matchedText.length);
+  const { length: defaultEndIndex } = afterHeader;
+
+  const doubleNewlineIndex = afterHeader.indexOf('\n\n');
+
+  const endIndex =
+    doubleNewlineIndex === NOT_FOUND
+      ? defaultEndIndex
+      : determineEndIndex(
+          afterHeader.substring(doubleNewlineIndex + DOUBLE_NEWLINE_LENGTH),
+          doubleNewlineIndex,
+          defaultEndIndex
+        );
+
+  const content = afterHeader.substring(ZERO, endIndex);
+  const fullSection = matchedText + content;
+
+  return { header, content, fullSection };
+};
+
+/** Test if line is a numbered list item */
+const isNumberedListItem = (line: string): boolean => /^\s*\d{1,2}\.\s+/v.test(line);
+
+/** Test if line is a bullet list item */
+const isBulletListItem = (line: string): boolean => /^\s*[\-•]\s+/v.test(line);
+
+/** Find the next non-empty line index in an array of lines */
+const findNextNonEmptyIndex = (lines: string[], startIndex: number): number => {
+  for (let j = startIndex; j < lines.length; j += INCREMENT) {
+    const line = getLineAt(lines, j);
+    if (line !== undefined && line.trim() !== '') {
+      return j;
+    }
+  }
+  return NOT_FOUND;
+};
+
+/** Check if next line is a list continuation */
+const isListContinuation = (lines: string[], nextNonEmptyIndex: number): boolean => {
+  if (nextNonEmptyIndex === NOT_FOUND) return false;
+  const nextLine = getLineAt(lines, nextNonEmptyIndex) ?? '';
+  return isNumberedListItem(nextLine) || isBulletListItem(nextLine);
+};
+
+/** Numbered list state */
+interface NumberedListState {
+  endLineIndex: number;
+  inList: boolean;
+}
+
+/** Process numbered list line result */
+interface NumberedListLineResult {
+  action: 'continue' | 'break' | 'next';
+  newState: NumberedListState;
+}
+
+/** Process a single line in numbered list - returns new state */
+const processNumberedListLine = (
+  line: string,
+  currentIndex: number,
+  lines: string[],
+  currentState: NumberedListState
+): NumberedListLineResult => {
+  const isNumbered = isNumberedListItem(line);
+  const isBullet = isBulletListItem(line);
+
+  if (isNumbered) {
+    return { action: 'next', newState: { inList: true, endLineIndex: currentIndex } };
+  }
+
+  if (isBullet && currentState.inList) {
+    return { action: 'next', newState: { ...currentState, endLineIndex: currentIndex } };
+  }
+
+  if (currentState.inList && line.trim() === '') {
+    const nextNonEmptyIndex = findNextNonEmptyIndex(lines, currentIndex + INCREMENT);
+    const action = isListContinuation(lines, nextNonEmptyIndex) ? 'continue' : 'break';
+    return { action, newState: currentState };
+  }
+
+  if (currentState.inList) {
+    return { action: 'break', newState: currentState };
+  }
+
+  return { action: 'next', newState: currentState };
+};
+
+/** Process numbered list to find end index */
+const processNumberedList = (lines: string[]): number => {
+  let state: NumberedListState = { endLineIndex: NOT_FOUND, inList: false };
+
+  for (let i = ZERO; i < lines.length; i += INCREMENT) {
+    const line = getLineAt(lines, i);
+    if (line === undefined) continue;
+
+    const { action, newState } = processNumberedListLine(line, i, lines, state);
+    state = newState;
+    if (action === 'break') break;
+  }
+
+  return state.endLineIndex >= ZERO
+    ? lines.slice(ZERO, state.endLineIndex + INCREMENT).join('\n').length
+    : ZERO;
+};
+
+/** Bullet list state */
+interface BulletListState {
+  endIndex: number;
+  inList: boolean;
+}
+
+/** Process bullet list line result */
+interface BulletListLineResult {
+  action: 'continue' | 'break' | 'next';
+  newState: BulletListState;
+}
+
+/** Process a single line in bullet list - returns new state */
+const processBulletListLine = (
+  line: string,
+  currentIndex: number,
+  lines: string[],
+  currentState: BulletListState
+): BulletListLineResult => {
+  const isBullet = /^[\-•]\s+/v.test(line.trim());
+
+  if (isBullet) {
+    const { length: newEndIndex } = lines.slice(ZERO, currentIndex + INCREMENT).join('\n');
+    return { action: 'next', newState: { inList: true, endIndex: newEndIndex } };
+  }
+
+  if (currentState.inList && line.trim() === '') {
+    const nextLine = getLineAt(lines, currentIndex + INCREMENT);
+    if (nextLine !== undefined && /^[\-•]\s+/v.test(nextLine.trim())) {
+      return { action: 'continue', newState: currentState };
+    }
+    return { action: 'break', newState: currentState };
+  }
+
+  if (currentState.inList) {
+    return { action: 'break', newState: currentState };
+  }
+
+  return { action: 'next', newState: currentState };
+};
+
+/** Process bullet list to find end index */
+const processBulletList = (lines: string[]): number => {
+  let state: BulletListState = { endIndex: ZERO, inList: false };
+
+  for (let i = ZERO; i < lines.length; i += INCREMENT) {
+    const line = getLineAt(lines, i);
+    if (line === undefined) continue;
+
+    const { action, newState } = processBulletListLine(line, i, lines, state);
+    state = newState;
+    if (action === 'break') break;
+  }
+
+  return state.endIndex;
+};
+
+/**
+ * Detects if text is within a list section (numbered or bulleted)
+ * Returns the boundaries of the list if found
+ */
+export const findListSection = (text: string): ListSectionResult | null => {
+  const numberedListStart = /^\d{1,2}\.\s+/v;
+  const bulletListStart = /^[\-•]\s+/v;
+
+  if (numberedListStart.test(text.trim())) {
+    const lines = text.split('\n');
+    const endIndex = processNumberedList(lines);
+    return { start: ZERO, end: endIndex, type: 'numbered' };
+  }
+
+  if (bulletListStart.test(text.trim())) {
+    const lines = text.split('\n');
+    const endIndex = processBulletList(lines);
+    return { start: ZERO, end: endIndex, type: 'bullet' };
+  }
+
+  return null;
+};

package/packages/core/src/chatSplit/splitChatText.ts

@@ -0,0 +1,156 @@
+import { processSectionBreaks } from './breakProcessor.js';
+import { ZERO } from './constants.js';
+import { normalizeInlineNumberedList, normalizeInlineProductCardList } from './listNormalization.js';
+import { processListSection } from './listProcessor.js';
+import { mergeSmallChunks } from './mergeProcessor.js';
+import {
+  processLongParagraphSequence,
+  processLongParagraphsAfterIntro,
+  processMarkdownSection,
+} from './paragraphProcessor.js';
+import { processPeriodSplits } from './periodProcessor.js';
+import { processProductCardLists } from './productCardProcessor.js';
+import { normalizeSpanishPunctuation } from './punctuationNormalization.js';
+import { processQuestionMarks } from './questionProcessor.js';
+import { PERIOD_SPLIT_TEXT_THRESHOLD } from './splitConstants.js';
+import {
+  processIntroWithList,
+  processIntroWithLongParagraphs,
+  processQuestionWithList,
+} from './splitProcessors.js';
+import { removePeriodsAfterURLs } from './urlNormalization.js';
+
+/** Split result type for processor functions */
+interface SplitProcessorResult {
+  splitFound: boolean;
+  newRemainingText: string;
+}
+
+/** Run intro and list processors */
+const runIntroAndListProcessors = (remainingText: string, chunks: string[]): SplitProcessorResult | null => {
+  const introResult = processIntroWithList(remainingText, chunks);
+  if (introResult.splitFound) return introResult;
+
+  const questionListResult = processQuestionWithList(remainingText, chunks);
+  if (questionListResult.splitFound) return questionListResult;
+
+  const longParaResult = processIntroWithLongParagraphs(remainingText, chunks);
+  if (longParaResult.splitFound) return longParaResult;
+
+  return null;
+};
+
+/** Run content structure processors */
+const runContentStructureProcessors = (
+  remainingText: string,
+  chunks: string[]
+): SplitProcessorResult | null => {
+  const productCardResult = processProductCardLists(remainingText, chunks);
+  if (productCardResult.splitFound) return productCardResult;
+
+  const listResult = processListSection(remainingText, chunks);
+  if (listResult.splitFound) return listResult;
+
+  const longParaAfterIntroResult = processLongParagraphsAfterIntro(remainingText, chunks);
+  if (longParaAfterIntroResult.splitFound) return longParaAfterIntroResult;
+
+  const longParagraphResult = processLongParagraphSequence(remainingText, chunks);
+  if (longParagraphResult.splitFound) return longParagraphResult;
+
+  return null;
+};
+
+/** Run formatting processors */
+const runFormattingProcessors = (remainingText: string, chunks: string[]): SplitProcessorResult | null => {
+  const markdownResult = processMarkdownSection(remainingText, chunks);
+  if (markdownResult.splitFound) return markdownResult;
+
+  const sectionBreakResult = processSectionBreaks(remainingText, chunks);
+  if (sectionBreakResult.splitFound) return sectionBreakResult;
+
+  return null;
+};
+
+/**
+ * Runs all split processors on the remaining text
+ */
+const runSplitProcessors = (remainingText: string, chunks: string[]): SplitProcessorResult => {
+  const introResult = runIntroAndListProcessors(remainingText, chunks);
+  if (introResult !== null) return introResult;
+
+  const contentResult = runContentStructureProcessors(remainingText, chunks);
+  if (contentResult !== null) return contentResult;
+
+  const formatResult = runFormattingProcessors(remainingText, chunks);
+  if (formatResult !== null) return formatResult;
+
+  return { splitFound: false, newRemainingText: remainingText };
+};
+
+/**
+ * Runs question and period processors
+ */
+const runQuestionAndPeriodProcessors = (remainingText: string, chunks: string[]): SplitProcessorResult => {
+  const questionResult = processQuestionMarks(remainingText, chunks);
+  if (questionResult.splitFound) {
+    return questionResult;
+  }
+
+  if (remainingText.length > PERIOD_SPLIT_TEXT_THRESHOLD) {
+    const periodResult = processPeriodSplits(remainingText, chunks);
+    if (periodResult.splitFound) {
+      return periodResult;
+    }
+  }
+
+  return { splitFound: false, newRemainingText: remainingText };
+};
+
+/** Pre-process text before splitting */
+const preProcessText = (text: string): string => {
+  let processedText = removePeriodsAfterURLs(text);
+  processedText = normalizeInlineNumberedList(processedText);
+  processedText = normalizeInlineProductCardList(processedText);
+  return processedText;
+};
+
+/**
+ * Splits chat text into smaller chunks for better readability.
+ * Handles various patterns like lists, questions, markdown sections, etc.
+ */
+export const splitChatText = (text: string | null | undefined): string[] => {
+  if (text === null || text === undefined || text.length === ZERO) {
+    return [];
+  }
+
+  const processedText = preProcessText(text);
+  const chunks: string[] = [];
+  let remainingText = processedText;
+
+  while (remainingText !== '') {
+    const { splitFound, newRemainingText } = runSplitProcessors(remainingText, chunks);
+
+    if (splitFound) {
+      remainingText = newRemainingText;
+      continue;
+    }
+
+    const { splitFound: qpSplitFound, newRemainingText: qpNewText } = runQuestionAndPeriodProcessors(
+      remainingText,
+      chunks
+    );
+
+    if (qpSplitFound) {
+      remainingText = qpNewText;
+      continue;
+    }
+
+    chunks.push(remainingText);
+    break;
+  }
+
+  const mergedChunks = mergeSmallChunks(chunks);
+  const normalizedChunks = mergedChunks.map((chunk) => normalizeSpanishPunctuation(chunk));
+
+  return normalizedChunks;
+};

package/packages/core/src/chatSplit/splitConstants.ts

@@ -0,0 +1,2 @@
+/** Short text threshold for period splitting */
+export const PERIOD_SPLIT_TEXT_THRESHOLD = 100;

package/packages/core/src/chatSplit/splitProcessors.ts

@@ -0,0 +1,153 @@
+import {
+  FIRST_NEWLINE_SEARCH_LIMIT,
+  INDEX_OFFSET,
+  MAX_INTRO_LENGTH,
+  MAX_QUESTION_WITH_OPTIONS_LENGTH,
+} from './constants.js';
+
+/** Long paragraph threshold */
+const LONG_PARAGRAPH_THRESHOLD = 150;
+
+/** Minimum list items for question with options */
+const MIN_LIST_ITEMS_FOR_OPTIONS = 2;
+
+/** Constants */
+const NOT_FOUND = -1;
+const ZERO = 0;
+const FIRST_MATCH = 1;
+const SECOND_MATCH = 2;
+
+/** Split result type */
+export interface SplitResult {
+  splitFound: boolean;
+  newRemainingText: string;
+}
+
+/**
+ * Checks if text has a question with response options pattern
+ */
+export const hasQuestionWithOptionsPattern = (text: string): boolean =>
+  /^[^?]+\?\s*\n+[\s\S]*?(?:Puedes responder con|puedes responder con):[\s\S]*?\n+-/v.test(text);
+
+/** Check if line ends with colon */
+const lineEndsWithColon = (line: string | undefined): boolean => line?.trim().endsWith(':') === true;
+
+/** Find the last line ending with colon */
+const findLastColonLineIndex = (lines: string[]): number => {
+  for (let i = lines.length - INDEX_OFFSET; i >= ZERO; i -= INDEX_OFFSET) {
+    if (lineEndsWithColon(lines[i])) {
+      return i;
+    }
+  }
+  return NOT_FOUND;
+};
+
+/** Extract intro from match groups */
+const extractIntro = (match: RegExpExecArray): string => {
+  const { groups } = match;
+  const part1 = groups?.intro ?? match[FIRST_MATCH] ?? '';
+  const part2 = groups?.afterColon ?? match[SECOND_MATCH] ?? '';
+  return part1 + part2;
+};
+
+/** Adjust intro for response prompts */
+const adjustIntroForResponsePrompt = (intro: string): string => {
+  if (!intro.includes('Puedes responder con:') && !intro.includes('puedes responder con:')) {
+    return intro;
+  }
+
+  const lines = intro.split('\n');
+  const lastColonIndex = findLastColonLineIndex(lines);
+
+  if (lastColonIndex >= ZERO) {
+    return lines.slice(ZERO, lastColonIndex + INDEX_OFFSET).join('\n');
+  }
+
+  return intro;
+};
+
+/**
+ * Processes intro with list pattern and returns split info
+ */
+export const processIntroWithList = (remainingText: string, chunks: string[]): SplitResult => {
+  const match = /^(?<intro>.+?:)(?<afterColon>[^\n]*?)\n+(?<listStart>\d{1,2}\.\s+|[\-•]\s+)/v.exec(
+    remainingText
+  );
+
+  if (match === null) {
+    return { splitFound: false, newRemainingText: remainingText };
+  }
+
+  const intro = extractIntro(match);
+  const finalIntro = adjustIntroForResponsePrompt(intro);
+
+  if (finalIntro.length < MAX_INTRO_LENGTH) {
+    chunks.push(finalIntro);
+    return { splitFound: true, newRemainingText: remainingText.substring(finalIntro.length).trim() };
+  }
+
+  return { splitFound: false, newRemainingText: remainingText };
+};
+
+/**
+ * Processes question followed by numbered list (answer options)
+ */
+export const processQuestionWithList = (remainingText: string, chunks: string[]): SplitResult => {
+  const match = /^(?<question>[\s\S]*?\?[^\n]*?)\n(?<list>\d{1,2}\.\s+[\s\S]*)/v.exec(remainingText);
+
+  if (match === null) {
+    return { splitFound: false, newRemainingText: remainingText };
+  }
+
+  const { groups } = match;
+  const listPart = groups?.list ?? match[SECOND_MATCH] ?? '';
+  const listLines = listPart.split('\n');
+  const allLinesAreListItems = listLines.every(
+    (line) => line.trim() === '' || /^\d{1,2}\.\s+/v.test(line.trim())
+  );
+  const { length: listItemCount } = listLines.filter((l) => /^\d{1,2}\.\s+/v.test(l.trim()));
+
+  const shouldProcess =
+    allLinesAreListItems &&
+    remainingText.length < MAX_QUESTION_WITH_OPTIONS_LENGTH &&
+    listItemCount >= MIN_LIST_ITEMS_FOR_OPTIONS;
+
+  if (shouldProcess) {
+    chunks.push(remainingText);
+    return { splitFound: true, newRemainingText: '' };
+  }
+
+  return { splitFound: false, newRemainingText: remainingText };
+};
+
+/** Check if intro ends with list pattern */
+const endsWithListPattern = (intro: string): boolean =>
+  /\d{1,2}\.\s*$/v.exec(intro) !== null || /[\-•]\s*$/v.exec(intro) !== null;
+
+/**
+ * Processes intro followed by long paragraphs
+ */
+export const processIntroWithLongParagraphs = (remainingText: string, chunks: string[]): SplitResult => {
+  const firstNewline = remainingText.indexOf('\n');
+
+  if (firstNewline === NOT_FOUND || firstNewline >= FIRST_NEWLINE_SEARCH_LIMIT) {
+    return { splitFound: false, newRemainingText: remainingText };
+  }
+
+  const intro = remainingText.substring(ZERO, firstNewline).trim();
+
+  if (!intro.endsWith(':') || endsWithListPattern(intro)) {
+    return { splitFound: false, newRemainingText: remainingText };
+  }
+
+  const afterIntro = remainingText.substring(firstNewline + INDEX_OFFSET);
+  const [firstParagraphRaw] = afterIntro.split('\n');
+  const firstParagraph = (firstParagraphRaw ?? '').trim();
+
+  if (firstParagraph.length > LONG_PARAGRAPH_THRESHOLD) {
+    chunks.push(intro);
+    return { splitFound: true, newRemainingText: afterIntro };
+  }
+
+  return { splitFound: false, newRemainingText: remainingText };
+};

package/packages/core/src/chatSplit/textHelpers.ts

@@ -0,0 +1,86 @@
+/** Empty length constant */
+const EMPTY_LENGTH = 0;
+
+/** First character index */
+const FIRST_INDEX = 0;
+
+/**
+ * Smart trim that only removes whitespace but preserves emojis and other Unicode characters
+ */
+export const smartTrim = (str: string): string =>
+  // Remove only ASCII whitespace characters and common Unicode spaces
+  str
+    .replace(/^[\s\u00A0\u1680\u2000-\u200B\u202F\u205F\u3000]+/v, '')
+    .replace(/[\s\u00A0\u1680\u2000-\u200B\u202F\u205F\u3000]+$/v, '');
+
+/**
+ * Check if a string contains only whitespace and/or emojis (no actual text content)
+ */
+export const hasTextContent = (str: string): boolean => {
+  const trimmed = smartTrim(str);
+  if (trimmed.length === EMPTY_LENGTH) return false;
+
+  // Check if the trimmed string contains any alphanumeric or punctuation characters
+  // If it only contains emojis/symbols, we don't consider it as having text content for splitting purposes
+  const hasAlphaNumeric = /[a-zA-Z0-9\u00C0-\u024F\u1E00-\u1EFF]/v.test(trimmed);
+  return hasAlphaNumeric;
+};
+
+/**
+ * Check if text after a question mark is just a parenthetical clarification
+ * that should stay with the question (e.g., "(XS, S o M)?")
+ */
+export const isParentheticalClarification = (str: string): boolean => {
+  const trimmed = smartTrim(str);
+  if (trimmed.length === EMPTY_LENGTH) return false;
+
+  // Check if it starts with opening parenthesis and contains a closing question mark
+  // Pattern: (something)?
+  const parentheticalPattern = /^\([^\)]+\)\?/v;
+  return parentheticalPattern.test(trimmed);
+};
+
+/** Emoji pattern for detection with Unicode property escape */
+const EMOJI_PATTERN = /\p{Emoji}/v;
+
+/**
+ * Check if text starts with an emoji using Unicode property escapes
+ */
+export const startsWithEmoji = (str: string): boolean => {
+  if (str === '' || str.length === EMPTY_LENGTH) return false;
+  const match = EMOJI_PATTERN.exec(str);
+  return match !== null && match.index === FIRST_INDEX;
+};
+
+/**
+ * Check if text starts with a lowercase letter (indicating continuation of sentence)
+ */
+export const startsWithLowercase = (str: string): boolean => {
+  if (str === '' || str.length === EMPTY_LENGTH) return false;
+
+  // Find the first alphabetic character (skipping whitespace and symbols)
+  const firstLetterMatch = /[a-zA-ZáéíóúüñÁÉÍÓÚÜÑàèìòùÀÈÌÒÙâêîôûÂÊÎÔÛäëïöüÄËÏÖÜ]/v.exec(str);
+  if (firstLetterMatch === null) return false;
+
+  const [firstLetter] = firstLetterMatch;
+  // Check if it's lowercase
+  return firstLetter === firstLetter.toLowerCase() && firstLetter !== firstLetter.toUpperCase();
+};
+
+/**
+ * Find the position after the emoji (including any trailing spaces)
+ * Returns the index where actual text content starts
+ */
+export const findPositionAfterEmoji = (str: string): number => {
+  if (str === '' || str.length === EMPTY_LENGTH) return FIRST_INDEX;
+
+  // Match emoji at the start using Unicode property escape, potentially followed by whitespace
+  const emojiWithSpacePattern = /^\p{Emoji}+\s*/v;
+  const match = emojiWithSpacePattern.exec(str);
+
+  if (match !== null) {
+    return match[FIRST_INDEX].length;
+  }
+
+  return FIRST_INDEX;
+};

package/packages/core/src/chatSplit/urlNormalization.ts

@@ -0,0 +1,17 @@
+/**
+ * Replaces periods immediately after URLs with line breaks.
+ * URLs never end with periods - the period is sentence punctuation that should be separated.
+ * Example: "Visit https://nike.com.co. We have products" → "Visit https://nike.com.co\nWe have products"
+ */
+export const removePeriodsAfterURLs = (text: string): string => {
+  // Match URLs (http/https/www) - allow multiple periods in domain, but capture trailing period separately
+  // Pattern matches the entire URL (including all periods in the domain) followed by a period and space/end
+  const urlWithPeriodPattern = /(?<url>https?:\/\/[^\s]+?|www\.[^\s]+?)\.(?<after>\s|$)/gv;
+
+  return text.replace(
+    urlWithPeriodPattern,
+    (_match, url: string, afterPeriod: string) =>
+      // Replace the period with a line break, preserve whatever comes after (space or end)
+      `${url}\n${afterPeriod}`
+  );
+};

package/packages/core/src/index.ts

@@ -0,0 +1 @@
+export { splitChatText } from './chatSplit/index.js';

package/packages/core/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "dist", "src/__tests__"]
+}

package/packages/core/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "target": "ES2024",
+    "lib": ["ES2024"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "incremental": true,
+    "declaration": true,
+    "declarationMap": true,
+    "composite": true,
+    "types": ["node", "jest"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}