src/docx-parser.js - master - diz/spec

src/docx-parser.js
762 строки35 KB
Dima
Аудит-рефакторинг: validateStructure возвращает найденные колонки (fillExcel не сканирует листы повторно), единый orderOf вместо orderOfLines, дедуп артикулов через Set, общие объекты стилей ячеек, загрузка только нужных word/headerN.xml по rels, общий предикат isTrayRow, warn при замене файла слота, *.zip в .gitignore
08 авг 2026, 13:59
08 авг 2026, 13:594cd4318
/**
 * docx-parser.js — лёгкий парсер Word .docx (word/document.xml) в браузере или Node.
 *
 * Идея: .docx это ZIP-архив. Внутри — word/document.xml. Парсер без внешних
 * зависимостей кроме JSZip (для распаковки) и DOMParser (для чтения XML).
 *
 * Результат:
 *   {
 *     paragraphs: string[],                    // абзацы верхнего уровня
 *     tables: Array<{                          // таблицы верхнего уровня (в порядке следования)
 *       caption: string,                       // последний непустой абзац перед таблицей (название листа)
 *       headers: string[],                     // первая строка таблицы (с нормализацией)
 *       rows: string[][],                      // остальные строки (прямоугольные)
 *       sourceRows: string[][]                 // все строки как в документе (включая headers)
 *     }>,
 *     tableCount: number,
 *     rowCount: number
 *   }
 *
 * Особенности:
 *   - Только верхнеуровневые w:tbl (прямые дети <w:body>) — вложенные таблицы
 *     (артефакты PDF-импорта, текстовые блоки и т.п.) не превращаются в "таблицы",
 *     но их текст попадает в текст ячейки/абзаца, где они находятся.
 *   - Если у ячейки есть gridSpan (colspan) — значение дублируется в ячейки
 *     растяжения, чтобы матрица оставалась прямоугольной (удобно для фильтра/CSV).
 *   - vMerge "continue" даёт пустую строку "" (стандартное представление
 *     объединённой ячейки), "restart" — обычное значение.
 *   - Внутри ячейки параграфы разделяются \n, табы — \t.
 *   - Строки с пустой References и «нулевым» Qty удаляются (applyRowRules).
 *   - Лист «Tray Feeder Info» (если он последний) переносится 1:1 в начало
 *     предпоследней таблицы, сам лист удаляется (moveTrayRows).
 *   - Из итоговых таблиц удаляются колонки
 *     Part Group / References / Skip / Description (removeColumns).
 *   - Qty "N(M,K)": вариант (делится ли N на 2) определяется ОТДЕЛЬНО
 *     для каждого установщика 1–4: у станка берутся первые 5 значений
 *     вида N(M,K) (после удаления значений с K <= 0 или N <= 0); если
 *     в выборке есть K > 0 → вариант 2 (N/2), нет значений → вариант 1 (N).
 *     Вариант применяется ко всем значениям станка, включая без скобок
 *     (2(2,0)→2 или 1, 6(3,3)→3) (applyQtyRule).
 *     НО 5-й установщик (таблицы с PCB-суффиксом «_5.PCB» — TOP_5/BOT_5)
 *     и трей (No с префиксом T или Type=Tray) НЕ делятся на 2 никогда —
 *     у них всегда берётся число перед скобками N.
 *   - Ошибки парсинга (validationErrors): только qty-odd — при варианте 2
 *     станка встретилось нечётное/дробное N (результат был бы дробным).
 *     Ошибки «qty-variant» больше нет: каждый станок всегда получает
 *     вариант (при пустой выборке — вариант 1).
 *   - Имя машины таблицы: сначала из колонтитула секции ("Machine : …"),
 *     но если колонтитул «мусорный» (нет PCB и имя состоит только из цифр —
 *     "Machine : 00" в конвертированных docx) или колонтитула нет — из caption
 *     ("AQCSMBX6R01CSNC_1.0_SKU50_TOP_5.PCB\tSM485_2"), там же берётся PCB.
 *
 * Использование в браузере:
 *   const data = await DocxParser.parseDocx(arrayBuffer, { JSZip: window.JSZip });
 *
 * Использование в Node (тесты):
 *   const data = await DocxParser.parseDocx(buffer, {
 *     JSZip: require("jszip"),
 *     DOMParserImpl: require("@xmldom/xmldom").DOMParser   // конструктор
 *   });
 */
