dsh-cait 1.0.4 → 1.1.3

package/index.js

@@ -42,4 +42,7 @@ export function apply(ctx, config = {}) {
 
   ctx.effect(() => registerCatTools(ctx, store))
   ctx.effect(() => registerCatApi(ctx, store))
+  // Cursor and draft edits are debounced; flush them when the plugin unloads so
+  // a restart lands on the same segment with the same draft.
+  ctx.effect(() => () => store.flushPersist())
 }

package/lib/aligner.js

@@ -0,0 +1,411 @@
+import { CatError } from './errors.js'
+import { splitIntoSegments } from './segmenter.js'
+import { normalizeText } from './similarity.js'
+import { cleanLang, cleanText } from './store-utils.js'
+
+/**
+ * Cross-language alignment of two separate files.
+ *
+ * Literal similarity is useless here: "3 modes" and "3 种模式" share no
+ * characters. What survives translation are structural signals — numbers,
+ * placeholders, URLs, all-caps names, relative length and paragraph position —
+ * so the score is built from those instead.
+ */
+
+export const ALIGN_WEIGHTS = { anchor: 0.45, length: 0.35, struct: 0.2 }
+export const ALIGN_HIGH = 0.6
+export const ALIGN_MEDIUM = 0.35
+export const ALIGN_SKIP_COST = 1
+export const ALIGN_MERGE_PENALTY = 0.15
+// A merge glues two sentences of one side onto one of the other. Without hard
+// evidence (a shared number, placeholder or name) that is almost always a
+// wrong pairing invented to make the totals look neat, so merges need a real
+// score before they are even considered.
+export const ALIGN_MERGE_MIN_SCORE = 0.55
+export const ALIGN_MAX_CELLS = 4_000_000
+export const ALIGN_BLOCK_SIZE = 500
+
+const ANCHOR_PATTERNS = [
+  /\{\d+\}/g,
+  /https?:\/\/[^\s)]+/gi,
+  /\b\d[\d.,]*%?/g,
+  /\b[A-Z][A-Z0-9]{1,}\b/g,
+  /\b[a-z]+[A-Z][A-Za-z0-9]*\b/g,
+]
+
+function anchorsIn(text) {
+  const found = []
+  const value = String(text ?? '')
+  for (const pattern of ANCHOR_PATTERNS) {
+    for (const match of value.match(pattern) || []) {
+      found.push(match.replace(/[.,]$/, '').toLocaleLowerCase())
+    }
+  }
+  return found
+}
+
+/** Multiset Dice over anchors. No anchors at all is neutral, not a failure. */
+export function anchorOverlap(left, right) {
+  const a = anchorsIn(left)
+  const b = anchorsIn(right)
+  if (!a.length && !b.length) return 0.5
+  if (!a.length || !b.length) return 0
+  const counts = new Map()
+  for (const item of a) counts.set(item, (counts.get(item) || 0) + 1)
+  let shared = 0
+  for (const item of b) {
+    const remaining = counts.get(item) || 0
+    if (remaining > 0) {
+      shared += 1
+      counts.set(item, remaining - 1)
+    }
+  }
+  return (2 * shared) / (a.length + b.length)
+}
+
+function median(values) {
+  const clean = values.filter((value) => value > 0).sort((a, b) => a - b)
+  if (!clean.length) return 1
+  return clean[Math.floor(clean.length / 2)]
+}
+
+/**
+ * Gale-Church style length hypothesis: compare each length against the median
+ * of its own language, so a Chinese sentence can match an English sentence
+ * that is 1.8× longer without any language-specific table.
+ */
+export function lengthFit(leftLength, rightLength, medianLeft, medianRight) {
+  const ratioLeft = leftLength / (medianLeft || 1)
+  const ratioRight = rightLength / (medianRight || 1)
+  if (!ratioLeft && !ratioRight) return 0.5
+  if (!ratioLeft || !ratioRight) return 0
+  const spread = Math.max(ratioLeft, ratioRight)
+  return Math.max(0, 1 - Math.abs(ratioLeft - ratioRight) / (spread || 1))
+}
+
+function isHeadingLike(text) {
+  const value = String(text ?? '').trim()
+  if (!value) return false
+  if (value.length > 60) return false
+  return !/[.!?。！？:：;；]$/.test(value)
+}
+
+/**
+ * Structure signal: same paragraph number, both sides headings, or adjacent
+ * paragraphs (a merge or split shifts numbers by one).
+ */
+export function structMatch(left, right) {
+  let score = 0
+  if (left.paragraph === right.paragraph) score += 0.5
+  if (isHeadingLike(left.source) && isHeadingLike(right.source)) score += 0.5
+  else if (Math.abs((left.paragraph ?? 0) - (right.paragraph ?? 0)) === 1) score += 0.25
+  return Math.min(1, score)
+}
+
+export function scorePair(left, right, medians) {
+  const anchor = anchorOverlap(left.source, right.source)
+  const length = lengthFit(
+    Array.from(left.source).length,
+    Array.from(right.source).length,
+    medians.left,
+    medians.right,
+  )
+  const struct = structMatch(left, right)
+  const score =
+    ALIGN_WEIGHTS.anchor * anchor + ALIGN_WEIGHTS.length * length + ALIGN_WEIGHTS.struct * struct
+  return { score: Math.min(1, Math.max(0, score)), anchor, length, struct }
+}
+
+export function confidenceOf(score) {
+  if (score >= ALIGN_HIGH) return 'high'
+  if (score >= ALIGN_MEDIUM) return 'medium'
+  return 'low'
+}
+
+function merged(leftSegments, rightSegments) {
+  const text = `${leftSegments.map((item) => item.source).join(' ')}`
+  const other = `${rightSegments.map((item) => item.source).join(' ')}`
+  return {
+    left: { source: text, paragraph: leftSegments[0]?.paragraph ?? 0 },
+    right: { source: other, paragraph: rightSegments[0]?.paragraph ?? 0 },
+  }
+}
+
+function pairCost(leftSegment, rightSegment, medians) {
+  return 1 - scorePair(leftSegment, rightSegment, medians).score
+}
+
+/**
+ * Dynamic programming over prefixes. Moves: 1:1, 1:0, 0:1, 2:1 and 1:2. Skips
+ * cost a full 1.0 so the algorithm prefers a bad pair over dropping both
+ * sides, and merges carry a penalty so it cannot cheat its way to a cheap
+ * total by gluing everything together.
+ */
+export function alignBlock(source, target, medians) {
+  const n = source.length
+  const m = target.length
+  const width = m + 1
+  const cost = new Float64Array((n + 1) * width).fill(Number.POSITIVE_INFINITY)
+  const move = new Int8Array((n + 1) * width)
+  cost[0] = 0
+  for (let i = 0; i <= n; i += 1) {
+    for (let j = 0; j <= m; j += 1) {
+      if (!i && !j) continue
+      const here = i * width + j
+      let best = Number.POSITIVE_INFINITY
+      let kind = 0
+      if (i && j) {
+        const value = cost[(i - 1) * width + (j - 1)] + pairCost(source[i - 1], target[j - 1], medians)
+        if (value < best) {
+          best = value
+          kind = 3
+        }
+      }
+      if (i && j >= 1 && i >= 2) {
+        const { left, right } = merged([source[i - 2], source[i - 1]], [target[j - 1]])
+        const scored = scorePair(left, right, medians).score
+        if (scored >= ALIGN_MERGE_MIN_SCORE) {
+          const value =
+            cost[(i - 2) * width + (j - 1)] + (1 - scored) + ALIGN_MERGE_PENALTY
+          if (value < best) {
+            best = value
+            kind = 4
+          }
+        }
+      }
+      if (i && j >= 2) {
+        const { left, right } = merged([source[i - 1]], [target[j - 2], target[j - 1]])
+        const scored = scorePair(left, right, medians).score
+        if (scored >= ALIGN_MERGE_MIN_SCORE) {
+          const value =
+            cost[(i - 1) * width + (j - 2)] + (1 - scored) + ALIGN_MERGE_PENALTY
+          if (value < best) {
+            best = value
+            kind = 5
+          }
+        }
+      }
+      if (i) {
+        const value = cost[(i - 1) * width + j] + ALIGN_SKIP_COST
+        if (value < best) {
+          best = value
+          kind = 1
+        }
+      }
+      if (j) {
+        const value = cost[i * width + (j - 1)] + ALIGN_SKIP_COST
+        if (value < best) {
+          best = value
+          kind = 2
+        }
+      }
+      cost[here] = best
+      move[here] = kind
+    }
+  }
+
+  const rows = []
+  let i = n
+  let j = m
+  while (i > 0 || j > 0) {
+    const kind = move[i * width + j]
+    if (kind === 3) {
+      rows.push({ source: source[i - 1], target: target[j - 1], left: 1, right: 1 })
+      i -= 1
+      j -= 1
+    } else if (kind === 4) {
+      const { left, right } = merged([source[i - 2], source[i - 1]], [target[j - 1]])
+      rows.push({ source: left, target: right, left: 2, right: 1, merged: true })
+      i -= 2
+      j -= 1
+    } else if (kind === 5) {
+      const { left, right } = merged([source[i - 1]], [target[j - 2], target[j - 1]])
+      rows.push({ source: left, target: right, left: 1, right: 2, merged: true })
+      i -= 1
+      j -= 2
+    } else if (kind === 1) {
+      rows.push({ source: source[i - 1], target: null, left: 1, right: 0 })
+      i -= 1
+    } else {
+      rows.push({ source: null, target: target[j - 1], left: 0, right: 1 })
+      j -= 1
+    }
+  }
+  rows.reverse()
+  return rows
+}
+
+function decorate(row, sourceIndex, targetIndex, medians) {
+  if (!row.source || !row.target) {
+    return {
+      sourceIndex,
+      targetIndex,
+      source: row.source ? row.source.source : '',
+      target: row.target ? row.target.source : '',
+      sourceParagraph: row.source?.paragraph ?? null,
+      targetParagraph: row.target?.paragraph ?? null,
+      score: 0,
+      confidence: 'missing',
+      merged: Boolean(row.merged),
+    }
+  }
+  const { score } = scorePair(row.source, row.target, medians)
+  return {
+    sourceIndex,
+    targetIndex,
+    source: row.source.source,
+    target: row.target.source,
+    sourceParagraph: row.source.paragraph ?? null,
+    targetParagraph: row.target.paragraph ?? null,
+    score: Math.round(score * 1000) / 1000,
+    confidence: confidenceOf(score),
+    merged: Boolean(row.merged),
+  }
+}
+
+/**
+ * Align two plain texts. Returns every row (including unpaired ones) so the UI
+ * can let a human repair them; `pairs` is only the two-sided rows.
+ */
+export function alignTexts(sourceText, targetText, options = {}) {
+  const source = splitIntoSegments(sourceText)
+  const target = splitIntoSegments(targetText)
+  if (!source.length || !target.length) {
+    throw new CatError('ALIGN_EMPTY', '两侧都需要有文本才能对齐。')
+  }
+  const medians = {
+    left: median(source.map((item) => Array.from(item.source).length)),
+    right: median(target.map((item) => Array.from(item.source).length)),
+  }
+
+  const blocked = source.length * target.length > ALIGN_MAX_CELLS
+  const blocks = []
+  if (blocked) {
+    for (let start = 0; start < Math.max(source.length, target.length); start += ALIGN_BLOCK_SIZE) {
+      blocks.push({
+        source: source.slice(start, start + ALIGN_BLOCK_SIZE),
+        target: target.slice(start, start + ALIGN_BLOCK_SIZE),
+        offset: start,
+      })
+    }
+  } else {
+    blocks.push({ source, target, offset: 0 })
+  }
+
+  const rows = []
+  for (const block of blocks) {
+    const aligned = alignBlock(block.source, block.target, medians)
+    let cursorSource = block.offset
+    let cursorTarget = block.offset
+    for (const row of aligned) {
+      const hasSource = Boolean(row.source)
+      const hasTarget = Boolean(row.target)
+      rows.push(
+        decorate(
+          row,
+          hasSource ? cursorSource : null,
+          hasTarget ? cursorTarget : null,
+          medians,
+        ),
+      )
+      if (hasSource) cursorSource += row.left
+      if (hasTarget) cursorTarget += row.right
+    }
+  }
+
+  const pairs = rows.filter((row) => row.source && row.target)
+  const high = pairs.filter((row) => row.confidence === 'high')
+  const medium = pairs.filter((row) => row.confidence === 'medium')
+  const low = pairs.filter((row) => row.confidence === 'low')
+  return {
+    sourceName: options.sourceName ?? '',
+    targetName: options.targetName ?? '',
+    sourceSegments: source.length,
+    targetSegments: target.length,
+    rows,
+    pairs,
+    high: high.length,
+    medium: medium.length,
+    low: low.length,
+    unpairedSource: rows.filter((row) => row.source && !row.target).length,
+    unpairedTarget: rows.filter((row) => row.target && !row.source).length,
+    blocked,
+  }
+}
+
+export const alignMethods = {
+  /** Read two uploads down to segments without creating a document. */
+  prepareAlignment({ sourceFile, targetFile } = {}) {
+    if (!sourceFile?.name || !targetFile?.name) {
+      throw new CatError('ALIGN_INPUT', '需要同时提供源文文件与译文文件。')
+    }
+    const source = this.readUploadText(sourceFile)
+    const target = this.readUploadText(targetFile)
+    return { source, target }
+  },
+
+  alignUploads({ sourceFile, targetFile, sourceLang, targetLang } = {}) {
+    const { source, target } = this.prepareAlignment({ sourceFile, targetFile })
+    const result = alignTexts(source.text, target.text, {
+      sourceName: source.name,
+      targetName: target.name,
+    })
+    return {
+      ...result,
+      sourceLang: cleanLang(sourceLang || this.settings.sourceLang, this.settings.sourceLang),
+      targetLang: cleanLang(targetLang || this.settings.targetLang, this.settings.targetLang),
+    }
+  },
+
+  /**
+   * Write reviewed pairs into one memory. Pairs identical to what is already
+   * stored are skipped, and nothing else in the store is touched: no document,
+   * no segment status.
+   */
+  writeAlignment({ pairs, tmId } = {}) {
+    const list = Array.isArray(pairs) ? pairs : []
+    if (!list.length) throw new CatError('ALIGN_EMPTY', '没有可写入的配对。')
+    const writeTmId = this.requireMountedTmLibrary(tmId)
+    const sourceLang = cleanLang(this.settings.sourceLang, this.settings.sourceLang)
+    const targetLang = cleanLang(this.settings.targetLang, this.settings.targetLang)
+    let written = 0
+    let updated = 0
+    let skipped = 0
+    for (const pair of list) {
+      const sourceText = cleanText(pair?.source, '源文')
+      const targetText = cleanText(pair?.target, '译文')
+      if (!sourceText || !targetText) {
+        skipped += 1
+        continue
+      }
+      const key = normalizeText(sourceText)
+      const existing = this.tm.find(
+        (entry) =>
+          entry.tmId === writeTmId &&
+          entry.sourceLang === sourceLang &&
+          entry.targetLang === targetLang &&
+          (entry.contextHash ?? null) === null &&
+          normalizeText(entry.source) === key,
+      )
+      if (existing && existing.target === targetText) {
+        skipped += 1
+        continue
+      }
+      this.upsertTM(sourceText, targetText, sourceLang, targetLang, writeTmId, null)
+      if (existing) updated += 1
+      else written += 1
+    }
+    if (written || updated) {
+      this.touch()
+      this.persist()
+    }
+    return {
+      written,
+      updated,
+      skipped,
+      total: list.length,
+      tmId: writeTmId,
+      count: this.mountedTmCount(),
+    }
+  },
+}

