fable-editor 1.3.1 → 1.4.0

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":"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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  /* 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;
@@ -2656,6 +2725,17 @@ class FableEditor {
             const cur = (el.getAttribute('style') || '').trim();
             el.setAttribute('style', cur ? cur.replace(/;?$/, '; ') + decl : decl);
         };
+        /* Replaces the `width:` an element already carries instead of appending a
+           second one and leaving it to the mail client which of the two wins.
+           `max-width` / `min-width` are left alone. */
+        const setWidthPx = (el, w) => {
+            const kept = (el.getAttribute('style') || '')
+                .split(';')
+                .map((d) => d.trim())
+                .filter((d) => d && !/^width\s*:/i.test(d));
+            kept.push(`width:${w}px`);
+            el.setAttribute('style', kept.join('; '));
+        };
         const box = document.createElement('div');
         box.innerHTML = this.ed.innerHTML;
         let found = null;
@@ -2688,18 +2768,26 @@ class FableEditor {
            built from the same HTML) and make it explicit. The width attribute is what
            Outlook desktop follows; max-width keeps it inside narrow mobile clients.
            Documents saved before this existed are fixed here too, without rewriting
-           anything the host has stored. */
+           anything the host has stored.
+           The measured width overrides what the markup carries rather than only
+           filling a gap: an image that `max-width:100%` is clamping, and one whose
+           stored size predates a resize, are on screen at the measured width and have
+           to leave at it too — that is what makes the mail match the preview.
+           offsetWidth is the laid-out width, so a rotate/flip transform on the image
+           cannot distort it, and a stale height attribute goes out with the old width:
+           the aspect ratio then comes from the picture itself, exactly as the editor's
+           `height:auto` gives it. */
         const liveImgs = this.ed.querySelectorAll('img');
         box.querySelectorAll('img').forEach((img, i) => {
             if (img.closest('.tpl-media'))
                 return;
             const live = liveImgs[i];
-            const w = Math.round(live?.getBoundingClientRect().width || 0);
-            if (w > 0 && !img.getAttribute('width'))
+            const w = Math.round(live?.offsetWidth || 0);
+            if (w > 0) {
                 img.setAttribute('width', String(w));
-            const style = img.getAttribute('style') || '';
-            if (w > 0 && !/(^|;)\s*width\s*:/i.test(style))
-                setStyle(img, `width:${w}px`);
+                img.removeAttribute('height');
+                setWidthPx(img, w);
+            }
             if (!/max-width\s*:/i.test(img.getAttribute('style') || ''))
                 setStyle(img, 'max-width:100%');
             if (!/(^|;)\s*height\s*:/i.test(img.getAttribute('style') || ''))
@@ -4538,14 +4626,18 @@ class FableEditor {
                image is exactly the size the user left it at — a narrower preview pane
                would silently shrink it and misreport what will be sent. The dialog gets
                a wider cap to make that width reachable; on a viewport too small for it
-               the image's max-width:100% scales things down rather than clipping. */
+               the image's max-width:100% scales things down rather than clipping.
+               box-sizing is pinned because a host page with the usual global
+               border-box rule would otherwise take the 14px padding out of that width
+               and preview every full-width image 28px narrower than it will be sent. */
             body.closest('.dlg')?.classList.add('dlg-preview');
             const box = document.createElement('div');
             box.className = 'pv-box';
             const w = this.contentWidth();
             box.style.cssText =
                 `width:${w > 0 ? Math.round(w) : 640}px;max-width:100%;max-height:52vh;overflow:auto;` +
-                    'border:1px solid #e3e3e3;border-radius:6px;padding:14px;font-family:Helvetica,Arial,sans-serif;font-size:14px';
+                    'box-sizing:content-box;border:1px solid #e3e3e3;border-radius:6px;padding:14px;' +
+                    'font-family:Helvetica,Arial,sans-serif;font-size:14px';
             box.innerHTML = this.ed.innerHTML;
             body.appendChild(box);
         });
@@ -6173,11 +6265,19 @@ class FableEditor {
             return;
         this.cancelImgHide();
         const startX = e.clientX;
-        const startW = img.getBoundingClientRect().width;
+        const startW = img.offsetWidth || img.getBoundingClientRect().width;
         const sign = corner === 'nw' || corner === 'sw' ? -1 : 1;
+        /* `.earea img { max-width:100% }` clamps an image to the text column, so a drag
+           past that edge would store a width the editor never renders — and a mail, which
+           carries no such rule, would then go out at that unseen width. Cap the drag at
+           the column so the stored size is always the size on screen. */
+        const max = Math.round(this.contentWidth());
         this.withNoTextSelect((restore) => {
             const mv = (ev) => {
-                img.style.width = Math.max(24, Math.round(startW + sign * (ev.clientX - startX))) + 'px';
+                let w = Math.max(24, Math.round(startW + sign * (ev.clientX - startX)));
+                if (max > 0)
+                    w = Math.min(w, max);
+                img.style.width = w + 'px';
                 img.style.height = 'auto';
                 this.positionImageHandles();
             };
@@ -6187,9 +6287,12 @@ class FableEditor {
                 restore();
                 /* mirror the final size onto the width attribute: Outlook desktop
                    follows the attribute rather than the CSS, so without this a resized
-                   image still goes out at its original size */
-                const w = parseInt(img.style.width, 10);
+                   image still goes out at its original size. Read it back from the laid
+                   out box — offsetWidth ignores any rotate/flip transform — so the
+                   attribute, the inline width and what the user sees cannot disagree. */
+                const w = Math.round(img.offsetWidth) || parseInt(img.style.width, 10);
                 if (w > 0 && !img.closest('.tpl-media')) {
+                    img.style.width = w + 'px';
                     img.setAttribute('width', String(w));
                     img.removeAttribute('height');
                 }