fable-editor 1.3.0 → 1.3.2

package/dist/angular/esm2022/core/word-image-paste.mjs

@@ -82,9 +82,14 @@ function decodePict(body) {
         kind = 'metafile';
     if (!kind)
         return null;
+    /* Each removal leaves a space behind. Deleting outright would glue what surrounded
+       it together, and Word ends the picture header with `\bliptagN{\*\blipuid …}`
+       hard against the payload: dropping the uid group would let the \bliptag
+       parameter's `\d*` run straight on into the hex and eat its leading digits
+       (89504e47… -> e470…), which silently corrupts every picture Word sends. */
     let hex = body
-        .replace(/\{[^{}]*\}/g, '') // nested property groups
-        .replace(/\\[a-z]+-?\d*\s?/gi, '') // control words
+        .replace(/\{[^{}]*\}/g, ' ') // nested property groups
+        .replace(/\\[a-z]+-?\d*\s?/gi, ' ') // control words
         .replace(/[^0-9a-fA-F]/g, '');
     if (hex.length % 2)
         hex = hex.slice(0, -1);
@@ -127,6 +132,70 @@ export function extractRtfImages(rtf) {
         return data;
     });
 }
+/** CSS length -> px, so a VML shape's size survives as the <img> width/height the
+ *  paste engine allows. Unknown units are left for the caller to skip. */
+function cssPx(value) {
+    const m = value.match(/^\s*(-?[\d.]+)\s*(pt|px|in|cm|mm)?\s*$/i);
+    if (!m)
+        return null;
+    const n = parseFloat(m[1]);
+    if (!isFinite(n) || n <= 0)
+        return null;
+    const unit = (m[2] || 'px').toLowerCase();
+    const px = unit === 'pt' ? (n * 4) / 3 : unit === 'in' ? n * 96 : unit === 'cm' ? (n * 96) / 2.54 : unit === 'mm' ? (n * 96) / 25.4 : n;
+    return Math.round(px);
+}
+function attrOf(tag, name) {
+    const m = tag.match(new RegExp('\\s' + name + '\\s*=\\s*(?:"([^"]*)"|\'([^\']*)\'|([^\\s>]+))', 'i'));
+    return m ? m[1] ?? m[2] ?? m[3] ?? '' : '';
+}
+/** Word describes a picture twice: as a VML shape inside a downlevel-hidden
+ *  conditional comment, and as a plain <img> fallback after it. With RelyOnVML on —
+ *  which is what a cropped picture gets — it writes only the shape, and the paste
+ *  engine drops conditional comments, so the picture has no tag left to land on and
+ *  disappears. Give those shapes the <img> Word withheld, keeping the shape's size.
+ *  Pictures that do have the fallback are recognised by their src and left alone.
+ *
+ *  The shape's crop attributes are not applied: the picture appears uncropped. */
+export function unwrapVmlImages(html) {
+    if (!/<v:imagedata\b/i.test(html))
+        return html;
+    /** The <img> Word withheld, or null when it did supply one (recognised by its src)
+     *  and the shape is therefore only the duplicate description of the same picture.
+     *  `sizing` is whatever markup the shape's style attribute can be read from. */
+    const imgFor = (imagedata, sizing) => {
+        const src = attrOf(imagedata, 'src');
+        if (!src)
+            return null;
+        const quoted = src.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        if (new RegExp('<img\\b[^>]*\\bsrc\\s*=\\s*["\']?' + quoted, 'i').test(html))
+            return null;
+        const style = (sizing.match(/<v:shape\b[^>]*\sstyle\s*=\s*(?:"([^"]*)"|'([^']*)')/i) || []).slice(1).find(Boolean) || '';
+        const w = cssPx((style.match(/(?:^|;)\s*width\s*:\s*([^;]+)/i) || [])[1] || '');
+        const h = cssPx((style.match(/(?:^|;)\s*height\s*:\s*([^;]+)/i) || [])[1] || '');
+        return ('<img src="' +
+            src.replace(/"/g, '&quot;') +
+            '"' +
+            (w ? ' width="' + w + '"' : '') +
+            (h ? ' height="' + h + '"' : '') +
+            '>');
+    };
+    /* Downlevel-hidden shape: an <img> put inside would stay inside a comment and never
+       reach the DOM, so the whole block has to go. */
+    let out = html.replace(/<!--\[if [^\]]*\]>([\s\S]*?)<!\[endif\]-->/gi, (block, inner) => {
+        const data = inner.match(/<v:imagedata\b[^>]*>/i);
+        return (data && imgFor(data[0], inner)) || block;
+    });
+    /* Live shape: with RelyOnVML on, Word writes the shape into the document itself
+       (bare, or inside a downlevel-revealed <![if gte vml 1]> that the parser drops),
+       counting on the v\:*{behavior:url(#default#VML)} rule it ships in <head>. */
+    out = out.replace(/<v:shape\b[^>]*>[\s\S]*?<\/v:shape\s*>/gi, (shape) => {
+        const data = shape.match(/<v:imagedata\b[^>]*>/i);
+        return (data && imgFor(data[0], shape)) || shape;
+    });
+    /* An imagedata with no shape left to take its size from. */
+    return out.replace(/<v:imagedata\b[^>]*>/gi, (data) => imgFor(data, '') || data);
+}
 /** Rewrites unusable <img src> values in raw pasted HTML with the pictures given, in
  *  document order. Images that already have a usable src are left alone and do not
  *  consume a slot, so a mixed paste (webmail image + Word image) stays aligned.
@@ -136,7 +205,7 @@ export function injectImages(html, imgs) {
         return { html, injected: [] };
     const injected = [];
     let next = 0;
-    const out = html.replace(/<img\b[^>]*>/gi, (tag) => {
+    const out = unwrapVmlImages(html).replace(/<img\b[^>]*>/gi, (tag) => {
         const src = (tag.match(/\ssrc\s*=\s*["']?([^"'\s>]+)/i) || [])[1] || '';
         if (USABLE_SRC.test(src))
             return tag;
@@ -186,4 +255,4 @@ export function dataUrlToFile(dataUrl, baseName) {
         return null;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"word-image-paste.js","sourceRoot":"","sources":["../../../../src/core/word-image-paste.ts"],"names":[],"mappings":"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","sourcesContent":["/* Recovers the pictures that desktop Word leaves out of the HTML clipboard flavor.\n   Word writes <img src=\"file:///…/msohtmlclip1/01/clip_image001.png\"> — a local temp\n   file the browser cannot read — but the same paste also carries a text/rtf flavor\n   with every picture embedded as hex inside a {\\pict} group. Pairing the two is how\n   TinyMCE PowerPaste implements powerpaste_allow_local_images.\n\n   This runs on the RAW html string BEFORE cleanPastedHTML() sees it: the paste engine\n   already allows data: URIs, so it needs no change and its behaviour is unaffected.\n   Anything this module cannot recover is left exactly as it was, and still ends up on\n   the engine's existing \"[local image — paste it separately]\" placeholder. */\n\n/** Decoded pictures in document order. A slot is null when the picture exists but\n *  cannot be turned into something the browser can show (a true vector metafile). */\nexport type RtfImages = (string | null)[];\n\n/** Total decoded bytes we are willing to inline from one paste. A Word document full\n *  of full-page screenshots can run to tens of MB; past this we leave the placeholders\n *  rather than freeze the editor building base64 strings. */\nconst MAX_TOTAL_BYTES = 10 * 1024 * 1024;\n\nconst USABLE_SRC = /^(https?:|data:image\\/|blob:)/i;\n\n/** Scans for `{\\keyword …}` groups, tracking brace depth so nested groups such as\n *  `{\\*\\picprop …}` inside a picture do not terminate the match early (a lazy\n *  `/\\{\\\\pict[\\s\\S]*?\\}/` regex gets this wrong and truncates the hex payload). */\nfunction findGroups(rtf: string, keyword: string): { start: number; end: number; body: string }[] {\n  const out: { start: number; end: number; body: string }[] = [];\n  const needle = '{\\\\' + keyword;\n  let i = 0;\n  while ((i = rtf.indexOf(needle, i)) !== -1) {\n    /* the char after the control word must be a delimiter, so \\pict does not also\n       match \\pictscalex and friends */\n    const after = rtf[i + needle.length];\n    if (after && /[a-z0-9]/i.test(after)) {\n      i += needle.length;\n      continue;\n    }\n    let depth = 0;\n    let j = i;\n    for (; j < rtf.length; j++) {\n      const c = rtf[j];\n      if (c === '\\\\') {\n        j++;\n        continue;\n      }\n      if (c === '{') depth++;\n      else if (c === '}') {\n        depth--;\n        if (!depth) break;\n      }\n    }\n    out.push({ start: i, end: j + 1, body: rtf.slice(i + needle.length, j) });\n    i = j + 1;\n  }\n  return out;\n}\n\nfunction hexToBytes(hex: string): Uint8Array {\n  const bytes = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(hex.substr(i * 2, 2), 16);\n  return bytes;\n}\n\nfunction toBase64(bytes: Uint8Array): string {\n  let bin = '';\n  for (let i = 0; i < bytes.length; i++) bin += String.fromCharCode(bytes[i]);\n  return btoa(bin);\n}\n\nfunction indexOfSig(bytes: Uint8Array, sig: number[]): number {\n  outer: for (let i = 0; i + sig.length <= bytes.length; i++) {\n    for (let j = 0; j < sig.length; j++) if (bytes[i + j] !== sig[j]) continue outer;\n    return i;\n  }\n  return -1;\n}\n\nconst PNG_SIG = [0x89, 0x50, 0x4e, 0x47];\nconst JPG_SIG = [0xff, 0xd8, 0xff];\n\nfunction decodePict(body: string): string | null {\n  let kind: 'image/png' | 'image/jpeg' | 'metafile' | null = null;\n  if (/\\\\pngblip/.test(body)) kind = 'image/png';\n  else if (/\\\\jpegblip/.test(body)) kind = 'image/jpeg';\n  else if (/\\\\wmetafile\\d*/.test(body) || /\\\\emfblip/.test(body)) kind = 'metafile';\n  if (!kind) return null;\n\n  let hex = body\n    .replace(/\\{[^{}]*\\}/g, '') // nested property groups\n    .replace(/\\\\[a-z]+-?\\d*\\s?/gi, '') // control words\n    .replace(/[^0-9a-fA-F]/g, '');\n  if (hex.length % 2) hex = hex.slice(0, -1);\n  if (!hex) return null;\n\n  const bytes = hexToBytes(hex);\n  if (kind === 'metafile') {\n    /* Word wraps a bitmap in a metafile for compatibility; when there is a real\n       PNG/JPEG inside we can use it. A genuine vector metafile we cannot render. */\n    const png = indexOfSig(bytes, PNG_SIG);\n    if (png >= 0) return 'data:image/png;base64,' + toBase64(bytes.slice(png));\n    const jpg = indexOfSig(bytes, JPG_SIG);\n    if (jpg >= 0) return 'data:image/jpeg;base64,' + toBase64(bytes.slice(jpg));\n    return null;\n  }\n  return 'data:' + kind + ';base64,' + toBase64(bytes);\n}\n\n/** Every picture in the RTF flavor, in document order. */\nexport function extractRtfImages(rtf: string): RtfImages {\n  if (!rtf || rtf.indexOf('\\\\pict') === -1) return [];\n  /* Word emits {\\*\\shppict{\\pict …}}{\\nonshppict{\\pict …}} — the second group is a\n     legacy duplicate of the first. Dropping it keeps picture order aligned with the\n     <img> tags in the HTML flavor. */\n  let cleaned = rtf;\n  findGroups(rtf, 'nonshppict')\n    .reverse()\n    .forEach((g) => {\n      cleaned = cleaned.slice(0, g.start) + cleaned.slice(g.end);\n    });\n\n  let budget = MAX_TOTAL_BYTES;\n  return findGroups(cleaned, 'pict').map((g) => {\n    if (budget <= 0) return null;\n    const data = decodePict(g.body);\n    if (data) budget -= data.length * 0.75; // base64 -> approximate byte count\n    return data;\n  });\n}\n\nexport interface InjectResult {\n  html: string;\n  /** The data URIs this call put into the HTML, in the order they were used. Only\n   *  these are candidates for the host's imageUploadHandler — data URIs that were\n   *  already in the pasted HTML are left alone, so existing paste behaviour is\n   *  unchanged. */\n  injected: string[];\n}\n\n/** Rewrites unusable <img src> values in raw pasted HTML with the pictures given, in\n *  document order. Images that already have a usable src are left alone and do not\n *  consume a slot, so a mixed paste (webmail image + Word image) stays aligned.\n *  Anything without a matching picture keeps its original tag. */\nexport function injectImages(html: string, imgs: RtfImages): InjectResult {\n  if (!html || !imgs.length) return { html, injected: [] };\n  const injected: string[] = [];\n  let next = 0;\n  const out = html.replace(/<img\\b[^>]*>/gi, (tag) => {\n    const src = (tag.match(/\\ssrc\\s*=\\s*[\"']?([^\"'\\s>]+)/i) || [])[1] || '';\n    if (USABLE_SRC.test(src)) return tag;\n    const data = imgs[next++];\n    if (!data) return tag;\n    injected.push(data);\n    return /\\ssrc\\s*=\\s*[\"']/i.test(tag)\n      ? tag.replace(/(\\ssrc\\s*=\\s*)([\"'])[^\"']*\\2/i, '$1\"' + data + '\"')\n      : tag.replace(/(\\ssrc\\s*=\\s*)[^\\s>]+/i, '$1\"' + data + '\"');\n  });\n  return { html: out, injected };\n}\n\n/** Pairs the HTML flavor of a Word paste with the pictures in its RTF flavor. */\nexport function injectRtfImages(html: string, rtf: string): InjectResult {\n  if (!html || !rtf) return { html, injected: [] };\n  return injectImages(html, extractRtfImages(rtf));\n}\n\n/** True when the cleaned HTML still holds images the engine could not resolve — used\n *  to decide whether a bitmap sitting in the clipboard is worth falling back to. */\nexport function countUnresolvedImages(html: string): number {\n  const tags = html.match(/<img\\b[^>]*>/gi);\n  if (!tags) return 0;\n  return tags.filter((tag) => {\n    const src = (tag.match(/\\ssrc\\s*=\\s*[\"']?([^\"'\\s>]+)/i) || [])[1] || '';\n    return !USABLE_SRC.test(src);\n  }).length;\n}\n\n/** data: URI -> File, so recovered pictures can go through the host's\n *  imageUploadHandler exactly like a picked file does. `baseName` gets the extension\n *  that matches the URI's MIME type. */\nexport function dataUrlToFile(dataUrl: string, baseName: string): File | null {\n  const m = dataUrl.match(/^data:([^;,]+);base64,(.*)$/);\n  if (!m) return null;\n  const ext = (m[1].split('/')[1] || 'png').replace(/[^a-z0-9]/gi, '') || 'png';\n  try {\n    const bin = atob(m[2]);\n    const bytes = new Uint8Array(bin.length);\n    for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);\n    return new File([bytes], baseName + '.' + (ext === 'jpeg' ? 'jpg' : ext), { type: m[1] });\n  } catch (e) {\n    return null;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"word-image-paste.js","sourceRoot":"","sources":["../../../../src/core/word-image-paste.ts"],"names":[],"mappings":"AAAA;;;;;;;;;8EAS8E;AAM9E;;6DAE6D;AAC7D,MAAM,eAAe,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;AAEzC,MAAM,UAAU,GAAG,gCAAgC,CAAC;AAEpD;;mFAEmF;AACnF,SAAS,UAAU,CAAC,GAAW,EAAE,OAAe;IAC9C,MAAM,GAAG,GAAmD,EAAE,CAAC;IAC/D,MAAM,MAAM,GAAG,KAAK,GAAG,OAAO,CAAC;IAC/B,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,OAAO,CAAC,CAAC,GAAG,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;QAC3C;2CACmC;QACnC,MAAM,KAAK,GAAG,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QACrC,IAAI,KAAK,IAAI,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACrC,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC;YACnB,SAAS;QACX,CAAC;QACD,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,OAAO,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3B,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;YACjB,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC;gBACf,CAAC,EAAE,CAAC;gBACJ,SAAS;YACX,CAAC;YACD,IAAI,CAAC,KAAK,GAAG;gBAAE,KAAK,EAAE,CAAC;iBAClB,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;gBACnB,KAAK,EAAE,CAAC;gBACR,IAAI,CAAC,KAAK;oBAAE,MAAM;YACpB,CAAC;QACH,CAAC;QACD,GAAG,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;QAC1E,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACZ,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,UAAU,CAAC,GAAW;IAC7B,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC7C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE;QAAE,KAAK,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACrF,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,QAAQ,CAAC,KAAiB;IACjC,IAAI,GAAG,GAAG,EAAE,CAAC;IACb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE;QAAE,GAAG,IAAI,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5E,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;AACnB,CAAC;AAED,SAAS,UAAU,CAAC,KAAiB,EAAE,GAAa;IAClD,KAAK,EAAE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE;YAAE,IAAI,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;gBAAE,SAAS,KAAK,CAAC;QACjF,OAAO,CAAC,CAAC;IACX,CAAC;IACD,OAAO,CAAC,CAAC,CAAC;AACZ,CAAC;AAED,MAAM,OAAO,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AACzC,MAAM,OAAO,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AAEnC,SAAS,UAAU,CAAC,IAAY;IAC9B,IAAI,IAAI,GAAmD,IAAI,CAAC;IAChE,IAAI,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,IAAI,GAAG,WAAW,CAAC;SAC1C,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,IAAI,GAAG,YAAY,CAAC;SACjD,IAAI,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,IAAI,GAAG,UAAU,CAAC;IAClF,IAAI,CAAC,IAAI;QAAE,OAAO,IAAI,CAAC;IAEvB;;;;iFAI6E;IAC7E,IAAI,GAAG,GAAG,IAAI;SACX,OAAO,CAAC,aAAa,EAAE,GAAG,CAAC,CAAC,yBAAyB;SACrD,OAAO,CAAC,oBAAoB,EAAE,GAAG,CAAC,CAAC,gBAAgB;SACnD,OAAO,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC;IAChC,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC;QAAE,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC3C,IAAI,CAAC,GAAG;QAAE,OAAO,IAAI,CAAC;IAEtB,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;IAC9B,IAAI,IAAI,KAAK,UAAU,EAAE,CAAC;QACxB;wFACgF;QAChF,MAAM,GAAG,GAAG,UAAU,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACvC,IAAI,GAAG,IAAI,CAAC;YAAE,OAAO,wBAAwB,GAAG,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3E,MAAM,GAAG,GAAG,UAAU,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACvC,IAAI,GAAG,IAAI,CAAC;YAAE,OAAO,yBAAyB,GAAG,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;QAC5E,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,OAAO,GAAG,IAAI,GAAG,UAAU,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;AACvD,CAAC;AAED,0DAA0D;AAC1D,MAAM,UAAU,gBAAgB,CAAC,GAAW;IAC1C,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAAE,OAAO,EAAE,CAAC;IACpD;;wCAEoC;IACpC,IAAI,OAAO,GAAG,GAAG,CAAC;IAClB,UAAU,CAAC,GAAG,EAAE,YAAY,CAAC;SAC1B,OAAO,EAAE;SACT,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;QACb,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAC7D,CAAC,CAAC,CAAC;IAEL,IAAI,MAAM,GAAG,eAAe,CAAC;IAC7B,OAAO,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;QAC3C,IAAI,MAAM,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC;QAC7B,MAAM,IAAI,GAAG,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,IAAI;YAAE,MAAM,IAAI,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,mCAAmC;QAC3E,OAAO,IAAI,CAAC;IACd,CAAC,CAAC,CAAC;AACL,CAAC;AAWD;0EAC0E;AAC1E,SAAS,KAAK,CAAC,KAAa;IAC1B,MAAM,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,yCAAyC,CAAC,CAAC;IACjE,IAAI,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IACpB,MAAM,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3B,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IACxC,MAAM,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;IAC1C,MAAM,EAAE,GACN,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/H,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;AACxB,CAAC;AAED,SAAS,MAAM,CAAC,GAAW,EAAE,IAAY;IACvC,MAAM,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,KAAK,GAAG,IAAI,GAAG,gDAAgD,EAAE,GAAG,CAAC,CAAC,CAAC;IACtG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;AAC7C,CAAC;AAED;;;;;;;kFAOkF;AAClF,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAE/C;;oFAEgF;IAChF,MAAM,MAAM,GAAG,CAAC,SAAiB,EAAE,MAAc,EAAiB,EAAE;QAClE,MAAM,GAAG,GAAG,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QACrC,IAAI,CAAC,GAAG;YAAE,OAAO,IAAI,CAAC;QACtB,MAAM,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;QAC1D,IAAI,IAAI,MAAM,CAAC,mCAAmC,GAAG,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC;QAC1F,MAAM,KAAK,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,uDAAuD,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;QACzH,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,gCAAgC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QAChF,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,iCAAiC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QACjF,OAAO,CACL,YAAY;YACZ,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC;YAC3B,GAAG;YACH,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;YAC/B,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;YAChC,GAAG,CACJ,CAAC;IACJ,CAAC,CAAC;IAEF;sDACkD;IAClD,IAAI,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,8CAA8C,EAAE,CAAC,KAAK,EAAE,KAAa,EAAE,EAAE;QAC9F,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAClD,OAAO,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,IAAI,KAAK,CAAC;IACnD,CAAC,CAAC,CAAC;IAEH;;mFAE+E;IAC/E,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,0CAA0C,EAAE,CAAC,KAAK,EAAE,EAAE;QACtE,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAClD,OAAO,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,IAAI,KAAK,CAAC;IACnD,CAAC,CAAC,CAAC;IAEH,4DAA4D;IAC5D,OAAO,GAAG,CAAC,OAAO,CAAC,wBAAwB,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC;AACnF,CAAC;AAED;;;kEAGkE;AAClE,MAAM,UAAU,YAAY,CAAC,IAAY,EAAE,IAAe;IACxD,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;IACzD,MAAM,QAAQ,GAAa,EAAE,CAAC;IAC9B,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,MAAM,GAAG,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,gBAAgB,EAAE,CAAC,GAAG,EAAE,EAAE;QAClE,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,+BAA+B,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QACxE,IAAI,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC;YAAE,OAAO,GAAG,CAAC;QACrC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QAC1B,IAAI,CAAC,IAAI;YAAE,OAAO,GAAG,CAAC;QACtB,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpB,OAAO,mBAAmB,CAAC,IAAI,CAAC,GAAG,CAAC;YAClC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,+BAA+B,EAAE,KAAK,GAAG,IAAI,GAAG,GAAG,CAAC;YAClE,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,wBAAwB,EAAE,KAAK,GAAG,IAAI,GAAG,GAAG,CAAC,CAAC;IAChE,CAAC,CAAC,CAAC;IACH,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC;AACjC,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,eAAe,CAAC,IAAY,EAAE,GAAW;IACvD,IAAI,CAAC,IAAI,IAAI,CAAC,GAAG;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;IACjD,OAAO,YAAY,CAAC,IAAI,EAAE,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC;AACnD,CAAC;AAED;oFACoF;AACpF,MAAM,UAAU,qBAAqB,CAAC,IAAY;IAChD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;IAC1C,IAAI,CAAC,IAAI;QAAE,OAAO,CAAC,CAAC;IACpB,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE;QACzB,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,+BAA+B,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QACxE,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC/B,CAAC,CAAC,CAAC,MAAM,CAAC;AACZ,CAAC;AAED;;wCAEwC;AACxC,MAAM,UAAU,aAAa,CAAC,OAAe,EAAE,QAAgB;IAC7D,MAAM,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,6BAA6B,CAAC,CAAC;IACvD,IAAI,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IACpB,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC,IAAI,KAAK,CAAC;IAC9E,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACvB,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACzC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE;YAAE,KAAK,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAClE,OAAO,IAAI,IAAI,CAAC,CAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,GAAG,GAAG,CAAC,GAAG,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAC5F,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC","sourcesContent":["/* Recovers the pictures that desktop Word leaves out of the HTML clipboard flavor.\n   Word writes <img src=\"file:///…/msohtmlclip1/01/clip_image001.png\"> — a local temp\n   file the browser cannot read — but the same paste also carries a text/rtf flavor\n   with every picture embedded as hex inside a {\\pict} group. Pairing the two is how\n   TinyMCE PowerPaste implements powerpaste_allow_local_images.\n\n   This runs on the RAW html string BEFORE cleanPastedHTML() sees it: the paste engine\n   already allows data: URIs, so it needs no change and its behaviour is unaffected.\n   Anything this module cannot recover is left exactly as it was, and still ends up on\n   the engine's existing \"[local image — paste it separately]\" placeholder. */\n\n/** Decoded pictures in document order. A slot is null when the picture exists but\n *  cannot be turned into something the browser can show (a true vector metafile). */\nexport type RtfImages = (string | null)[];\n\n/** Total decoded bytes we are willing to inline from one paste. A Word document full\n *  of full-page screenshots can run to tens of MB; past this we leave the placeholders\n *  rather than freeze the editor building base64 strings. */\nconst MAX_TOTAL_BYTES = 10 * 1024 * 1024;\n\nconst USABLE_SRC = /^(https?:|data:image\\/|blob:)/i;\n\n/** Scans for `{\\keyword …}` groups, tracking brace depth so nested groups such as\n *  `{\\*\\picprop …}` inside a picture do not terminate the match early (a lazy\n *  `/\\{\\\\pict[\\s\\S]*?\\}/` regex gets this wrong and truncates the hex payload). */\nfunction findGroups(rtf: string, keyword: string): { start: number; end: number; body: string }[] {\n  const out: { start: number; end: number; body: string }[] = [];\n  const needle = '{\\\\' + keyword;\n  let i = 0;\n  while ((i = rtf.indexOf(needle, i)) !== -1) {\n    /* the char after the control word must be a delimiter, so \\pict does not also\n       match \\pictscalex and friends */\n    const after = rtf[i + needle.length];\n    if (after && /[a-z0-9]/i.test(after)) {\n      i += needle.length;\n      continue;\n    }\n    let depth = 0;\n    let j = i;\n    for (; j < rtf.length; j++) {\n      const c = rtf[j];\n      if (c === '\\\\') {\n        j++;\n        continue;\n      }\n      if (c === '{') depth++;\n      else if (c === '}') {\n        depth--;\n        if (!depth) break;\n      }\n    }\n    out.push({ start: i, end: j + 1, body: rtf.slice(i + needle.length, j) });\n    i = j + 1;\n  }\n  return out;\n}\n\nfunction hexToBytes(hex: string): Uint8Array {\n  const bytes = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(hex.substr(i * 2, 2), 16);\n  return bytes;\n}\n\nfunction toBase64(bytes: Uint8Array): string {\n  let bin = '';\n  for (let i = 0; i < bytes.length; i++) bin += String.fromCharCode(bytes[i]);\n  return btoa(bin);\n}\n\nfunction indexOfSig(bytes: Uint8Array, sig: number[]): number {\n  outer: for (let i = 0; i + sig.length <= bytes.length; i++) {\n    for (let j = 0; j < sig.length; j++) if (bytes[i + j] !== sig[j]) continue outer;\n    return i;\n  }\n  return -1;\n}\n\nconst PNG_SIG = [0x89, 0x50, 0x4e, 0x47];\nconst JPG_SIG = [0xff, 0xd8, 0xff];\n\nfunction decodePict(body: string): string | null {\n  let kind: 'image/png' | 'image/jpeg' | 'metafile' | null = null;\n  if (/\\\\pngblip/.test(body)) kind = 'image/png';\n  else if (/\\\\jpegblip/.test(body)) kind = 'image/jpeg';\n  else if (/\\\\wmetafile\\d*/.test(body) || /\\\\emfblip/.test(body)) kind = 'metafile';\n  if (!kind) return null;\n\n  /* Each removal leaves a space behind. Deleting outright would glue what surrounded\n     it together, and Word ends the picture header with `\\bliptagN{\\*\\blipuid …}`\n     hard against the payload: dropping the uid group would let the \\bliptag\n     parameter's `\\d*` run straight on into the hex and eat its leading digits\n     (89504e47… -> e470…), which silently corrupts every picture Word sends. */\n  let hex = body\n    .replace(/\\{[^{}]*\\}/g, ' ') // nested property groups\n    .replace(/\\\\[a-z]+-?\\d*\\s?/gi, ' ') // control words\n    .replace(/[^0-9a-fA-F]/g, '');\n  if (hex.length % 2) hex = hex.slice(0, -1);\n  if (!hex) return null;\n\n  const bytes = hexToBytes(hex);\n  if (kind === 'metafile') {\n    /* Word wraps a bitmap in a metafile for compatibility; when there is a real\n       PNG/JPEG inside we can use it. A genuine vector metafile we cannot render. */\n    const png = indexOfSig(bytes, PNG_SIG);\n    if (png >= 0) return 'data:image/png;base64,' + toBase64(bytes.slice(png));\n    const jpg = indexOfSig(bytes, JPG_SIG);\n    if (jpg >= 0) return 'data:image/jpeg;base64,' + toBase64(bytes.slice(jpg));\n    return null;\n  }\n  return 'data:' + kind + ';base64,' + toBase64(bytes);\n}\n\n/** Every picture in the RTF flavor, in document order. */\nexport function extractRtfImages(rtf: string): RtfImages {\n  if (!rtf || rtf.indexOf('\\\\pict') === -1) return [];\n  /* Word emits {\\*\\shppict{\\pict …}}{\\nonshppict{\\pict …}} — the second group is a\n     legacy duplicate of the first. Dropping it keeps picture order aligned with the\n     <img> tags in the HTML flavor. */\n  let cleaned = rtf;\n  findGroups(rtf, 'nonshppict')\n    .reverse()\n    .forEach((g) => {\n      cleaned = cleaned.slice(0, g.start) + cleaned.slice(g.end);\n    });\n\n  let budget = MAX_TOTAL_BYTES;\n  return findGroups(cleaned, 'pict').map((g) => {\n    if (budget <= 0) return null;\n    const data = decodePict(g.body);\n    if (data) budget -= data.length * 0.75; // base64 -> approximate byte count\n    return data;\n  });\n}\n\nexport interface InjectResult {\n  html: string;\n  /** The data URIs this call put into the HTML, in the order they were used. Only\n   *  these are candidates for the host's imageUploadHandler — data URIs that were\n   *  already in the pasted HTML are left alone, so existing paste behaviour is\n   *  unchanged. */\n  injected: string[];\n}\n\n/** CSS length -> px, so a VML shape's size survives as the <img> width/height the\n *  paste engine allows. Unknown units are left for the caller to skip. */\nfunction cssPx(value: string): number | null {\n  const m = value.match(/^\\s*(-?[\\d.]+)\\s*(pt|px|in|cm|mm)?\\s*$/i);\n  if (!m) return null;\n  const n = parseFloat(m[1]);\n  if (!isFinite(n) || n <= 0) return null;\n  const unit = (m[2] || 'px').toLowerCase();\n  const px =\n    unit === 'pt' ? (n * 4) / 3 : unit === 'in' ? n * 96 : unit === 'cm' ? (n * 96) / 2.54 : unit === 'mm' ? (n * 96) / 25.4 : n;\n  return Math.round(px);\n}\n\nfunction attrOf(tag: string, name: string): string {\n  const m = tag.match(new RegExp('\\\\s' + name + '\\\\s*=\\\\s*(?:\"([^\"]*)\"|\\'([^\\']*)\\'|([^\\\\s>]+))', 'i'));\n  return m ? m[1] ?? m[2] ?? m[3] ?? '' : '';\n}\n\n/** Word describes a picture twice: as a VML shape inside a downlevel-hidden\n *  conditional comment, and as a plain <img> fallback after it. With RelyOnVML on —\n *  which is what a cropped picture gets — it writes only the shape, and the paste\n *  engine drops conditional comments, so the picture has no tag left to land on and\n *  disappears. Give those shapes the <img> Word withheld, keeping the shape's size.\n *  Pictures that do have the fallback are recognised by their src and left alone.\n *\n *  The shape's crop attributes are not applied: the picture appears uncropped. */\nexport function unwrapVmlImages(html: string): string {\n  if (!/<v:imagedata\\b/i.test(html)) return html;\n\n  /** The <img> Word withheld, or null when it did supply one (recognised by its src)\n   *  and the shape is therefore only the duplicate description of the same picture.\n   *  `sizing` is whatever markup the shape's style attribute can be read from. */\n  const imgFor = (imagedata: string, sizing: string): string | null => {\n    const src = attrOf(imagedata, 'src');\n    if (!src) return null;\n    const quoted = src.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n    if (new RegExp('<img\\\\b[^>]*\\\\bsrc\\\\s*=\\\\s*[\"\\']?' + quoted, 'i').test(html)) return null;\n    const style = (sizing.match(/<v:shape\\b[^>]*\\sstyle\\s*=\\s*(?:\"([^\"]*)\"|'([^']*)')/i) || []).slice(1).find(Boolean) || '';\n    const w = cssPx((style.match(/(?:^|;)\\s*width\\s*:\\s*([^;]+)/i) || [])[1] || '');\n    const h = cssPx((style.match(/(?:^|;)\\s*height\\s*:\\s*([^;]+)/i) || [])[1] || '');\n    return (\n      '<img src=\"' +\n      src.replace(/\"/g, '&quot;') +\n      '\"' +\n      (w ? ' width=\"' + w + '\"' : '') +\n      (h ? ' height=\"' + h + '\"' : '') +\n      '>'\n    );\n  };\n\n  /* Downlevel-hidden shape: an <img> put inside would stay inside a comment and never\n     reach the DOM, so the whole block has to go. */\n  let out = html.replace(/<!--\\[if [^\\]]*\\]>([\\s\\S]*?)<!\\[endif\\]-->/gi, (block, inner: string) => {\n    const data = inner.match(/<v:imagedata\\b[^>]*>/i);\n    return (data && imgFor(data[0], inner)) || block;\n  });\n\n  /* Live shape: with RelyOnVML on, Word writes the shape into the document itself\n     (bare, or inside a downlevel-revealed <![if gte vml 1]> that the parser drops),\n     counting on the v\\:*{behavior:url(#default#VML)} rule it ships in <head>. */\n  out = out.replace(/<v:shape\\b[^>]*>[\\s\\S]*?<\\/v:shape\\s*>/gi, (shape) => {\n    const data = shape.match(/<v:imagedata\\b[^>]*>/i);\n    return (data && imgFor(data[0], shape)) || shape;\n  });\n\n  /* An imagedata with no shape left to take its size from. */\n  return out.replace(/<v:imagedata\\b[^>]*>/gi, (data) => imgFor(data, '') || data);\n}\n\n/** Rewrites unusable <img src> values in raw pasted HTML with the pictures given, in\n *  document order. Images that already have a usable src are left alone and do not\n *  consume a slot, so a mixed paste (webmail image + Word image) stays aligned.\n *  Anything without a matching picture keeps its original tag. */\nexport function injectImages(html: string, imgs: RtfImages): InjectResult {\n  if (!html || !imgs.length) return { html, injected: [] };\n  const injected: string[] = [];\n  let next = 0;\n  const out = unwrapVmlImages(html).replace(/<img\\b[^>]*>/gi, (tag) => {\n    const src = (tag.match(/\\ssrc\\s*=\\s*[\"']?([^\"'\\s>]+)/i) || [])[1] || '';\n    if (USABLE_SRC.test(src)) return tag;\n    const data = imgs[next++];\n    if (!data) return tag;\n    injected.push(data);\n    return /\\ssrc\\s*=\\s*[\"']/i.test(tag)\n      ? tag.replace(/(\\ssrc\\s*=\\s*)([\"'])[^\"']*\\2/i, '$1\"' + data + '\"')\n      : tag.replace(/(\\ssrc\\s*=\\s*)[^\\s>]+/i, '$1\"' + data + '\"');\n  });\n  return { html: out, injected };\n}\n\n/** Pairs the HTML flavor of a Word paste with the pictures in its RTF flavor. */\nexport function injectRtfImages(html: string, rtf: string): InjectResult {\n  if (!html || !rtf) return { html, injected: [] };\n  return injectImages(html, extractRtfImages(rtf));\n}\n\n/** True when the cleaned HTML still holds images the engine could not resolve — used\n *  to decide whether a bitmap sitting in the clipboard is worth falling back to. */\nexport function countUnresolvedImages(html: string): number {\n  const tags = html.match(/<img\\b[^>]*>/gi);\n  if (!tags) return 0;\n  return tags.filter((tag) => {\n    const src = (tag.match(/\\ssrc\\s*=\\s*[\"']?([^\"'\\s>]+)/i) || [])[1] || '';\n    return !USABLE_SRC.test(src);\n  }).length;\n}\n\n/** data: URI -> File, so recovered pictures can go through the host's\n *  imageUploadHandler exactly like a picked file does. `baseName` gets the extension\n *  that matches the URI's MIME type. */\nexport function dataUrlToFile(dataUrl: string, baseName: string): File | null {\n  const m = dataUrl.match(/^data:([^;,]+);base64,(.*)$/);\n  if (!m) return null;\n  const ext = (m[1].split('/')[1] || 'png').replace(/[^a-z0-9]/gi, '') || 'png';\n  try {\n    const bin = atob(m[2]);\n    const bytes = new Uint8Array(bin.length);\n    for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);\n    return new File([bytes], baseName + '.' + (ext === 'jpeg' ? 'jpg' : ext), { type: m[1] });\n  } catch (e) {\n    return null;\n  }\n}\n"]}

package/dist/angular/fesm2022/fable-editor.mjs

@@ -1374,9 +1374,14 @@ function decodePict(body) {
         kind = 'metafile';
     if (!kind)
         return null;
+    /* Each removal leaves a space behind. Deleting outright would glue what surrounded
+       it together, and Word ends the picture header with `\bliptagN{\*\blipuid …}`
+       hard against the payload: dropping the uid group would let the \bliptag
+       parameter's `\d*` run straight on into the hex and eat its leading digits
+       (89504e47… -> e470…), which silently corrupts every picture Word sends. */
     let hex = body
-        .replace(/\{[^{}]*\}/g, '') // nested property groups
-        .replace(/\\[a-z]+-?\d*\s?/gi, '') // control words
+        .replace(/\{[^{}]*\}/g, ' ') // nested property groups
+        .replace(/\\[a-z]+-?\d*\s?/gi, ' ') // control words
         .replace(/[^0-9a-fA-F]/g, '');
     if (hex.length % 2)
         hex = hex.slice(0, -1);
@@ -1419,6 +1424,70 @@ function extractRtfImages(rtf) {
         return data;
     });
 }
+/** CSS length -> px, so a VML shape's size survives as the <img> width/height the
+ *  paste engine allows. Unknown units are left for the caller to skip. */
+function cssPx(value) {
+    const m = value.match(/^\s*(-?[\d.]+)\s*(pt|px|in|cm|mm)?\s*$/i);
+    if (!m)
+        return null;
+    const n = parseFloat(m[1]);
+    if (!isFinite(n) || n <= 0)
+        return null;
+    const unit = (m[2] || 'px').toLowerCase();
+    const px = unit === 'pt' ? (n * 4) / 3 : unit === 'in' ? n * 96 : unit === 'cm' ? (n * 96) / 2.54 : unit === 'mm' ? (n * 96) / 25.4 : n;
+    return Math.round(px);
+}
+function attrOf(tag, name) {
+    const m = tag.match(new RegExp('\\s' + name + '\\s*=\\s*(?:"([^"]*)"|\'([^\']*)\'|([^\\s>]+))', 'i'));
+    return m ? m[1] ?? m[2] ?? m[3] ?? '' : '';
+}
+/** Word describes a picture twice: as a VML shape inside a downlevel-hidden
+ *  conditional comment, and as a plain <img> fallback after it. With RelyOnVML on —
+ *  which is what a cropped picture gets — it writes only the shape, and the paste
+ *  engine drops conditional comments, so the picture has no tag left to land on and
+ *  disappears. Give those shapes the <img> Word withheld, keeping the shape's size.
+ *  Pictures that do have the fallback are recognised by their src and left alone.
+ *
+ *  The shape's crop attributes are not applied: the picture appears uncropped. */
+function unwrapVmlImages(html) {
+    if (!/<v:imagedata\b/i.test(html))
+        return html;
+    /** The <img> Word withheld, or null when it did supply one (recognised by its src)
+     *  and the shape is therefore only the duplicate description of the same picture.
+     *  `sizing` is whatever markup the shape's style attribute can be read from. */
+    const imgFor = (imagedata, sizing) => {
+        const src = attrOf(imagedata, 'src');
+        if (!src)
+            return null;
+        const quoted = src.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        if (new RegExp('<img\\b[^>]*\\bsrc\\s*=\\s*["\']?' + quoted, 'i').test(html))
+            return null;
+        const style = (sizing.match(/<v:shape\b[^>]*\sstyle\s*=\s*(?:"([^"]*)"|'([^']*)')/i) || []).slice(1).find(Boolean) || '';
+        const w = cssPx((style.match(/(?:^|;)\s*width\s*:\s*([^;]+)/i) || [])[1] || '');
+        const h = cssPx((style.match(/(?:^|;)\s*height\s*:\s*([^;]+)/i) || [])[1] || '');
+        return ('<img src="' +
+            src.replace(/"/g, '&quot;') +
+            '"' +
+            (w ? ' width="' + w + '"' : '') +
+            (h ? ' height="' + h + '"' : '') +
+            '>');
+    };
+    /* Downlevel-hidden shape: an <img> put inside would stay inside a comment and never
+       reach the DOM, so the whole block has to go. */
+    let out = html.replace(/<!--\[if [^\]]*\]>([\s\S]*?)<!\[endif\]-->/gi, (block, inner) => {
+        const data = inner.match(/<v:imagedata\b[^>]*>/i);
+        return (data && imgFor(data[0], inner)) || block;
+    });
+    /* Live shape: with RelyOnVML on, Word writes the shape into the document itself
+       (bare, or inside a downlevel-revealed <![if gte vml 1]> that the parser drops),
+       counting on the v\:*{behavior:url(#default#VML)} rule it ships in <head>. */
+    out = out.replace(/<v:shape\b[^>]*>[\s\S]*?<\/v:shape\s*>/gi, (shape) => {
+        const data = shape.match(/<v:imagedata\b[^>]*>/i);
+        return (data && imgFor(data[0], shape)) || shape;
+    });
+    /* An imagedata with no shape left to take its size from. */
+    return out.replace(/<v:imagedata\b[^>]*>/gi, (data) => imgFor(data, '') || data);
+}
 /** Rewrites unusable <img src> values in raw pasted HTML with the pictures given, in
  *  document order. Images that already have a usable src are left alone and do not
  *  consume a slot, so a mixed paste (webmail image + Word image) stays aligned.
@@ -1428,7 +1497,7 @@ function injectImages(html, imgs) {
         return { html, injected: [] };
     const injected = [];
     let next = 0;
-    const out = html.replace(/<img\b[^>]*>/gi, (tag) => {
+    const out = unwrapVmlImages(html).replace(/<img\b[^>]*>/gi, (tag) => {
         const src = (tag.match(/\ssrc\s*=\s*["']?([^"'\s>]+)/i) || [])[1] || '';
         if (USABLE_SRC.test(src))
             return tag;
@@ -1980,6 +2049,152 @@ function firstStrongDir(text) {
     }
     return null;
 }
+/* ---------------------------------------------------------- email-export table
+   borders — used only by getContentForEmail(). Word describes a cell's borders
+   as three parallel longhands (`border-color` / `border-style` / `border-width`),
+   one value per side, and a browser re-copy of Word content keeps that split.
+   Mail pipelines allowlist CSS one property at a time, and any of them that
+   keeps `border-color` and `border-width` while dropping `border-style` erases
+   the border outright — the initial `border-style` is `none`, so a width and a
+   colour on their own draw nothing. Re-emitting every side as a single
+   `border-<side>: <width> <style> <colour>` (collapsed to one `border:` when all
+   four agree) makes a side survive or vanish as a unit instead. A side left with
+   a width or a colour but no style is read back as `solid`, which also repairs
+   content that was already flattened that way before it came back into the
+   editor, and `windowtext` — a deprecated system colour Word still emits —
+   becomes plain black. */
+const BORDER_SIDES = ['top', 'right', 'bottom', 'left'];
+const BORDER_STYLE_KEYWORD = /^(none|hidden|dotted|dashed|solid|double|groove|ridge|inset|outset)$/i;
+const BORDER_WIDTH_VALUE = /^(thin|medium|thick|[+-]?(\d+\.?\d*|\.\d+)(px|pt|em|rem|ex|ch|cm|mm|in|pc|q)?)$/i;
+const BORDER_ZERO_WIDTH = /^[+-]?0*(\.0*)?(px|pt|em|rem|ex|ch|cm|mm|in|pc|q)?$/i;
+/* border-* properties that describe something other than one of the four sides,
+   plus the CSS-wide keywords a shorthand cannot express. */
+const BORDER_NOT_A_SIDE = /^border-(collapse|spacing|radius|image|block|inline|start|end)/i;
+const BORDER_SIDE_PROP = /^border(?:-(top|right|bottom|left))?(?:-(width|style|color))?$/;
+const CSS_WIDE_KEYWORD = /^(inherit|initial|unset|revert|revert-layer)$/i;
+/* Split on top-level whitespace, so `rgb(0, 0, 0) solid` stays two values. */
+function splitCssValues(value) {
+    const out = [];
+    let depth = 0;
+    let cur = '';
+    for (const ch of value) {
+        if (ch === '(')
+            depth++;
+        else if (ch === ')')
+            depth--;
+        if (depth === 0 && /\s/.test(ch)) {
+            if (cur)
+                out.push(cur);
+            cur = '';
+        }
+        else
+            cur += ch;
+    }
+    if (cur)
+        out.push(cur);
+    return out;
+}
+/* 1–4 values in CSS box order → an explicit [top, right, bottom, left]. */
+function boxSides(parts) {
+    const [t, r = t, b = t, l = r] = parts;
+    return [t, r, b, l];
+}
+/* `1pt solid windowtext` in any order; whatever the author left out falls back
+   to its initial value, exactly as the real shorthand resets it. */
+function parseBorderShorthand(value) {
+    const side = { width: 'medium', style: 'none', color: '' };
+    splitCssValues(value).forEach((part) => {
+        if (BORDER_STYLE_KEYWORD.test(part))
+            side.style = part.toLowerCase();
+        else if (BORDER_WIDTH_VALUE.test(part))
+            side.width = part;
+        else
+            side.color = part;
+    });
+    return side;
+}
+function emailBorderColor(color) {
+    if (!color || /^currentcolor$/i.test(color))
+        return '';
+    return /^windowtext$/i.test(color) ? '#000000' : color;
+}
+/* One side's declaration value, or '' when that side was never mentioned. */
+function sideBorderValue(side) {
+    if (side.width === null && side.style === null && side.color === null)
+        return '';
+    const style = side.style ?? 'solid';
+    if (style === 'none' || style === 'hidden')
+        return 'none';
+    if (side.width && BORDER_ZERO_WIDTH.test(side.width))
+        return 'none';
+    const width = side.width && side.width !== 'medium' ? side.width : '';
+    return [width, style, emailBorderColor(side.color || '')].filter(Boolean).join(' ');
+}
+function hardenTableBorders(root) {
+    root.querySelectorAll('table,td,th').forEach((el) => {
+        const raw = el.getAttribute('style') || '';
+        if (!/border/i.test(raw))
+            return;
+        const sides = {
+            top: { width: null, style: null, color: null },
+            right: { width: null, style: null, color: null },
+            bottom: { width: null, style: null, color: null },
+            left: { width: null, style: null, color: null }
+        };
+        const rest = [];
+        let sawBorder = false;
+        let bail = false;
+        raw.split(';').forEach((decl) => {
+            const i = decl.indexOf(':');
+            if (i < 1) {
+                if (decl.trim())
+                    rest.push(decl.trim());
+                return;
+            }
+            const prop = decl.slice(0, i).trim().toLowerCase();
+            const value = decl.slice(i + 1).trim();
+            const m = BORDER_SIDE_PROP.exec(prop);
+            if (!m || BORDER_NOT_A_SIDE.test(prop)) {
+                rest.push(prop + ':' + value);
+                return;
+            }
+            /* `border-color:inherit` and friends only mean anything against a
+               parent this export has no say over — leave the cell untouched. */
+            if (CSS_WIDE_KEYWORD.test(value)) {
+                bail = true;
+                return;
+            }
+            sawBorder = true;
+            const one = m[1];
+            const part = m[2];
+            if (!part) {
+                /* `border` / `border-<side>` resets all three components. */
+                const parsed = parseBorderShorthand(value);
+                (one ? [one] : BORDER_SIDES.slice()).forEach((s) => {
+                    sides[s] = { ...parsed };
+                });
+            }
+            else if (one) {
+                sides[one][part] = value;
+            }
+            else {
+                const per = boxSides(splitCssValues(value));
+                BORDER_SIDES.forEach((s, n) => {
+                    sides[s][part] = per[n];
+                });
+            }
+        });
+        if (bail || !sawBorder)
+            return;
+        const values = BORDER_SIDES.map((s) => sideBorderValue(sides[s]));
+        const out = rest.slice();
+        if (values.every((v) => v && v === values[0]))
+            out.push('border:' + values[0]);
+        else
+            BORDER_SIDES.forEach((s, n) => values[n] && out.push(`border-${s}:` + values[n]));
+        el.setAttribute('style', out.join(';'));
+    });
+}
 /* Text belonging to el itself, skipping subtrees rooted at a descendant that
    already carries its own explicit rtl/ltr dir — that subtree's direction is
    already independently decided and shouldn't sway el's own detection. */
@@ -2559,6 +2774,19 @@ class FableEditor {
             if (!/(^|;)\s*height\s*:/i.test(img.getAttribute('style') || ''))
                 setStyle(img, 'height:auto');
         });
+        /* Borders last, so the per-side shorthands it writes are the final word on
+           every cell. Also pin border-collapse inline and mirror it onto the legacy
+           cellspacing attribute: a mail pipeline that drops border-collapse leaves
+           the table in `separate` mode, where any cellspacing of its own would open
+           gaps between Word's deliberately shared cell edges. */
+        hardenTableBorders(box);
+        box.querySelectorAll('table').forEach((tbl) => {
+            const style = tbl.getAttribute('style') || '';
+            if (!/border-collapse\s*:/i.test(style))
+                setStyle(tbl, 'border-collapse:collapse');
+            if (!/border-spacing\s*:/i.test(style) && !tbl.hasAttribute('cellspacing'))
+                tbl.setAttribute('cellspacing', '0');
+        });
         const dir = found || this.ed.getAttribute('dir') || this.dir();
         box.querySelectorAll('table:not([dir])').forEach((tbl) => {
             tbl.setAttribute('dir', dir);