@open-mercato/documents 0.6.8-develop.7016.1.4ed7b1e49d

package/dist/modules/documents/lib/docxRenderer.js

@@ -0,0 +1,601 @@
+var _a, _b, _c, _d, _e, _f, _g, _h;
+import { createRequire } from "node:module";
+import { isAbsolute } from "node:path";
+import { Worker } from "node:worker_threads";
+const DOCX_RENDER_MAX_CONCURRENCY = 2;
+const DOCX_RENDER_MAX_QUEUE = 4;
+const DOCX_RENDER_ACQUIRE_TIMEOUT_MS = 2e3;
+const DOCX_RENDER_TIMEOUT_MS = 2e4;
+const DOCX_MAX_OUTPUT_BYTES = 25 * 1024 * 1024;
+const DOCX_WORKER_CHUNK_BYTES = 64 * 1024;
+const DOCX_WORKER_RESOURCE_LIMITS = Object.freeze({
+  maxOldGenerationSizeMb: 128,
+  maxYoungGenerationSizeMb: 16,
+  stackSizeMb: 4
+});
+const DOCX_OVERLOADED_MARKER = /* @__PURE__ */ Symbol.for("open-mercato.documents.docxRenderer.overloaded");
+const DOCX_TIMEOUT_MARKER = /* @__PURE__ */ Symbol.for("open-mercato.documents.docxRenderer.timeout");
+const DOCX_OUTPUT_TOO_LARGE_MARKER = /* @__PURE__ */ Symbol.for("open-mercato.documents.docxRenderer.outputTooLarge");
+const DOCX_FAILED_MARKER = /* @__PURE__ */ Symbol.for("open-mercato.documents.docxRenderer.failed");
+class DocxRenderOverloadedError extends (_b = Error, _a = DOCX_OVERLOADED_MARKER, _b) {
+  constructor() {
+    super("DOCX renderer is at capacity");
+    this[_a] = true;
+    this.name = "DocxRenderOverloadedError";
+  }
+}
+class DocxRenderTimeoutError extends (_d = Error, _c = DOCX_TIMEOUT_MARKER, _d) {
+  constructor() {
+    super("DOCX renderer timed out");
+    this[_c] = true;
+    this.name = "DocxRenderTimeoutError";
+  }
+}
+class DocxRenderOutputTooLargeError extends (_f = Error, _e = DOCX_OUTPUT_TOO_LARGE_MARKER, _f) {
+  constructor() {
+    super("DOCX renderer output exceeded its byte limit");
+    this[_e] = true;
+    this.name = "DocxRenderOutputTooLargeError";
+  }
+}
+class DocxRenderFailedError extends (_h = Error, _g = DOCX_FAILED_MARKER, _h) {
+  constructor(options = {}) {
+    super("DOCX renderer failed", options);
+    this[_g] = true;
+    this.name = "DocxRenderFailedError";
+  }
+}
+function hasErrorMarker(error, marker) {
+  return Boolean(error && typeof error === "object" && error[marker] === true);
+}
+const isDocxRenderOverloadedError = (error) => error instanceof DocxRenderOverloadedError || hasErrorMarker(error, DOCX_OVERLOADED_MARKER);
+const isDocxRenderTimeoutError = (error) => error instanceof DocxRenderTimeoutError || hasErrorMarker(error, DOCX_TIMEOUT_MARKER);
+const isDocxRenderOutputTooLargeError = (error) => error instanceof DocxRenderOutputTooLargeError || hasErrorMarker(error, DOCX_OUTPUT_TOO_LARGE_MARKER);
+const isDocxRenderFailedError = (error) => error instanceof DocxRenderFailedError || hasErrorMarker(error, DOCX_FAILED_MARKER);
+const DOCX_WORKER_SOURCE = String.raw`
+const { parentPort, workerData } = require('node:worker_threads')
+
+const VOID_TAGS = new Set(['br', 'hr', 'img', 'input'])
+
+function attributes(source) {
+  const result = {}
+  const pattern = /([A-Za-z_:][-A-Za-z0-9_:.]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>]+)))?/g
+  let match
+  while ((match = pattern.exec(source)) !== null) {
+    result[match[1].toLowerCase()] = match[2] ?? match[3] ?? match[4] ?? ''
+  }
+  return result
+}
+
+function parseHtml(html) {
+  const root = { tag: 'root', attrs: {}, children: [] }
+  const stack = [root]
+  const tokens = String(html).match(/<!--[\s\S]*?-->|<![^>]*>|<\/?[A-Za-z][^>]*>|[^<]+/g) || []
+  for (const token of tokens) {
+    if (token.startsWith('<!--') || token.startsWith('<!')) continue
+    if (!token.startsWith('<')) {
+      stack[stack.length - 1].children.push(token)
+      continue
+    }
+    const closing = /^<\/\s*([A-Za-z0-9-]+)/.exec(token)
+    if (closing) {
+      const tag = closing[1].toLowerCase()
+      while (stack.length > 1) {
+        const node = stack.pop()
+        if (node.tag === tag) break
+      }
+      continue
+    }
+    const opening = /^<\s*([A-Za-z0-9-]+)([\s\S]*?)\/?\s*>$/.exec(token)
+    if (!opening) continue
+    const tag = opening[1].toLowerCase()
+    const node = { tag, attrs: attributes(opening[2]), children: [] }
+    stack[stack.length - 1].children.push(node)
+    if (!VOID_TAGS.has(tag) && !/\/\s*>$/.test(token)) stack.push(node)
+  }
+  return root
+}
+
+function decode(value) {
+  return String(value)
+    .replace(/&#x([0-9a-f]+);/gi, (_match, code) => String.fromCodePoint(Number.parseInt(code, 16)))
+    .replace(/&#([0-9]+);/g, (_match, code) => String.fromCodePoint(Number.parseInt(code, 10)))
+    .replace(/&(amp|lt|gt|quot|apos|nbsp);/g, (_match, name) => ({ amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ' })[name])
+}
+
+function inlineNodes(nodes, marks) {
+  const result = []
+  for (const child of Array.isArray(nodes) ? nodes : []) {
+    if (typeof child === 'string') {
+      const text = decode(child)
+      if (text) result.push({ type: 'text', text, marks })
+      continue
+    }
+    if (!child || typeof child !== 'object') continue
+    if (child.tag === 'br') {
+      result.push({ type: 'hardBreak' })
+      continue
+    }
+    if (child.tag === 'img') {
+      result.push({ type: 'image', attrs: { src: child.attrs.src || '' } })
+      continue
+    }
+    const markType = ({ strong: 'bold', b: 'bold', em: 'italic', i: 'italic', u: 'underline', s: 'strike', strike: 'strike', code: 'code' })[child.tag]
+    result.push(...inlineNodes(child.children, markType ? [...marks, { type: markType }] : marks))
+  }
+  return result
+}
+
+function blockNodes(nodes) {
+  const result = []
+  for (const child of Array.isArray(nodes) ? nodes : []) {
+    if (typeof child === 'string') {
+      if (decode(child).trim()) result.push({ type: 'paragraph', content: inlineNodes([child], []) })
+      continue
+    }
+    if (!child || typeof child !== 'object') continue
+    const align = /(?:^|;)\s*text-align\s*:\s*(left|center|right|justify)/i.exec(child.attrs.style || '')
+    if (child.tag === 'div' && String(child.attrs.class || '').split(/\s+/).includes('page-break')) {
+      result.push({ type: 'pageBreak' })
+    } else if (child.tag === 'p' || child.tag === 'div') {
+      result.push({ type: 'paragraph', attrs: { textAlign: align && align[1].toLowerCase() }, content: inlineNodes(child.children, []) })
+    } else if (/^h[1-6]$/.test(child.tag)) {
+      result.push({ type: 'heading', attrs: { level: Number(child.tag.slice(1)), textAlign: align && align[1].toLowerCase() }, content: inlineNodes(child.children, []) })
+    } else if (child.tag === 'ul' || child.tag === 'ol') {
+      result.push({
+        type: child.tag === 'ol' ? 'orderedList' : 'bulletList',
+        content: child.children.filter((item) => item && typeof item === 'object' && item.tag === 'li').map((item) => ({
+          type: 'listItem',
+          content: blockNodes(item.children).length ? blockNodes(item.children) : [{ type: 'paragraph', content: inlineNodes(item.children, []) }],
+        })),
+      })
+    } else if (child.tag === 'blockquote') {
+      result.push({ type: 'blockquote', content: inlineNodes(child.children, []) })
+    } else if (child.tag === 'pre') {
+      result.push({ type: 'codeBlock', content: inlineNodes(child.children, [{ type: 'code' }]) })
+    } else if (child.tag === 'hr') {
+      result.push({ type: 'horizontalRule' })
+    } else if (child.tag === 'img') {
+      result.push({ type: 'image', attrs: { src: child.attrs.src || '' } })
+    } else if (child.tag === 'table') {
+      const rows = []
+      const visitRows = (entries) => {
+        for (const entry of Array.isArray(entries) ? entries : []) {
+          if (!entry || typeof entry !== 'object') continue
+          if (entry.tag === 'tr') {
+            rows.push({
+              type: 'tableRow',
+              content: entry.children.filter((cell) => cell && typeof cell === 'object' && ['td', 'th'].includes(cell.tag)).map((cell) => ({
+                type: cell.tag === 'th' ? 'tableHeader' : 'tableCell',
+                content: blockNodes(cell.children).length ? blockNodes(cell.children) : [{ type: 'paragraph', content: inlineNodes(cell.children, []) }],
+              })),
+            })
+          } else visitRows(entry.children)
+        }
+      }
+      visitRows(child.children)
+      result.push({ type: 'table', content: rows })
+    } else {
+      const nested = blockNodes(child.children)
+      if (nested.length) result.push(...nested)
+      else if (inlineNodes(child.children, []).length) result.push({ type: 'paragraph', content: inlineNodes(child.children, []) })
+    }
+  }
+  return result
+}
+
+function htmlToDocumentJson(html) {
+  return { type: 'doc', content: blockNodes(parseHtml(html).children) }
+}
+
+function xml(value) {
+  return String(value ?? '')
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&apos;')
+}
+
+function markProperties(marks) {
+  const names = new Set((Array.isArray(marks) ? marks : []).map((mark) => mark && mark.type))
+  return [
+    names.has('bold') ? '<w:b/>' : '',
+    names.has('italic') ? '<w:i/>' : '',
+    names.has('underline') ? '<w:u w:val="single"/>' : '',
+    names.has('strike') ? '<w:strike/>' : '',
+    names.has('code') ? '<w:rFonts w:ascii="Courier New" w:hAnsi="Courier New"/>' : '',
+  ].join('')
+}
+
+function textRun(node) {
+  const text = String(node && node.text || '')
+  const properties = markProperties(node && node.marks)
+  return '<w:r>' + (properties ? '<w:rPr>' + properties + '</w:rPr>' : '')
+    + '<w:t xml:space="preserve">' + xml(text) + '</w:t></w:r>'
+}
+
+function inlineContent(nodes, state) {
+  return (Array.isArray(nodes) ? nodes : []).map((node) => {
+    if (!node || typeof node !== 'object') return ''
+    if (node.type === 'text') return textRun(node)
+    if (node.type === 'hardBreak') return '<w:r><w:br/></w:r>'
+    if (node.type === 'entityRef') return textRun({ text: node.attrs && node.attrs.label || '' })
+    if (node.type === 'image') return imageRun(node, state)
+    return inlineContent(node.content, state)
+  }).join('')
+}
+
+function paragraphProperties(node, options) {
+  const properties = []
+  if (options && options.style) properties.push('<w:pStyle w:val="' + xml(options.style) + '"/>')
+  if (options && options.numberId) {
+    properties.push('<w:numPr><w:ilvl w:val="' + Number(options.level || 0) + '"/><w:numId w:val="' + Number(options.numberId) + '"/></w:numPr>')
+  }
+  const alignment = node && node.attrs && node.attrs.textAlign
+  if (['left', 'center', 'right', 'justify'].includes(alignment)) {
+    properties.push('<w:jc w:val="' + alignment + '"/>')
+  }
+  return properties.length ? '<w:pPr>' + properties.join('') + '</w:pPr>' : ''
+}
+
+function paragraph(node, state, options) {
+  return '<w:p>' + paragraphProperties(node, options) + inlineContent(node && node.content, state) + '</w:p>'
+}
+
+function imageDimensions(bytes, mimeType) {
+  if (mimeType === 'image/png' && bytes.length >= 24) {
+    return { width: bytes.readUInt32BE(16), height: bytes.readUInt32BE(20) }
+  }
+  if (mimeType === 'image/jpeg' && bytes.length >= 4) {
+    let offset = 2
+    while (offset + 8 < bytes.length) {
+      if (bytes[offset] !== 0xff) break
+      const marker = bytes[offset + 1]
+      offset += 2
+      if (marker === 0xd8 || marker === 0xd9 || marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) continue
+      if (offset + 2 > bytes.length) break
+      const length = bytes.readUInt16BE(offset)
+      if (length < 2 || offset + length > bytes.length) break
+      if ([0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf].includes(marker)) {
+        return { width: bytes.readUInt16BE(offset + 5), height: bytes.readUInt16BE(offset + 3) }
+      }
+      offset += length
+    }
+  }
+  return { width: 640, height: 480 }
+}
+
+function imageRun(node, state) {
+  const source = node && node.attrs && node.attrs.src
+  const match = typeof source === 'string' && /^data:(image\/(?:png|jpeg));base64,([A-Za-z0-9+/]+={0,2})$/.exec(source)
+  if (!match) return ''
+  const bytes = Buffer.from(match[2], 'base64')
+  if (bytes.length === 0 || bytes.toString('base64') !== match[2]) return ''
+  const extension = match[1] === 'image/png' ? 'png' : 'jpg'
+  const imageId = state.images.length + 1
+  const relationshipId = 'rId' + (imageId + 2)
+  const dimensions = imageDimensions(bytes, match[1])
+  const maxWidth = 5486400
+  const scale = Math.min(1, 640 / Math.max(1, dimensions.width))
+  const width = Math.max(9525, Math.round(dimensions.width * scale * 9525))
+  const height = Math.max(9525, Math.round(dimensions.height * scale * 9525))
+  state.images.push({ bytes, extension, relationshipId, imageId })
+  return '<w:r><w:drawing><wp:inline distT="0" distB="0" distL="0" distR="0">'
+    + '<wp:extent cx="' + Math.min(width, maxWidth) + '" cy="' + Math.round(height * Math.min(1, maxWidth / width)) + '"/>'
+    + '<wp:docPr id="' + imageId + '" name="Image ' + imageId + '"/>'
+    + '<a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture">'
+    + '<pic:pic><pic:nvPicPr><pic:cNvPr id="' + imageId + '" name="image.' + extension + '"/><pic:cNvPicPr/></pic:nvPicPr>'
+    + '<pic:blipFill><a:blip r:embed="' + relationshipId + '"/><a:stretch><a:fillRect/></a:stretch></pic:blipFill>'
+    + '<pic:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="' + width + '" cy="' + height + '"/></a:xfrm>'
+    + '<a:prstGeom prst="rect"><a:avLst/></a:prstGeom></pic:spPr></pic:pic>'
+    + '</a:graphicData></a:graphic></wp:inline></w:drawing></w:r>'
+}
+
+function renderList(node, state, level, numberId) {
+  return (Array.isArray(node.content) ? node.content : []).map((item) => {
+    const children = Array.isArray(item && item.content) ? item.content : []
+    return children.map((child) => {
+      if (child.type === 'paragraph') return paragraph(child, state, { numberId, level })
+      if (child.type === 'bulletList') return renderList(child, state, level + 1, 1)
+      if (child.type === 'orderedList') return renderList(child, state, level + 1, 2)
+      return renderBlock(child, state)
+    }).join('')
+  }).join('')
+}
+
+function renderTable(node, state) {
+  const rows = (Array.isArray(node.content) ? node.content : []).map((row) => {
+    const cells = (Array.isArray(row && row.content) ? row.content : []).map((cell) => (
+      '<w:tc><w:tcPr><w:tcW w:w="0" w:type="auto"/></w:tcPr>'
+      + (Array.isArray(cell && cell.content) ? cell.content.map((entry) => renderBlock(entry, state)).join('') : '<w:p/>')
+      + '</w:tc>'
+    )).join('')
+    return '<w:tr>' + cells + '</w:tr>'
+  }).join('')
+  return '<w:tbl><w:tblPr><w:tblBorders><w:top w:val="single" w:sz="4"/><w:left w:val="single" w:sz="4"/>'
+    + '<w:bottom w:val="single" w:sz="4"/><w:right w:val="single" w:sz="4"/><w:insideH w:val="single" w:sz="4"/>'
+    + '<w:insideV w:val="single" w:sz="4"/></w:tblBorders></w:tblPr>' + rows + '</w:tbl>'
+}
+
+function renderBlock(node, state) {
+  if (!node || typeof node !== 'object') return ''
+  if (node.type === 'paragraph') return paragraph(node, state)
+  if (node.type === 'heading') return paragraph(node, state, { style: 'Heading' + Math.min(6, Math.max(1, Number(node.attrs && node.attrs.level || 1))) })
+  if (node.type === 'bulletList' || node.type === 'taskList') return renderList(node, state, 0, 1)
+  if (node.type === 'orderedList') return renderList(node, state, 0, 2)
+  if (node.type === 'blockquote') return '<w:p><w:pPr><w:ind w:left="720"/></w:pPr>' + inlineContent(node.content, state) + '</w:p>'
+  if (node.type === 'codeBlock') return '<w:p><w:pPr><w:pStyle w:val="Code"/></w:pPr>' + inlineContent(node.content, state) + '</w:p>'
+  if (node.type === 'horizontalRule') return '<w:p><w:pPr><w:pBdr><w:bottom w:val="single" w:sz="6"/></w:pBdr></w:pPr></w:p>'
+  if (node.type === 'table') return renderTable(node, state)
+  if (node.type === 'pageBreak') return '<w:p><w:r><w:br w:type="page"/></w:r></w:p>'
+  if (node.type === 'image') return '<w:p>' + imageRun(node, state) + '</w:p>'
+  return (Array.isArray(node.content) ? node.content : []).map((child) => renderBlock(child, state)).join('')
+}
+
+function documentXml(documentJson, state) {
+  const body = (Array.isArray(documentJson && documentJson.content) ? documentJson.content : [])
+    .map((node) => renderBlock(node, state)).join('')
+  return '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+    + '<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" '
+    + 'xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" '
+    + 'xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" '
+    + 'xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" '
+    + 'xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture">'
+    + '<w:body>' + body + '<w:sectPr><w:pgSz w:w="11906" w:h="16838"/><w:pgMar w:top="1440" w:right="1440" w:bottom="1440" w:left="1440"/></w:sectPr></w:body></w:document>'
+}
+
+async function convert(documentJson, JSZip) {
+  const zip = new JSZip()
+  const state = { images: [] }
+  const document = documentXml(documentJson, state)
+  zip.file('[Content_Types].xml', '<?xml version="1.0" encoding="UTF-8"?>'
+    + '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">'
+    + '<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>'
+    + '<Default Extension="xml" ContentType="application/xml"/><Default Extension="png" ContentType="image/png"/>'
+    + '<Default Extension="jpg" ContentType="image/jpeg"/>'
+    + '<Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>'
+    + '<Override PartName="/word/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/>'
+    + '<Override PartName="/word/numbering.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"/>'
+    + '</Types>')
+  zip.file('_rels/.rels', '<?xml version="1.0" encoding="UTF-8"?>'
+    + '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">'
+    + '<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/>'
+    + '</Relationships>')
+  zip.file('word/document.xml', document)
+  zip.file('word/styles.xml', '<?xml version="1.0" encoding="UTF-8"?>'
+    + '<w:styles xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">'
+    + '<w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/></w:style>'
+    + [1,2,3,4,5,6].map((level) => '<w:style w:type="paragraph" w:styleId="Heading' + level + '"><w:name w:val="heading ' + level + '"/><w:basedOn w:val="Normal"/><w:rPr><w:b/><w:sz w:val="' + (34 - level * 2) + '"/></w:rPr></w:style>').join('')
+    + '<w:style w:type="paragraph" w:styleId="Code"><w:name w:val="Code"/><w:rPr><w:rFonts w:ascii="Courier New" w:hAnsi="Courier New"/></w:rPr></w:style>'
+    + '</w:styles>')
+  zip.file('word/numbering.xml', '<?xml version="1.0" encoding="UTF-8"?>'
+    + '<w:numbering xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">'
+    + '<w:abstractNum w:abstractNumId="1"><w:lvl w:ilvl="0"><w:numFmt w:val="bullet"/><w:lvlText w:val="•"/></w:lvl></w:abstractNum>'
+    + '<w:abstractNum w:abstractNumId="2"><w:lvl w:ilvl="0"><w:numFmt w:val="decimal"/><w:lvlText w:val="%1."/></w:lvl></w:abstractNum>'
+    + '<w:num w:numId="1"><w:abstractNumId w:val="1"/></w:num><w:num w:numId="2"><w:abstractNumId w:val="2"/></w:num>'
+    + '</w:numbering>')
+  const relationships = [
+    '<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>',
+    '<Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering" Target="numbering.xml"/>',
+  ]
+  for (const image of state.images) {
+    zip.file('word/media/image' + image.imageId + '.' + image.extension, image.bytes)
+    relationships.push('<Relationship Id="' + image.relationshipId + '" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="media/image' + image.imageId + '.' + image.extension + '"/>')
+  }
+  zip.file('word/_rels/document.xml.rels', '<?xml version="1.0" encoding="UTF-8"?>'
+    + '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">'
+    + relationships.join('') + '</Relationships>')
+  return zip.generateAsync({ type: 'uint8array', compression: 'DEFLATE', compressionOptions: { level: 6 } })
+}
+
+;(async () => {
+  const imported = typeof workerData.modulePath === 'string'
+    ? require(workerData.modulePath)
+    : require('node:module').createRequire(workerData.requireFrom)(workerData.moduleSpecifier)
+  const JSZip = typeof imported === 'function' ? imported : imported && imported.default
+  if (typeof JSZip !== 'function') throw new Error('[internal] JSZip export is not callable')
+  const bytes = await convert(htmlToDocumentJson(workerData.html), JSZip)
+  if (bytes.byteLength > workerData.maxOutputBytes) {
+    parentPort.postMessage({ type: 'overflow' })
+    parentPort.close()
+    return
+  }
+
+  parentPort.postMessage({ type: 'start', totalBytes: bytes.byteLength })
+  for (let offset = 0; offset < bytes.byteLength; offset += workerData.chunkBytes) {
+    const length = Math.min(workerData.chunkBytes, bytes.byteLength - offset)
+    const chunk = new Uint8Array(length)
+    chunk.set(bytes.subarray(offset, offset + length))
+    parentPort.postMessage({ type: 'chunk', chunk }, [chunk.buffer])
+  }
+  parentPort.postMessage({ type: 'done' })
+  parentPort.close()
+})().catch((error) => {
+  parentPort.postMessage({
+    type: 'error',
+    message: error && typeof error.message === 'string' ? error.message : 'DOCX conversion failed',
+  })
+  parentPort.close()
+})
+`;
+const requireFromHere = createRequire(import.meta.url);
+function defaultWorkerFactory(input) {
+  return new Worker(DOCX_WORKER_SOURCE, {
+    eval: true,
+    workerData: input,
+    resourceLimits: DOCX_WORKER_RESOURCE_LIMITS,
+    // `--input-type=module` is valid only for the parent's eval/stdin entry and
+    // would reinterpret this deliberately CommonJS worker source. Preserve all
+    // other execArgv entries, including Yarn PnP loaders.
+    execArgv: process.execArgv.filter((arg) => !arg.startsWith("--input-type"))
+  });
+}
+function resolveDocxArchiveModuleReference() {
+  const tracedPath = requireFromHere.resolve("jszip");
+  return {
+    modulePath: typeof tracedPath === "string" && isAbsolute(tracedPath) ? tracedPath : null,
+    moduleSpecifier: "jszip",
+    requireFrom: import.meta.url
+  };
+}
+function createDocxRenderer(options = {}, deps = {}) {
+  const maxConcurrency = options.maxConcurrency ?? DOCX_RENDER_MAX_CONCURRENCY;
+  const maxQueue = options.maxQueue ?? DOCX_RENDER_MAX_QUEUE;
+  const acquireTimeoutMs = options.acquireTimeoutMs ?? DOCX_RENDER_ACQUIRE_TIMEOUT_MS;
+  const renderTimeoutMs = options.renderTimeoutMs ?? DOCX_RENDER_TIMEOUT_MS;
+  const maxOutputBytes = options.maxOutputBytes ?? DOCX_MAX_OUTPUT_BYTES;
+  const workerFactory = deps.workerFactory ?? defaultWorkerFactory;
+  const allocateOutput = deps.allocateOutput ?? ((byteLength) => new Uint8Array(byteLength));
+  let active = 0;
+  const waiters = [];
+  const grant = () => {
+    active += 1;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      active -= 1;
+      const waiter = waiters.shift();
+      if (!waiter) return;
+      clearTimeout(waiter.timer);
+      waiter.resolve(grant());
+    };
+  };
+  const acquire = async () => {
+    if (active < maxConcurrency) return grant();
+    if (waiters.length >= maxQueue) throw new DocxRenderOverloadedError();
+    return await new Promise((resolve, reject) => {
+      const waiter = {
+        resolve,
+        reject,
+        timer: setTimeout(() => {
+          const index = waiters.indexOf(waiter);
+          if (index >= 0) waiters.splice(index, 1);
+          reject(new DocxRenderOverloadedError());
+        }, acquireTimeoutMs)
+      };
+      waiters.push(waiter);
+    });
+  };
+  const runWorker = (html) => new Promise((resolve, reject) => {
+    let worker;
+    try {
+      const moduleReference = deps.modulePath === void 0 ? resolveDocxArchiveModuleReference() : { modulePath: deps.modulePath, moduleSpecifier: "jszip", requireFrom: import.meta.url };
+      worker = workerFactory({
+        html,
+        ...moduleReference,
+        maxOutputBytes,
+        chunkBytes: DOCX_WORKER_CHUNK_BYTES
+      });
+    } catch (error) {
+      reject(new DocxRenderFailedError({ cause: error }));
+      return;
+    }
+    let settled = false;
+    let output = null;
+    let expectedBytes = null;
+    let receivedBytes = 0;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      void worker.terminate().catch(() => void 0).then(() => {
+        reject(new DocxRenderTimeoutError());
+      });
+    }, renderTimeoutMs);
+    const terminateAndReject = (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      void worker.terminate().catch(() => void 0).then(() => reject(error));
+    };
+    const terminateAndResolve = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      void worker.terminate().catch(() => void 0).then(() => resolve(value));
+    };
+    worker.on("message", (message) => {
+      if (settled || !message || typeof message !== "object") return;
+      const record = message;
+      if (record.type === "overflow") {
+        terminateAndReject(new DocxRenderOutputTooLargeError());
+        return;
+      }
+      if (record.type === "error") {
+        const message2 = typeof record.message === "string" ? record.message : "DOCX worker reported an unknown conversion failure";
+        terminateAndReject(new DocxRenderFailedError({ cause: new Error(message2) }));
+        return;
+      }
+      if (record.type === "start") {
+        const totalBytes = record.totalBytes;
+        if (expectedBytes !== null || typeof totalBytes !== "number" || !Number.isSafeInteger(totalBytes) || totalBytes < 0 || totalBytes > maxOutputBytes) {
+          terminateAndReject(new DocxRenderOutputTooLargeError());
+          return;
+        }
+        try {
+          output = allocateOutput(totalBytes);
+          if (output.byteLength !== totalBytes) throw new Error("[internal] invalid DOCX output allocation");
+          expectedBytes = totalBytes;
+        } catch (error) {
+          terminateAndReject(new DocxRenderFailedError({ cause: error }));
+        }
+        return;
+      }
+      if (record.type === "chunk") {
+        const chunk = record.chunk;
+        if (expectedBytes === null || !output || !(chunk instanceof Uint8Array) || receivedBytes + chunk.byteLength > expectedBytes || receivedBytes + chunk.byteLength > maxOutputBytes) {
+          terminateAndReject(new DocxRenderOutputTooLargeError());
+          return;
+        }
+        output.set(chunk, receivedBytes);
+        receivedBytes += chunk.byteLength;
+        return;
+      }
+      if (record.type === "done") {
+        if (expectedBytes === null || !output || receivedBytes !== expectedBytes) {
+          terminateAndReject(new DocxRenderFailedError());
+          return;
+        }
+        terminateAndResolve(output);
+      }
+    });
+    worker.on("error", (error) => terminateAndReject(new DocxRenderFailedError({ cause: error })));
+    worker.on("exit", (code) => {
+      if (!settled) terminateAndReject(new DocxRenderFailedError({ cause: new Error(`DOCX worker exited with code ${code}`) }));
+    });
+  });
+  const render = async (html) => {
+    const release = await acquire();
+    try {
+      return await runWorker(html);
+    } finally {
+      release();
+    }
+  };
+  return { render };
+}
+const DOCX_RENDERER_KEY = /* @__PURE__ */ Symbol.for("open-mercato.documents.docxRenderer");
+const globalStore = globalThis;
+const processDocxRenderer = globalStore[DOCX_RENDERER_KEY] ?? (globalStore[DOCX_RENDERER_KEY] = createDocxRenderer());
+const renderDocxWithCapacity = processDocxRenderer.render;
+export {
+  DOCX_MAX_OUTPUT_BYTES,
+  DOCX_RENDER_ACQUIRE_TIMEOUT_MS,
+  DOCX_RENDER_MAX_CONCURRENCY,
+  DOCX_RENDER_MAX_QUEUE,
+  DOCX_RENDER_TIMEOUT_MS,
+  DOCX_WORKER_CHUNK_BYTES,
+  DOCX_WORKER_RESOURCE_LIMITS,
+  DocxRenderFailedError,
+  DocxRenderOutputTooLargeError,
+  DocxRenderOverloadedError,
+  DocxRenderTimeoutError,
+  createDocxRenderer,
+  isDocxRenderFailedError,
+  isDocxRenderOutputTooLargeError,
+  isDocxRenderOverloadedError,
+  isDocxRenderTimeoutError,
+  renderDocxWithCapacity
+};
+//# sourceMappingURL=docxRenderer.js.map