dsh-cait 1.0.4 → 1.0.5

package/lib/epub.js

@@ -0,0 +1,355 @@
+/**
+ * Dependency-free EPUB 3 reader/writer.
+ *
+ * EPUB is a ZIP package of XHTML documents listed in an OPF spine. Import
+ * walks the spine, scans each chapter into inline runs and stores the run
+ * ordinal in segment metadata. Export re-reads the untouched source package
+ * and replaces exactly those runs, so CSS, images, navigation and any chapter
+ * without translations survive byte-for-byte.
+ *
+ * PDF is intentionally not supported: fixed-layout pages have no reliable
+ * reading order or text flow, which makes them unsuitable for CAT work.
+ */
+import { posix } from 'node:path'
+import { CatError } from './errors.js'
+import { readZipEntries, writeZip } from './docx.js'
+import { parseHtmlBlocks, patchHtmlRuns, renderHtmlTokens } from './html.js'
+import { decodeXml, escapeXml } from './xml.js'
+
+export const EPUB_MIME = 'application/epub+zip'
+
+function readAttribute(source, name) {
+  const match = String(source ?? '').match(
+    new RegExp(`\\b${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*=\\s*["']([^"']*)["']`, 'i'),
+  )
+  return match ? decodeXml(match[1]) : ''
+}
+
+function lookupEntry(entriesByName, name) {
+  const normalized = String(name ?? '').replace(/^\.\//, '')
+  let decoded = normalized
+  try {
+    decoded = decodeURIComponent(normalized)
+  } catch {
+    // A stray percent sign is not valid URI escaping; keep the literal path.
+  }
+  return (
+    entriesByName.get(normalized) ??
+    entriesByName.get(decoded) ??
+    [...entriesByName.values()].find((item) => item.name.toLowerCase() === normalized.toLowerCase()) ??
+    null
+  )
+}
+
+function readTextEntry(entries, name) {
+  const entry = lookupEntry(entries, name)
+  return entry ? entry.data.toString('utf8') : ''
+}
+
+function resolveHref(baseDir, href) {
+  let clean = String(href ?? '').split('#')[0].replace(/\\/g, '/')
+  try {
+    clean = decodeURIComponent(clean)
+  } catch {
+    // A stray percent sign is not valid URI escaping; keep the literal path.
+  }
+  clean = clean.replace(/^\.\//, '')
+  if (!clean) return ''
+  const resolved = baseDir ? posix.join(baseDir, clean) : clean
+  return posix.normalize(resolved).replace(/^\.\//, '')
+}
+
+function parseContainer(xml) {
+  const match = String(xml ?? '').match(
+    /<(?:[\w.-]+:)?rootfile\b[^>]*\bfull-path\s*=\s*["']([^"']+)["']/i,
+  )
+  return match ? decodeXml(match[1]) : ''
+}
+
+function parseOpf(xml) {
+  const manifest = new Map()
+  for (const match of String(xml ?? '').matchAll(/<(?:[\w.-]+:)?item\b([^>]*?)\/?>/gi)) {
+    const attrs = match[1]
+    const id = readAttribute(attrs, 'id')
+    const href = readAttribute(attrs, 'href')
+    if (!id || !href) continue
+    manifest.set(id, {
+      href,
+      mediaType: readAttribute(attrs, 'media-type'),
+      properties: readAttribute(attrs, 'properties'),
+    })
+  }
+
+  const spineBlock = String(xml ?? '').match(
+    /<(?:[\w.-]+:)?spine\b[^>]*>([\s\S]*?)<\/(?:[\w.-]+:)?spine>/i,
+  )
+  const spine = []
+  if (spineBlock) {
+    for (const match of spineBlock[1].matchAll(/<(?:[\w.-]+:)?itemref\b([^>]*?)\/?>/gi)) {
+      const idref = readAttribute(match[1], 'idref')
+      if (idref) spine.push(idref)
+    }
+  }
+
+  const titleMatch = String(xml ?? '').match(
+    /<(?:[\w.-]+:)?title\b[^>]*>([\s\S]*?)<\/(?:[\w.-]+:)?title>/i,
+  )
+  const languageMatch = String(xml ?? '').match(
+    /<(?:[\w.-]+:)?language\b[^>]*>([\s\S]*?)<\/(?:[\w.-]+:)?language>/i,
+  )
+
+  return {
+    title: titleMatch ? decodeXml(titleMatch[1]).trim() : '',
+    language: languageMatch ? decodeXml(languageMatch[1]).trim() : '',
+    manifest,
+    spine,
+  }
+}
+
+function readPackage(buffer) {
+  let entries
+  try {
+    entries = readZipEntries(buffer, 'EPUB')
+  } catch (error) {
+    throw new CatError('EPUB_PARSE', `EPUB 解析失败: ${error?.message ?? error}`)
+  }
+  const byName = new Map(entries.map((entry) => [entry.name, entry]))
+  const container = readTextEntry(byName, 'META-INF/container.xml')
+  if (!container) throw new CatError('EPUB_PARSE', 'EPUB 缺少 META-INF/container.xml。')
+  const opfPath = parseContainer(container)
+  if (!opfPath) throw new CatError('EPUB_PARSE', 'EPUB 的 container.xml 中没有 rootfile。')
+  const opf = readTextEntry(byName, opfPath)
+  if (!opf) throw new CatError('EPUB_PARSE', `EPUB 缺少 OPF 文件: ${opfPath}`)
+  return {
+    entries,
+    byName,
+    opfPath,
+    opfDir: posix.dirname(opfPath) === '.' ? '' : posix.dirname(opfPath),
+    package: parseOpf(opf),
+  }
+}
+
+function chapterHref(baseDir, item) {
+  return resolveHref(baseDir, item.href)
+}
+
+function isHtmlItem(item) {
+  const type = String(item.mediaType || '').toLowerCase()
+  if (type) return type === 'application/xhtml+xml' || type === 'text/html'
+  return /\.x?html?$/i.test(item.href || '')
+}
+
+/**
+ * Parse an EPUB package into CAIT segments.
+ * Returns title/language so a fresh document inherits the book metadata.
+ */
+export function parseEpub(buffer) {
+  if (!Buffer.isBuffer(buffer) || !buffer.length) {
+    throw new CatError('EPUB_PARSE', 'EPUB 文件内容为空。')
+  }
+  const { byName, opfDir, package: pkg } = readPackage(buffer)
+  if (!pkg.spine.length) throw new CatError('EPUB_PARSE', 'EPUB 的 OPF 中没有 spine 书脊。')
+
+  const segments = []
+  const warnings = []
+  const chapters = []
+
+  for (const idref of pkg.spine) {
+    const item = pkg.manifest.get(idref)
+    if (!item || !isHtmlItem(item)) continue
+    if (/\bnav\b/i.test(item.properties || '')) continue
+    const href = chapterHref(opfDir, item)
+    const html = readTextEntry(byName, href)
+    if (!html) {
+      warnings.push(`EPUB 章节缺失，已跳过: ${href}`)
+      continue
+    }
+    const parsed = parseHtmlBlocks(html)
+    let imported = 0
+    for (const run of parsed.runs) {
+      segments.push({
+        source: run.text,
+        target: '',
+        paragraph: segments.length,
+        meta: {
+          format: 'epub',
+          epubHref: href.slice(0, 500),
+          epubBlock: run.index,
+          ...(run.tokens.length ? { inline: run.tokens } : {}),
+        },
+      })
+      imported += 1
+    }
+    if (imported) chapters.push({ href, units: imported })
+
+    if (!parsed.runs.length) {
+      warnings.push(`EPUB 章节没有可翻译的正文，已跳过: ${href}`)
+    }
+  }
+
+  if (!segments.length) throw new CatError('EPUB_NO_UNITS', 'EPUB 中没有可翻译的正文。')
+  return {
+    title: pkg.title,
+    language: pkg.language,
+    segments,
+    chapters,
+    warnings,
+  }
+}
+
+function segmentSource(segment) {
+  return String(segment?.source ?? '')
+}
+
+function translatedHtml(segment) {
+  const tokens = Array.isArray(segment?.meta?.inline) ? segment.meta.inline : []
+  let value = String(segment?.target ?? '')
+  if (!value) value = segmentSource(segment)
+  else if (tokens.some((item) => !value.includes(item.token))) value = segmentSource(segment)
+  return renderHtmlTokens(value, tokens)
+}
+
+/**
+ * Patch translated text into the original package. Falls back to the caller
+ * when the package no longer matches the stored segment metadata.
+ */
+export function buildEpub(doc, template) {
+  const { entries, byName, opfDir, package: pkg } = readPackage(template)
+  const groups = new Map()
+  const known = new Map(
+    [...pkg.manifest.values()]
+      .map((item) => [chapterHref(opfDir, item), item])
+      .filter(([href]) => href),
+  )
+
+  for (const segment of doc.segments) {
+    const href = segment?.meta?.epubHref
+    const block = Number(segment?.meta?.epubBlock)
+    if (typeof href !== 'string' || !href || !Number.isInteger(block) || block < 0) continue
+    if (!known.has(href)) continue
+    if (!groups.has(href)) groups.set(href, new Map())
+    groups.get(href).set(block, translatedHtml(segment))
+  }
+
+  if (!groups.size) throw new Error('EPUB 源文件中没有可回写的章节')
+
+  let patched = 0
+  for (const [href, replacements] of groups) {
+    const entry = lookupEntry(byName, href)
+    if (!entry) continue
+    const source = entry.data.toString('utf8')
+    entry.data = Buffer.from(patchHtmlRuns(source, replacements), 'utf8')
+    patched += 1
+  }
+  if (!patched) throw new Error('EPUB 源文件中没有可回写的章节')
+
+  return writeZip(
+    entries.map((entry) => ({
+      ...entry,
+      store: entry.name === 'mimetype',
+    })),
+  )
+}
+
+function paragraphText(doc, joiner) {
+  const groups = new Map()
+  for (const segment of doc.segments) {
+    const key = segment.paragraph ?? 0
+    if (!groups.has(key)) groups.set(key, [])
+    groups.get(key).push(segment)
+  }
+  return [...groups.values()]
+    .map((parts) => parts.map((segment) => translatedHtml(segment)).filter(Boolean).join(joiner).trim())
+    .filter(Boolean)
+    .join('\n')
+}
+
+/** Build a minimal, valid EPUB 3 package when no source package is available. */
+export function buildEpubFromText(doc) {
+  const lang = escapeXml(doc.targetLang || 'en')
+  const title = escapeXml(doc.name || 'CAIT export')
+  const identifier = escapeXml(`urn:cait:${doc.id || 'export'}`)
+  const modified = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z')
+  const body = paragraphText(doc, ' ')
+    .split('\n')
+    .filter(Boolean)
+    .map((paragraph) => `    <p>${paragraph}</p>`)
+    .join('\n')
+
+  const chapter = [
+    '<?xml version="1.0" encoding="utf-8"?>',
+    '<!DOCTYPE html>',
+    `<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="${lang}" lang="${lang}">`,
+    '  <head>',
+    '    <meta charset="utf-8"/>',
+    `    <title>${title}</title>`,
+    '  </head>',
+    '  <body>',
+    body || '    <p></p>',
+    '  </body>',
+    '</html>',
+    '',
+  ].join('\n')
+
+  const nav = [
+    '<?xml version="1.0" encoding="utf-8"?>',
+    '<!DOCTYPE html>',
+    `<html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops" xml:lang="${lang}" lang="${lang}">`,
+    '  <head>',
+    '    <meta charset="utf-8"/>',
+    `    <title>${title}</title>`,
+    '  </head>',
+    '  <body>',
+    '    <nav epub:type="toc" id="toc">',
+    '      <h1>Contents</h1>',
+    '      <ol>',
+    '        <li><a href="chapter.xhtml">1</a></li>',
+    '      </ol>',
+    '    </nav>',
+    '  </body>',
+    '</html>',
+    '',
+  ].join('\n')
+
+  const opf = [
+    '<?xml version="1.0" encoding="utf-8"?>',
+    '<package xmlns="http://www.idpf.org/2007/opf" version="3.0" unique-identifier="cait-id">',
+    '  <metadata xmlns:dc="http://purl.org/dc/elements/1.1/">',
+    `    <dc:identifier id="cait-id">${identifier}</dc:identifier>`,
+    `    <dc:title>${title}</dc:title>`,
+    `    <dc:language>${lang}</dc:language>`,
+    `    <meta property="dcterms:modified">${modified}</meta>`,
+    '  </metadata>',
+    '  <manifest>',
+    '    <item id="nav" href="nav.xhtml" media-type="application/xhtml+xml" properties="nav"/>',
+    '    <item id="chapter" href="chapter.xhtml" media-type="application/xhtml+xml"/>',
+    '  </manifest>',
+    '  <spine>',
+    '    <itemref idref="chapter"/>',
+    '  </spine>',
+    '</package>',
+    '',
+  ].join('\n')
+
+  return writeZip([
+    { name: 'mimetype', data: Buffer.from(EPUB_MIME, 'utf8'), store: true },
+    {
+      name: 'META-INF/container.xml',
+      data: Buffer.from(
+        [
+          '<?xml version="1.0" encoding="utf-8"?>',
+          '<container xmlns="urn:oasis:names:tc:opendocument:xmlns:container" version="1.0">',
+          '  <rootfiles>',
+          '    <rootfile full-path="OEBPS/content.opf" media-type="application/oebps-package+xml"/>',
+          '  </rootfiles>',
+          '</container>',
+          '',
+        ].join('\n'),
+        'utf8',
+      ),
+    },
+    { name: 'OEBPS/content.opf', data: Buffer.from(opf, 'utf8') },
+    { name: 'OEBPS/nav.xhtml', data: Buffer.from(nav, 'utf8') },
+    { name: 'OEBPS/chapter.xhtml', data: Buffer.from(chapter, 'utf8') },
+  ])
+}

package/lib/formats.js

@@ -8,6 +8,7 @@
  */
 import { CatError } from './errors.js'
 import { decodeXml, escapeXml } from './xml.js'
+import { parseHtmlBlocks, renderHtmlTokens } from './html.js'
 
 const SRT_TIME = /^(\d{1,3}):(\d{2}):(\d{2})[,.](\d{1,3})$/
 const VTT_TIME = /^(?:(\d{1,3}):)?(\d{1,2}):(\d{2})\.(\d{1,3})$/
@@ -69,7 +70,44 @@ function completeInline(value, tokens) {
   return output
 }
 
-export function parseCsvRows(text) {
+export function detectCsvDelimiter(text) {
+  const input = String(text ?? '').replace(/^\uFEFF/, '')
+  const candidates = [',', ';', '\t', '|']
+  const counts = new Map(candidates.map((candidate) => [candidate, 0]))
+  let quoted = false
+  let lines = 0
+
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index]
+    if (char === '"') {
+      if (quoted && input[index + 1] === '"') {
+        index += 1
+        continue
+      }
+      quoted = !quoted
+      continue
+    }
+    if (quoted) continue
+    if (char === '\n') {
+      lines += 1
+      if (lines >= 5) break
+      continue
+    }
+    if (counts.has(char)) counts.set(char, counts.get(char) + 1)
+  }
+
+  let best = ','
+  let bestCount = 0
+  for (const candidate of candidates) {
+    if (counts.get(candidate) > bestCount) {
+      best = candidate
+      bestCount = counts.get(candidate)
+    }
+  }
+  return best
+}
+
+export function parseCsvRows(text, delimiter = ',') {
   const input = String(text ?? '').replace(/^\uFEFF/, '').replace(/\r\n?/g, '\n')
   const rows = []
   let row = []
@@ -94,7 +132,7 @@ export function parseCsvRows(text) {
 
     if (char === '"' && field === '') {
       quoted = true
-    } else if (char === ',') {
+    } else if (char === delimiter) {
       row.push(field)
       field = ''
     } else if (char === '\n') {
@@ -116,7 +154,8 @@ export function parseCsvRows(text) {
 }
 
 export function parseCsv(text, { sourceColumn, targetColumn } = {}) {
-  const rows = parseCsvRows(text)
+  const delimiter = detectCsvDelimiter(text)
+  const rows = parseCsvRows(text, delimiter)
   if (!rows.length) throw formatError('CSV_PARSE', 'CSV 中没有可用的行。')
 
   const normalize = (value) => String(value ?? '').trim().toLowerCase()
@@ -344,7 +383,8 @@ export function buildSrt(doc) {
 export function buildVtt(doc) {
   const cues = buildCues(doc.segments).map(({ segment, times }) => {
     const identifier = segment.meta?.identifier ? `${segment.meta.identifier}\n` : ''
-    return `${identifier}${formatVttTime(times.start)} --> ${formatVttTime(times.end)}\n${subtitleText(segment)}\n`
+    const settings = segment.meta?.settings ? ` ${segment.meta.settings}` : ''
+    return `${identifier}${formatVttTime(times.start)} --> ${formatVttTime(times.end)}${settings}\n${subtitleText(segment)}\n`
   })
   return `WEBVTT\n\n${cues.join('\n')}`
 }
@@ -648,50 +688,47 @@ export function buildXliff2(doc) {
 }
 
 function htmlToText(input) {
-  let text = String(input ?? '').replace(/^\uFEFF/, '').replace(/\r\n?/g, '\n')
-  text = text
-    .replace(/<!--[\s\S]*?-->/g, '')
-    .replace(/<(script|style|noscript|head)\b[\s\S]*?<\/\1>/gi, '')
-    .replace(/<br\s*\/?>/gi, '\n')
-    .replace(/<\/(?:p|div|li|h[1-6]|section|article|blockquote|pre|tr)>/gi, '\n\n')
-    .replace(/<\/(?:td|th)>/gi, '\t')
-    .replace(/<[^>]+>/g, '')
-  return decodeXml(text)
-    .replace(/[ \t]+\n/g, '\n')
-    .replace(/\n{3,}/g, '\n\n')
-    .trim()
+  const { runs } = parseHtmlBlocks(input)
+  return runs.map((run) => run.text).join('\n\n').trim()
 }
 
 export function parseHtml(text) {
   const input = String(text ?? '')
   if (!input.trim()) throw formatError('HTML_PARSE', 'HTML 文件内容为空。')
-  const plain = htmlToText(input)
-  if (!plain) throw formatError('HTML_NO_UNITS', 'HTML 中没有可用的正文。')
-  const segments = plain
-    .split(/\n{2,}/)
-    .map((part) => part.trim())
-    .filter(Boolean)
-    .map((source, index) => ({
-      source,
-      target: '',
-      paragraph: index,
-      meta: { format: 'html' },
-    }))
-  if (!segments.length) throw formatError('HTML_NO_UNITS', 'HTML 中没有可用的正文。')
+  const { runs } = parseHtmlBlocks(input)
+  if (!runs.length) throw formatError('HTML_NO_UNITS', 'HTML 中没有可用的正文。')
+  const segments = runs.map((run, index) => ({
+    source: run.text,
+    target: '',
+    paragraph: index,
+    meta: {
+      format: 'html',
+      ...(run.tokens.length ? { inline: run.tokens } : {}),
+    },
+  }))
   return { format: 'html', segments, warnings: [] }
 }
 
+function renderHtmlSegment(segment) {
+  const tokens = Array.isArray(segment?.meta?.inline) ? segment.meta.inline : []
+  let value = String(segment?.target || segment?.source || '')
+  if (tokens.length && tokens.some((item) => !value.includes(item.token))) {
+    value = String(segment?.source ?? '')
+  }
+  return tokens.length ? renderHtmlTokens(value, tokens) : escapeXml(value)
+}
+
 export function buildHtml(doc) {
   const groups = new Map()
   for (const segment of doc.segments) {
     const key = segment.paragraph ?? 0
     if (!groups.has(key)) groups.set(key, [])
-    groups.get(key).push(String(segment.target || segment.source || '').trim())
+    groups.get(key).push(segment)
   }
   const paragraphs = [...groups.values()]
-    .map((parts) => parts.filter(Boolean).join(' '))
+    .map((parts) => parts.map((segment) => renderHtmlSegment(segment).trim()).filter(Boolean).join(' '))
     .filter(Boolean)
-    .map((text) => `  <p>${escapeXml(text)}</p>`)
+    .map((text) => `  <p>${text}</p>`)
     .join('\n')
   return [
     '<!doctype html>',
@@ -743,7 +780,7 @@ function setJsonPointer(root, pointer, value) {
 }
 
 export function parseJson(text) {
-  const input = String(text ?? '')
+  const input = String(text ?? '').replace(/^\uFEFF/, '')
   if (!input.trim()) throw formatError('JSON_PARSE', 'JSON 文件内容为空。')
   let root
   try {
@@ -836,6 +873,16 @@ export function parseRtf(text) {
       index += 2
       continue
     }
+    if (next === '~') {
+      output += ' '
+      index += 2
+      continue
+    }
+    if (next === '_') {
+      output += '-'
+      index += 2
+      continue
+    }
     let cursor = index + 1
     let sign = 1
     if (input[cursor] === '-') {
@@ -855,6 +902,14 @@ export function parseRtf(text) {
     if (word === 'par') output += '\n\n'
     else if (word === 'line') output += '\n'
     else if (word === 'tab') output += '\t'
+    else if (word === 'cell') output += '\t'
+    else if (word === 'row') output += '\n'
+    else if (word === 'page' || word === 'sect') output += '\n\n'
+    else if (word === 'emdash') output += '—'
+    else if (word === 'endash') output += '–'
+    else if (word === 'bullet') output += '•'
+    else if (word === 'lquote' || word === 'rquote') output += "'"
+    else if (word === 'ldblquote' || word === 'rdblquote') output += '"'
     else if (word === 'uc' && value !== null) unicodeSkip = Math.max(0, value)
     else if (word === 'u' && value !== null) {
       output += rtfUnicode(value)