(function (root, factory) {
  if (typeof module === "object" && module.exports) {
    module.exports = factory();
  } else {
    root.DocxParser = factory();
  }
})(typeof self !== "undefined" ? self : this, function () {
  "use strict";

  /** Берёт значение атрибута с учётом namespace. */
  function attr(el, localName) {
    if (!el) return null;
    for (var i = 0; i < el.attributes.length; i++) {
      var a = el.attributes[i];
      var name = a.name.indexOf(":") === -1 ? a.name : a.name.split(":")[1];
      if (name === localName) return a.value;
    }
    return null;
  }

  /** Дети элемента с заданным локальным именем. */
  function children(el, localName) {
    if (!el || !el.childNodes) return [];
    var out = [];
    for (var i = 0; i < el.childNodes.length; i++) {
      var c = el.childNodes[i];
      if (c.nodeType === 1 && c.localName === localName) out.push(c);
    }
    return out;
  }

  function child(el, localName) {
    var arr = children(el, localName);
    return arr.length ? arr[0] : null;
  }

  /** Нормализация названия колонки: схлопывание пробелов и trim. */
  function normHead(x) {
    return String(x).replace(/\s+/g, " ").trim();
  }

  /**
   * Текст элемента: w:t — текст, w:tab — \t, w:br — \n.
   * Внутри текста прогона могут быть вложенные объекты; также рекурсивно
   * захватываем текст вложенных таблиц (чтобы данные не терялись).
   */
  function collectText(el, acc) {
    if (!el || !el.childNodes) return;
    for (var i = 0; i < el.childNodes.length; i++) {
      var c = el.childNodes[i];
      if (c.nodeType === 3) {
        acc.push(c.nodeValue || "");
        continue;
      }
      if (c.nodeType !== 1) continue;
      if (c.localName === "t") {
        acc.push(c.textContent || "");
      } else if (c.localName === "tab") {
        acc.push("\t");
      } else if (c.localName === "br") {
        acc.push("\n");
      } else if (c.localName === "tbl") {
        // Вложенная таблица: сериализуем в текст (строки через " | ", строки через \n)
        acc.push(serializeTableAsText(c));
      } else {
        collectText(c, acc);
      }
    }
  }

  function serializeTableAsText(tblEl) {
    var lines = [];
    var trs = children(tblEl, "tr");
    for (var i = 0; i < trs.length; i++) {
      var cells = [];
      var tcs = children(trs[i], "tc");
      for (var j = 0; j < tcs.length; j++) {
        var parts = [];
        collectText(tcs[j], parts);
        cells.push(parts.join("").replace(/\s+/g, " ").trim());
      }
      lines.push(cells.join(" | "));
    }
    return lines.join("\n");
  }

  /** Текст ячейки: параграфы через "\n", табы сохраняются. */
  function cellText(tcEl) {
    var parts = [];
    collectText(tcEl, parts);
    return parts.join("");
  }

  /** Один w:tc → { text, colspan }. */
  function parseCell(tcEl) {
    var tcPr = child(tcEl, "tcPr");
    var gridSpanEl = child(tcPr, "gridSpan");
    var colspan = gridSpanEl ? parseInt(attr(gridSpanEl, "val") || "1", 10) : 1;
    if (!isFinite(colspan) || colspan < 1) colspan = 1;
    return { text: cellText(tcEl), colspan: colspan };
  }

  /** Одна таблица w:tbl → { headers, rows, sourceRows }.
   *  normalizeHeaders — карта соответствий названий колонок (например
   *  "Qty(F,R)" → "Qty"), применяется к строке заголовков таблицы. */
  function parseTable(tblEl, normalizeHeaders) {
    var grid = child(tblEl, "tblGrid");
    var colCount = grid ? children(grid, "gridCol").length : 0;

    var trs = children(tblEl, "tr");
    var rows2d = [];
    for (var i = 0; i < trs.length; i++) {
      var tcs = children(trs[i], "tc");
      var row = [];
      for (var j = 0; j < tcs.length; j++) {
        var tcPr = child(tcs[j], "tcPr");
        var vMergeEl = tcPr ? child(tcPr, "vMerge") : null;
        var vMergeVal = vMergeEl ? (attr(vMergeEl, "val") || "continue") : null;
        var cell = parseCell(tcs[j]);
        if (vMergeVal === "continue") {
          // продолжение вертикального объединения: без значения
          row.push("");
          continue;
        }
        for (var k = 0; k < cell.colspan; k++) {
          row.push(cell.text);
        }
      }
      rows2d.push(row);
    }

    // Нормализуем до прямоугольной матрицы (по максимальной ширине или tblGrid)
    var ncols = Math.max(colCount, 0);
    for (var r = 0; r < rows2d.length; r++) {
      ncols = Math.max(ncols, rows2d[r].length);
    }
    for (var r2 = 0; r2 < rows2d.length; r2++) {
      while (rows2d[r2].length < ncols) rows2d[r2].push("");
      rows2d[r2] = rows2d[r2].slice(0, ncols);
    }

    var sourceRows = rows2d;
    var headers = (sourceRows.length ? sourceRows[0] : []).slice();
    var rows = sourceRows.slice(1);

    // Нормализация заголовков колонок
    if (normalizeHeaders) {
      for (var h = 0; h < headers.length; h++) {
        var key = normHead(headers[h]);
        if (Object.prototype.hasOwnProperty.call(normalizeHeaders, key)) {
          headers[h] = normalizeHeaders[key];
        }
      }
    }

    return {
      headers: headers,
      rows: rows,
      sourceRows: sourceRows,
      rowCount: rows.length,
      colCount: ncols
    };
  }

  /** Текст абзаца верхнего уровня. */
  function paragraphText(pEl) {
    var parts = [];
    collectText(pEl, parts);
    return parts.join("");
  }

  /**
   * Текст XML-документа: собираем все w:t без разбора структуры.
   * Используется для чтения колонтитулов (word/headerN.xml).
   */
  function xmlDocText(docEl) {
    var parts = [];
    collectText(docEl, parts);
    return parts.join("");
  }

  /**
   * Парсинг word/_rels/document.xml.rels: rId → target (файл внутри word/).
   */
  function parseDocumentRels(xmlText, DomCtor) {
    var out = {};
    var doc;
    try {
      doc = new DomCtor().parseFromString(xmlText, "application/xml");
    } catch (e) {
      return out;
    }
    var rels = children(doc.documentElement, "Relationship");
    for (var i = 0; i < rels.length; i++) {
      var id = attr(rels[i], "Id");
      var target = attr(rels[i], "Target");
      var type = attr(rels[i], "Type");
      if (id) out[id] = { target: target, type: type };
    }
    return out;
  }

  /**
   * Данные колонтитула секции (headerReference из sectPr).
   * Возвращает { default: {text, id}, first: {...}, even: {...} } — только
   * найденные ссылки; text — текст соответствующего word/headerN.xml.
   */
  function sectionHeaders(sectPrEl, rels, headerTexts) {
    var out = {};
    for (var i = 0; i < sectPrEl.childNodes.length; i++) {
      var c = sectPrEl.childNodes[i];
      if (c.nodeType !== 1 || localNameOf(c) !== "headerReference") continue;
      var type = attr(c, "type") || "default";
      var rid = attr(c, "id");
      var rel = rid ? rels[rid] : null;
      var target = rel ? rel.target : null;
      if (typeof target !== "string") continue;
      var file = target.indexOf("/") === 0 ? target.slice(1) :
        ("word/" + target.replace(/^\.\//, ""));
      out[type] = {
        id: rid,
        file: file,
        text: headerTexts[file] || ""
      };
    }
    return out;
  }

  function localNameOf(el) {
    return el.localName || (el.nodeName || "").replace(/^.*:/, "");
  }

  /**
   * Имя машины из текста колонтитула вида "… Machine : SM485_2".
   * Возвращает { machine, pcb } — имя машины и имя PCB (TOP_5.PCB и т.п.).
   */
  function machineFromHeader(headerText) {
    if (!headerText) return null;
    var machine = null;
    var m = /Machine\s*[:：]\s*([^\s]+)/i.exec(headerText);
    if (m && m[1].length) machine = m[1];
    var pcb = null;
    var p = /([A-Za-z0-9_\-.]*\.PCB)/i.exec(headerText);
    if (p) pcb = p[1];
    if (!machine && !pcb) return null;
    return { machine: machine, pcb: pcb };
  }

  /** Заголовки колонок, которые сводим к общему имени (для единообразия таблиц). */
  var DEFAULT_HEADER_NORMALIZATION = {
    "Qty(F,R)": "Qty"
  };

  /** Значения Qty, которые считаются «нулевыми» (артефакты разметки/расстояния). */
  var ZERO_QTY_VALUES = ["0( 0, 0)", "0", "-", "\u2014", ""];

  /**
   * Фильтрация «пустых» строк: если References пуста И Qty «нулевое»
   * (0( 0, 0), 0, -, —, пусто) — строка удаляется из вывода.
   * Применяется к таблицам, у которых есть колонки References и Qty.
   */
function applyRowRules(parsed) {
    var excludedTotal = 0;
    parsed.tables.forEach(function (t) {
      var idxRefs = -1;
      var idxQty = -1;
      t.headers.forEach(function (h, j) {
        var norm = normHead(h);
        if (norm === "References") idxRefs = j;
        if (norm === "Qty") idxQty = j;
      });
      t.excludedCount = 0;
      if (idxRefs === -1 || idxQty === -1) return;
      var kept = [];
      t.rows.forEach(function (r) {
        var refs = String(r[idxRefs] === undefined ? "" : r[idxRefs]).trim();
        var qty = String(r[idxQty] === undefined ? "" : r[idxQty]).trim();
        if (!refs && ZERO_QTY_VALUES.indexOf(qty) !== -1) {
          excludedTotal++;
          t.excludedCount++;
          return;
        }
        kept.push(r);
      });
      t.rows = kept;
      t.rowCount = kept.length;
    });
    parsed.rowCount = 0;
    parsed.tables.forEach(function (t) { parsed.rowCount += t.rowCount; });
    parsed.excludedTotal = excludedTotal;
    return parsed;
  }

  /**
   * Перенос строк листа «Tray Feeder Info» в начало предпоследней таблицы.
   * Если последняя таблица документа — «Tray Feeder Info», её строки
   * (уже после фильтрации нулевых) добавляются 1:1 в начало таблицы,
   * стоящей перед ней; сам лист удаляется из результата.
   * Итого: 1 строка листа Tray = 1 строка в начале предпоследнего листа.
   */
  /** Строка трея: No с префиксом T или Type = Tray (колонки по заголовкам). */
  function isTrayRow(r, idxNo, idxType) {
    if (idxNo !== -1 && r[idxNo] !== undefined && /^T/i.test(String(r[idxNo]).trim())) return true;
    if (idxType !== -1 && r[idxType] !== undefined && /Tray/i.test(String(r[idxType]).trim())) return true;
    return false;
  }

  /** Признак таблицы трея: по первым строкам (Type «Tray» или No с префиксом T),
   *  т.к. абзац-заголовок «Tray Feeder Info» может стоять ПОСЛЕ таблицы. */
  function isTrayTable(t) {
    if (/Tray Feeder Info/i.test(t.caption || "")) return true;
    var idxNo = -1, idxType = -1;
    t.headers.forEach(function (h, j) {
      var norm = normHead(h);
      if (norm === "No." || norm === "No") idxNo = j;
      if (norm === "Type") idxType = j;
    });
    var rows = t.rows || [];
    var limit = Math.min(rows.length, 3);
    for (var i = 0; i < limit; i++) {
      if (rows[i] && isTrayRow(rows[i], idxNo, idxType)) return true;
    }
    return false;
  }

  function moveTrayRows(parsed) {
    var tables = parsed.tables;
    if (tables.length < 2) return parsed;
    var last = tables[tables.length - 1];
    if (!isTrayTable(last)) return parsed;
    // если у трее-таблицы пустой caption, а последний непустой абзац документа —
    // «Tray Feeder Info» (идёт после таблицы), переносим его в caption для наглядности
    if (!last.caption && parsed.paragraphs.length) {
      for (var pi = parsed.paragraphs.length - 1; pi >= 0; pi--) {
        var pt = String(parsed.paragraphs[pi]).trim();
        if (!pt) continue;
        if (/Tray Feeder Info/i.test(pt)) last.caption = pt;
        break;
      }
    }
    var target = tables[tables.length - 2];
    target.rows = last.rows.concat(target.rows);
    target.rowCount = target.rows.length;
    tables.pop();
    parsed.tableCount = tables.length;
    parsed.rowCount = tables.reduce(function (n, t) { return n + t.rowCount; }, 0);
    return parsed;
  }

  /** Формат Qty "N(M,K)" — с учётом пробелов: "  1( 1, 0)", "40(40, 0)". */
  var QTY_RE = /^\s*([\d.]+)\s*\(\s*[\d.]+\s*,\s*([\d.]+)\s*\)\s*$/;

  function qtyParts(value) {
    var m = QTY_RE.exec(String(value));
    if (!m) return null;
    return { n: parseFloat(m[1]), k: parseFloat(m[2]) };
  }

  /**
   * Правило колонки Qty: значение "N(M,K)" → число перед скобкой N,
   * а если второе число в скобках K > 0 — остаётся N / 2.
   *   пример: 2(2,0) → 2;  6(3,3) → 3.
   * Вариант определяется ОТДЕЛЬНО ДЛЯ КАЖДОГО УСТАНОВЩИКА (станка) 1–4:
   * у станка берутся первые `sampleSize` значений вида N(M,K) (после
   * «удаления нулей» — значений с K <= 0 или N <= 0); если среди них есть
   * K > 0 — станок вариант 2 (делится на 2), если таких значений нет вовсе —
   * вариант 1 (не делится). Если у станка меньше `sampleSize` значений —
   * берутся те, что есть. Поэтому каждый станок может быть со своим
   * вариантом (1 или 2). Выбранный вариант применяется ко всем значениям
   * Qty ЭТОГО станка, включая значения БЕЗ скобок ("4" → 4 или 4/2 = 2).
   * ИСКЛЮЧЕНИЕ (всегда, независимо от варианта): 5-й установщик и трей
   * НЕ делятся на 2 — для них Qty всегда остаётся числом перед скобками N
   * (значения без скобок берутся как есть). 5-й установщик — таблицы с
   * PCB-суффиксом «_5.PCB» (TOP_5.PCB / BOT_5.PCB; в спецификации линии
   * ровно 5 установщиков); трей — строка, у которой No начинается с "T"
   * или Type = "Tray". 5-й установщик всегда вариант 1 (без деления) —
   * как и любой станок, у которого в выборке нет значений с K>0.
   * Ошибки парсинга (в parsed.validationErrors):
   *   - при варианте 2 станка встретилось нечётное/дробное N — строка
   *     помечается ошибкой, её значение Qty не изменяется (остальные
   *     применяются). Вариант 1 ошибок не даёт.
   */
  function applyQtyRule(parsed, sampleSize) {
    var limit = sampleSize || 5;
    parsed.validationErrors = parsed.validationErrors || [];

    function findColIdx(t, name) {
      for (var j = 0; j < t.headers.length; j++) {
        if (normHead(t.headers[j]) === name) return j;
      }
      return -1;
    }

    // 5-й установщик — таблицы, у которых в PCB/подписи листа есть суффикс
    // "_5.PCB" (TOP_5.PCB / BOT_5.PCB); в спецификации линии ровно 5
    // установщиков. По имени машины определять НЕЛЬЗЯ: в конвертированных
    // docx колонтитулы 5-го могут не содержать имени автомата либо у всех
    // секций одинаковый текст ("Machine : 00") — имена машин приходят из
    // caption ("AQCSMBX6R01CSNC_1.0_SKU50_TOP_5.PCB\tSM485_2").
    function isFifthTable(t) {
      var s = String(t.pcb || "") + " " + String(t.caption || "");
      return /_5\.PCB\b/i.test(s);
    }

    // Строка трея — общий предикат isTrayRow (см. выше): No с префиксом T
    // или Type = Tray; используется и в isTrayTable.

    // 1) группируем таблицы по установщику (имени машины); у каждого
    //    установщика 1–4 будет свой вариант, 5-й всегда вариант 1.
    var groups = {}; // имя машины → { name, fifth, variant, tables: [{t, qIdx, noIdx, tyIdx}] }
    var order = [];
    parsed.tables.forEach(function (t, ti) {
      var qIdx = findColIdx(t, "Qty");
      var noIdx = findColIdx(t, "No.");
      var tyIdx = findColIdx(t, "Type");
      if (qIdx === -1) return;
      var name = t.machine && String(t.machine).trim() ? String(t.machine).trim() : "Table#" + ti;
      if (!groups.hasOwnProperty(name)) {
        groups[name] = { name: name, fifth: isFifthTable(t), tables: [] };
        order.push(name);
      }
      groups[name].tables.push({ t: t, qIdx: qIdx, noIdx: noIdx, tyIdx: tyIdx, ti: ti });
    });

    // 2) определяем вариант каждого станка: после «удаления нулей»
    //    (K <= 0 / N <= 0) берём первые `limit` значений со скобками —
    //    если есть K > 0, это вариант 2, иначе вариант 1. 5-й — всегда 1.
    order.forEach(function (key) {
      var g = groups[key];
      if (g.fifth) { g.variant = 1; return; }
      var samples = [];
      for (var gi = 0; gi < g.tables.length && samples.length < limit; gi++) {
        var x = g.tables[gi];
        for (var i = 0; i < x.t.rows.length && samples.length < limit; i++) {
          if (isTrayRow(x.t.rows[i], x.noIdx, x.tyIdx)) continue;
          var p = qtyParts(x.t.rows[i][x.qIdx]);
          if (!p || p.n <= 0) continue;
          if (p.k > 0) samples.push(2); // значения с K=0 отброшены («удаление нулей»)
        }
      }
      g.variant = samples.length ? 2 : 1;
    });

    // 3) применяем вариант станка ко всем его таблицам и строкам
    //    (индексы колонок уже найдены на шаге 1 — повторно не ищем)
    order.forEach(function (key) {
      var g = groups[key];
      g.tables.forEach(function (x) {
        var t = x.t;
        var variant = g.variant;
        t.rows.forEach(function (r, ri) {
          var raw = String(r[x.qIdx]).trim();
          var p = qtyParts(raw);
          var n = p ? p.n : (isFinite(parseFloat(raw)) ? parseFloat(raw) : null);
          if (n === null) return;
          // 5-й установщик и трей: всегда число перед скобками N, без деления на 2
          if (g.fifth || isTrayRow(r, x.noIdx, x.tyIdx)) {
            r[x.qIdx] = String(n);
            return;
          }
          if (variant === 1) {
            r[x.qIdx] = String(n);
            return;
          }
          // вариант 2: N должно быть чётным целым (результат всегда целое)
          if (!Number.isInteger(n) || n % 2 !== 0) {
            var label = (t.caption || ("Таблица " + (x.ti + 1)));
            var no = x.noIdx !== -1 && r[x.noIdx] !== undefined ? String(r[x.noIdx]).trim() : (ri + 1);
            parsed.validationErrors.push({
              type: "qty-odd",
              table: label,
              row: no,
              qty: raw,
              message: "Qty \"" + raw + "\" (лист \"" + label + "\", No. " + no + ") нечётное при варианте 2: деление на 2 даст дробное значение. Значение не изменено."
            });
            return;
          }
          r[x.qIdx] = String(n / 2);
        });
      });
    });

    return parsed;
  }

  /** Колонки, которые удаляются из итоговых таблиц (по имени заголовка). */
  var REMOVE_COLUMNS = ["Part Group", "References", "Skip", "Description"];

  /**
   * Удаление лишних колонок из всех таблиц (заголовки, данные и sourceRows).
   * Колонка ищется по имени заголовка (с нормализацией пробелов).
   */
  function removeColumns(parsed) {
    parsed.tables.forEach(function (t) {
      var dropIdx = [];
      t.headers.forEach(function (h, j) {
        var norm = normHead(h);
        if (REMOVE_COLUMNS.indexOf(norm) !== -1) dropIdx.push(j);
      });
      if (!dropIdx.length) return;
      var drop = {};
      dropIdx.forEach(function (j) { drop[j] = true; });
      t.headers = t.headers.filter(function (_, j) { return !drop[j]; });
      t.rows = t.rows.map(function (r) { return r.filter(function (_, j) { return !drop[j]; }); });
      t.sourceRows = t.sourceRows.map(function (r) { return r.filter(function (_, j) { return !drop[j]; }); });
      t.colCount = t.headers.length;
    });
    return parsed;
  }

  /**
   * Главная функция: DOCX (ArrayBuffer) → структурированные данные.
   * options: {
   *   JSZip (обязателен),
   *   DOMParserImpl (опционально, по умолчанию глобальный),
   *   normalizeHeaders (опционально, карта заголовков; по умолчанию {'Qty(F,R)': 'Qty'}, false — отключить)
   * }
   */
  function parseDocx(arrayBuffer, options) {
    options = options || {};
    var JSZip = options.JSZip || (root.JSZip);
    if (!JSZip) {
      return Promise.reject(new Error("JSZip не найден: передайте { JSZip } в options"));
    }
    var DomCtor = options.DOMParserImpl ||
      (typeof DOMParser !== "undefined" ? DOMParser : null);
    if (typeof DomCtor !== "function") {
      return Promise.reject(
        new Error("DOMParser недоступен: передайте { DOMParserImpl: конструктор-класс } в options (в Node нужен @xmldom/xmldom)")
      );
    }
    var normalizeHeaders = options.normalizeHeaders;
    if (normalizeHeaders === undefined || normalizeHeaders === null) {
      normalizeHeaders = DEFAULT_HEADER_NORMALIZATION;
    }

    return JSZip.loadAsync(arrayBuffer).then(function (zip) {
      var entry = zip.file("word/document.xml");
      if (!entry) {
        throw new Error("Не найден word/document.xml — это не .docx Word-документ");
      }
      var relsEntry = zip.file("word/_rels/document.xml.rels");
      var headersMap = {}; // "word/headerN.xml" -> xml-строка

      function loadRels() {
        if (!relsEntry) return Promise.resolve({});
        return relsEntry.async("string").then(function (relsText) {
          return parseDocumentRels(relsText, DomCtor);
        });
      }

      // Сначала читаем document.xml.rels и загружаем ТОЛЬКО те колонтитулы,
      // на которые document.xml реально ссылается (headerReference), —
      // неиспользуемые word/headerN.xml не читаем и не парсим.
      return loadRels().then(function (rels) {
        var headerPromises = [];
        Object.keys(rels).forEach(function (id) {
          var rel = rels[id];
          if (!rel || typeof rel.target !== "string") return;
          var path = rel.target.indexOf("/") === 0
            ? rel.target.slice(1)
            : ("word/" + rel.target.replace(/^\.\//, ""));
          if (/^word\/header\d*\.xml$/.test(path) && zip.file(path)) {
            headerPromises.push(zip.file(path).async("string").then(function (text) {
              headersMap[path] = text;
            }));
          }
        });
        return Promise.all([Promise.all(headerPromises), Promise.resolve(rels)]);
      }).then(function (res) {
        var rels = res[1];
        return entry.async("string").then(function (xmlText) {
          var doc = new DomCtor().parseFromString(xmlText, "application/xml");
          var xmlErr = doc.getElementsByTagName("parsererror");
          if (xmlErr.length) {
            throw new Error("Ошибка разбора document.xml: " + (xmlErr[0].textContent || "").slice(0, 200));
          }

          var body = children(doc.documentElement, "body")[0];
          if (!body) throw new Error("В document.xml нет <w:body>");

          // Тексты колонтитулов, на которые ссылается document.xml
          var headerTexts = {};
          Object.keys(headersMap).forEach(function (name) {
            headerTexts[name] = xmlDocText(new DomCtor().parseFromString(headersMap[name], "application/xml"));
          });

          var paragraphs = [];
          var tables = [];
          var lastNonEmpty = ""; // подпись (название листа) в текущей секции

          // Буфер таблиц текущей секции: свойства секции задаются в её sectPr
          // (абзац с pPr/sectPr = конец секции; sectPr в конце body = последняя секция).
          var pendingTables = [];

          function assignSection(sectPrEl) {
            var props = sectionHeaders(sectPrEl, rels, headerTexts);
            for (var k = 0; k < pendingTables.length; k++) {
              pendingTables[k].section = props;
            }
            pendingTables = [];
            lastNonEmpty = ""; // новая секция начинается без подписи
          }

          function sectPrOfPar(pEl) {
            var pPr = child(pEl, "pPr");
            return pPr ? child(pPr, "sectPr") : null;
          }

          function finishTbl(builtTable, capText) {
            // Машина таблицы: сначала из секции (колонтитула), затем из caption.
            // Колонтитул считается «мусорным», если в нём нет PCB и имя машины
            // состоит только из цифр ("Machine : 00", "Machine : 127541432435"
            // в конвертированных docx): тогда настоящее имя берём из caption
            // ("AQCSMBX6R01CSNC_1.0_SKU50_TOP_5.PCB\tSM485_2").
            var fromHeader = null;
            var sect = builtTable.section || {};
            if (sect.default && sect.default.text) fromHeader = machineFromHeader(sect.default.text);
            if (!fromHeader && sect.first && sect.first.text) fromHeader = machineFromHeader(sect.first.text);
            if (!fromHeader && sect.even && sect.even.text) fromHeader = machineFromHeader(sect.even.text);

            // Машина из caption вида "AQC266SD_2.0_SKUB_TOP_4.PCB\tDECAN L2"
            // (в именах машин допускаются и подчёркивания: "SM485_2")
            var fromCaption = null;
            var text = (capText || "").trim();
            var capMatch = /(?:([A-Za-z0-9_\-.]*\.PCB)\s*)?([A-Za-z0-9\-_]+(?:\s+[A-Za-z0-9\-_]+)*)$/.exec(text);
            if (capMatch) {
              fromCaption = {
                pcb: capMatch[1] || null,
                machine: (capMatch[2] || "").trim() || null
              };
            }

            var headerSane = !!(fromHeader &&
              (fromHeader.pcb || (fromHeader.machine && /\D/.test(fromHeader.machine))));

            if (fromHeader && headerSane) {
              builtTable.machine = fromHeader.machine;
              builtTable.pcb = fromHeader.pcb;
            } else if (fromCaption && (fromCaption.machine || fromCaption.pcb)) {
              builtTable.machine = fromCaption.machine;
              builtTable.pcb = fromCaption.pcb;
            } else if (fromHeader) {
              builtTable.machine = fromHeader.machine;
              builtTable.pcb = fromHeader.pcb;
            }
            return builtTable;
          }

          for (var i = 0; i < body.childNodes.length; i++) {
            var node = body.childNodes[i];
            if (node.nodeType !== 1) continue;
            var ln = localNameOf(node);
            if (ln === "p") {
              var text = paragraphText(node);
              paragraphs.push(text);
              var innerSect = sectPrOfPar(node);
              if (innerSect) {
                // конец текущей секции: применяем её свойства к её таблицам
                assignSection(innerSect);
              }
              if (text.replace(/\s+/g, "").length) {
                lastNonEmpty = text.trim();
              }
            } else if (ln === "tbl") {
              var table = parseTable(node, normalizeHeaders);
              table.caption = lastNonEmpty;
              table.section = null; // заполним в assignSection
              table.machine = null;
              table.pcb = null;
              pendingTables.push(table);
              tables.push(table);
            } else if (ln === "sectPr") {
              // Свойства последней секции (прямой потомок body)
              assignSection(node);
            }
          }

          // Завершаем определение машин для всех таблиц
          for (var ti = 0; ti < tables.length; ti++) {
            finishTbl(tables[ti], tables[ti].caption);
          }

          var rowCount = 0;
          for (var t = 0; t < tables.length; t++) rowCount += tables[t].rowCount;

          return removeColumns(applyQtyRule(moveTrayRows(applyRowRules({
            paragraphs: paragraphs,
            tables: tables,
            tableCount: tables.length,
            rowCount: rowCount
          })), 5));
        });
      });
    });
  }

  /** Экспорт публичного API. */
  return {
    parseDocx: parseDocx
  };
});