package/lib/api.js

@@ -14,9 +14,18 @@ const MUTATIONS = new Set([
   'loadDemo',
   'selectSegment',
   'saveDraft',
+  'adoptSuggestion',
+  'proposeTranslation',
+  'writeAlignment',
+  'propagateDocument',
+  'addGlossaryEntries',
+  'preTranslate',
+  'confirmSegments',
   'confirmSegment',
   'moveSegment',
   'addTM',
+  'updateTM',
+  'deleteTM',
   'importTM',
   'clearTM',
   'addGlossary',
@@ -25,6 +34,8 @@ const MUTATIONS = new Set([
   'importGlossary',
   'clearGlossary',
   'createLibrary',
+  'renameLibrary',
+  'deleteLibrary',
   'setMounts',
   'saveSettings',
 ])
@@ -104,6 +115,18 @@ function createHandlers(store) {
     loadDemo: () => store.loadDemo(),
     selectSegment: (params) => store.selectSegment(params),
     saveDraft: (params) => store.saveDraft(params),
+    adoptSuggestion: (params) => store.adoptSuggestion(params),
+    proposeTranslation: (params) => store.proposeTranslation(params),
+    writeAlignment: (params) => store.writeAlignment(params),
+    readUploadText: (params) => store.readUploadText(params),
+    alignUploads: (params) => store.alignUploads(params),
+    consistencyReport: (params) => store.consistencyReport(params),
+    termCandidates: (params) => store.termCandidates(params),
+    addGlossaryEntries: (params) => store.addGlossaryEntries(params),
+    propagateDocument: (params) => store.propagateDocument(params),
+    preTranslate: (params) => store.preTranslate(params),
+    confirmSegments: (params) => store.confirmSegmentsForTool(params),
+    getQaReport: (params) => store.getQaReport(params),
     confirmSegment: (params) => store.confirmSegment(params),
     moveSegment: (params) => store.moveSegment(params),
 
@@ -111,7 +134,13 @@ function createHandlers(store) {
       const result = store.lookupTM(params)
       return { ...result, count: result.matches.length }
     },
+    listTmEntries: (params) => store.listTmEntries(params),
+    listGlossaryEntries: (params) => store.listGlossaryEntries(params),
+    exportTM: (params) => store.exportTM(params),
+    exportGlossary: (params) => store.exportGlossary(params),
     addTM: (params) => store.addTM(params),
+    updateTM: (params) => store.updateTM(params),
+    deleteTM: (params) => store.deleteTM(params),
     importTM: (params) => store.importTM(params),
     clearTM: confirmDangerous((params) => store.clearTM(params)),
 
@@ -122,6 +151,8 @@ function createHandlers(store) {
     clearGlossary: confirmDangerous((params) => store.clearGlossary(params)),
 
     createLibrary: (params) => store.createLibrary(params),
+    renameLibrary: (params) => store.renameLibrary(params),
+    deleteLibrary: (params) => store.deleteLibrary(params),
     setMounts: (params) => store.setMounts(params),
     saveSettings: (params) => store.saveSettings(params),
     mtSuggest: (params) => store.mtSuggest(params),

package/lib/context.js

@@ -0,0 +1,71 @@
+/**
+ * Context fingerprints for translation-memory entries.
+ *
+ * A translation unit is often ambiguous without its neighbours: "Close" is a
+ * button in one document and a menu entry in another. Mainstream CAT tools solve
+ * this by storing the surrounding segments with every unit and giving an exact
+ * context match a score above 100% (ICE).
+ *
+ * CAIT keeps the two neighbouring *source* segments, normalises them, and
+ * reduces them to a short FNV-1a hash used for indexing. The plain text is kept
+ * next to the hash so the review pane can show what the context was.
+ */
+
+import { normalizeText } from './similarity.js'
+
+export const CONTEXT_SEPARATOR = '\u0001'
+
+/** 32-bit FNV-1a, hex. Not a security primitive — only an index key. */
+export function fnv1a(value) {
+  let hash = 0x811c9dc5
+  const text = String(value ?? '')
+  for (let index = 0; index < text.length; index += 1) {
+    hash ^= text.charCodeAt(index)
+    hash = Math.imul(hash, 0x01000193) >>> 0
+  }
+  return (hash >>> 0).toString(16).padStart(8, '0')
+}
+
+/** Normalise a `{prev, next}` pair; an empty pair is not a context at all. */
+export function normalizeContext(context) {
+  if (!context || typeof context !== 'object') return null
+  const prev = normalizeText(context.prev)
+  const next = normalizeText(context.next)
+  if (!prev && !next) return null
+  return { prev, next }
+}
+
+export function contextHashOf(context) {
+  const normalized = normalizeContext(context)
+  if (!normalized) return null
+  return fnv1a(`${normalized.prev}${CONTEXT_SEPARATOR}${normalized.next}`)
+}
+
+/**
+ * Context of one segment: adjacent source text only. Translations are
+ * deliberately ignored — editing a neighbour must not invalidate a match.
+ * A single-segment document has no context (`null`), so it can never score 101%.
+ */
+export function contextOf(doc, index) {
+  const segments = doc?.segments ?? []
+  const position = Math.trunc(Number(index))
+  if (!Number.isInteger(position) || position < 0 || position >= segments.length) return null
+  const prev = position > 0 ? segments[position - 1]?.source ?? '' : ''
+  const next = position < segments.length - 1 ? segments[position + 1]?.source ?? '' : ''
+  return normalizeContext({ prev, next })
+}
+
+/** `<prop type="x-context">` payload: prev, separator, next. */
+export function contextToProp(context) {
+  const normalized = normalizeContext(context)
+  if (!normalized) return ''
+  return `${normalized.prev}${CONTEXT_SEPARATOR}${normalized.next}`
+}
+
+export function contextFromProp(value) {
+  const text = String(value ?? '')
+  if (!text.trim()) return null
+  const cut = text.indexOf(CONTEXT_SEPARATOR)
+  if (cut < 0) return normalizeContext({ prev: text, next: '' })
+  return normalizeContext({ prev: text.slice(0, cut), next: text.slice(cut + CONTEXT_SEPARATOR.length) })
+}

package/lib/docx.js

@@ -59,16 +59,16 @@ function readZipEntry(buffer, wanted) {
   return null
 }
 
-function readZipEntries(buffer) {
+function readZipEntries(buffer, label = 'DOCX') {
   const eocd = findEndOfCentralDirectory(buffer)
-  if (eocd < 0) throw new Error('DOCX 文件不是有效的 ZIP 容器')
+  if (eocd < 0) throw new Error(`${label} 文件不是有效的 ZIP 容器`)
   const count = buffer.readUInt16LE(eocd + 10)
   let offset = buffer.readUInt32LE(eocd + 16)
   const entries = []
 
   for (let index = 0; index < count; index += 1) {
     if (offset + 46 > buffer.length || buffer.readUInt32LE(offset) !== CENTRAL) {
-      throw new Error('DOCX ZIP 中央目录损坏')
+      throw new Error(`${label} ZIP 中央目录损坏`)
     }
     const method = buffer.readUInt16LE(offset + 10)
     const compressedSize = buffer.readUInt32LE(offset + 20)
@@ -78,7 +78,7 @@ function readZipEntries(buffer) {
     const localOffset = buffer.readUInt32LE(offset + 42)
     const name = buffer.subarray(offset + 46, offset + 46 + nameLength).toString('utf8')
 
-    if (buffer.readUInt32LE(localOffset) !== LOCAL) throw new Error('DOCX ZIP 本地头损坏')
+    if (buffer.readUInt32LE(localOffset) !== LOCAL) throw new Error(`${label} ZIP 本地头损坏`)
     const localNameLength = buffer.readUInt16LE(localOffset + 26)
     const localExtraLength = buffer.readUInt16LE(localOffset + 28)
     const start = localOffset + 30 + localNameLength + localExtraLength
@@ -86,9 +86,9 @@ function readZipEntries(buffer) {
     let data
     if (method === 0) data = Buffer.from(compressed)
     else if (method === 8) data = inflateRawSync(compressed)
-    else throw new Error(`DOCX 使用了不支持的压缩方式 (${method})`)
+    else throw new Error(`${label} 使用了不支持的压缩方式 (${method})`)
 
-    entries.push({ name, data })
+    entries.push({ name, data, method })
     offset += 46 + nameLength + extraLength + commentLength
   }
 
@@ -134,14 +134,17 @@ function writeZip(entries) {
   for (const entry of entries) {
     const name = Buffer.from(entry.name, 'utf8')
     const data = Buffer.isBuffer(entry.data) ? entry.data : Buffer.from(entry.data)
-    const compressed = deflateRawSync(data)
+    // EPUB requires the `mimetype` entry to be stored (method 0) and first.
+    const stored = entry.store === true
+    const method = stored ? 0 : 8
+    const compressed = stored ? data : deflateRawSync(data)
     const crc = crc32(data)
 
     const local = Buffer.alloc(30)
     local.writeUInt32LE(LOCAL, 0)
     local.writeUInt16LE(20, 4)
     local.writeUInt16LE(0x0800, 6)
-    local.writeUInt16LE(8, 8)
+    local.writeUInt16LE(method, 8)
     local.writeUInt16LE(time, 10)
     local.writeUInt16LE(date, 12)
     local.writeUInt32LE(crc, 14)
@@ -156,7 +159,7 @@ function writeZip(entries) {
     central.writeUInt16LE(20, 4)
     central.writeUInt16LE(20, 6)
     central.writeUInt16LE(0x0800, 8)
-    central.writeUInt16LE(8, 10)
+    central.writeUInt16LE(method, 10)
     central.writeUInt16LE(time, 12)
     central.writeUInt16LE(date, 14)
     central.writeUInt32LE(crc, 16)