fable-editor 1.2.7 → 1.3.0

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

@@ -0,0 +1,189 @@
+/* Recovers the pictures that desktop Word leaves out of the HTML clipboard flavor.
+   Word writes <img src="file:///…/msohtmlclip1/01/clip_image001.png"> — a local temp
+   file the browser cannot read — but the same paste also carries a text/rtf flavor
+   with every picture embedded as hex inside a {\pict} group. Pairing the two is how
+   TinyMCE PowerPaste implements powerpaste_allow_local_images.
+
+   This runs on the RAW html string BEFORE cleanPastedHTML() sees it: the paste engine
+   already allows data: URIs, so it needs no change and its behaviour is unaffected.
+   Anything this module cannot recover is left exactly as it was, and still ends up on
+   the engine's existing "[local image — paste it separately]" placeholder. */
+/** Total decoded bytes we are willing to inline from one paste. A Word document full
+ *  of full-page screenshots can run to tens of MB; past this we leave the placeholders
+ *  rather than freeze the editor building base64 strings. */
+const MAX_TOTAL_BYTES = 10 * 1024 * 1024;
+const USABLE_SRC = /^(https?:|data:image\/|blob:)/i;
+/** Scans for `{\keyword …}` groups, tracking brace depth so nested groups such as
+ *  `{\*\picprop …}` inside a picture do not terminate the match early (a lazy
+ *  `/\{\\pict[\s\S]*?\}/` regex gets this wrong and truncates the hex payload). */
+function findGroups(rtf, keyword) {
+    const out = [];
+    const needle = '{\\' + keyword;
+    let i = 0;
+    while ((i = rtf.indexOf(needle, i)) !== -1) {
+        /* the char after the control word must be a delimiter, so \pict does not also
+           match \pictscalex and friends */
+        const after = rtf[i + needle.length];
+        if (after && /[a-z0-9]/i.test(after)) {
+            i += needle.length;
+            continue;
+        }
+        let depth = 0;
+        let j = i;
+        for (; j < rtf.length; j++) {
+            const c = rtf[j];
+            if (c === '\\') {
+                j++;
+                continue;
+            }
+            if (c === '{')
+                depth++;
+            else if (c === '}') {
+                depth--;
+                if (!depth)
+                    break;
+            }
+        }
+        out.push({ start: i, end: j + 1, body: rtf.slice(i + needle.length, j) });
+        i = j + 1;
+    }
+    return out;
+}
+function hexToBytes(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++)
+        bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
+    return bytes;
+}
+function toBase64(bytes) {
+    let bin = '';
+    for (let i = 0; i < bytes.length; i++)
+        bin += String.fromCharCode(bytes[i]);
+    return btoa(bin);
+}
+function indexOfSig(bytes, sig) {
+    outer: for (let i = 0; i + sig.length <= bytes.length; i++) {
+        for (let j = 0; j < sig.length; j++)
+            if (bytes[i + j] !== sig[j])
+                continue outer;
+        return i;
+    }
+    return -1;
+}
+const PNG_SIG = [0x89, 0x50, 0x4e, 0x47];
+const JPG_SIG = [0xff, 0xd8, 0xff];
+function decodePict(body) {
+    let kind = null;
+    if (/\\pngblip/.test(body))
+        kind = 'image/png';
+    else if (/\\jpegblip/.test(body))
+        kind = 'image/jpeg';
+    else if (/\\wmetafile\d*/.test(body) || /\\emfblip/.test(body))
+        kind = 'metafile';
+    if (!kind)
+        return null;
+    let hex = body
+        .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);
+    if (!hex)
+        return null;
+    const bytes = hexToBytes(hex);
+    if (kind === 'metafile') {
+        /* Word wraps a bitmap in a metafile for compatibility; when there is a real
+           PNG/JPEG inside we can use it. A genuine vector metafile we cannot render. */
+        const png = indexOfSig(bytes, PNG_SIG);
+        if (png >= 0)
+            return 'data:image/png;base64,' + toBase64(bytes.slice(png));
+        const jpg = indexOfSig(bytes, JPG_SIG);
+        if (jpg >= 0)
+            return 'data:image/jpeg;base64,' + toBase64(bytes.slice(jpg));
+        return null;
+    }
+    return 'data:' + kind + ';base64,' + toBase64(bytes);
+}
+/** Every picture in the RTF flavor, in document order. */
+export function extractRtfImages(rtf) {
+    if (!rtf || rtf.indexOf('\\pict') === -1)
+        return [];
+    /* Word emits {\*\shppict{\pict …}}{\nonshppict{\pict …}} — the second group is a
+       legacy duplicate of the first. Dropping it keeps picture order aligned with the
+       <img> tags in the HTML flavor. */
+    let cleaned = rtf;
+    findGroups(rtf, 'nonshppict')
+        .reverse()
+        .forEach((g) => {
+        cleaned = cleaned.slice(0, g.start) + cleaned.slice(g.end);
+    });
+    let budget = MAX_TOTAL_BYTES;
+    return findGroups(cleaned, 'pict').map((g) => {
+        if (budget <= 0)
+            return null;
+        const data = decodePict(g.body);
+        if (data)
+            budget -= data.length * 0.75; // base64 -> approximate byte count
+        return 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.
+ *  Anything without a matching picture keeps its original tag. */
+export function injectImages(html, imgs) {
+    if (!html || !imgs.length)
+        return { html, injected: [] };
+    const injected = [];
+    let next = 0;
+    const out = html.replace(/<img\b[^>]*>/gi, (tag) => {
+        const src = (tag.match(/\ssrc\s*=\s*["']?([^"'\s>]+)/i) || [])[1] || '';
+        if (USABLE_SRC.test(src))
+            return tag;
+        const data = imgs[next++];
+        if (!data)
+            return tag;
+        injected.push(data);
+        return /\ssrc\s*=\s*["']/i.test(tag)
+            ? tag.replace(/(\ssrc\s*=\s*)(["'])[^"']*\2/i, '$1"' + data + '"')
+            : tag.replace(/(\ssrc\s*=\s*)[^\s>]+/i, '$1"' + data + '"');
+    });
+    return { html: out, injected };
+}
+/** Pairs the HTML flavor of a Word paste with the pictures in its RTF flavor. */
+export function injectRtfImages(html, rtf) {
+    if (!html || !rtf)
+        return { html, injected: [] };
+    return injectImages(html, extractRtfImages(rtf));
+}
+/** True when the cleaned HTML still holds images the engine could not resolve — used
+ *  to decide whether a bitmap sitting in the clipboard is worth falling back to. */
+export function countUnresolvedImages(html) {
+    const tags = html.match(/<img\b[^>]*>/gi);
+    if (!tags)
+        return 0;
+    return tags.filter((tag) => {
+        const src = (tag.match(/\ssrc\s*=\s*["']?([^"'\s>]+)/i) || [])[1] || '';
+        return !USABLE_SRC.test(src);
+    }).length;
+}
+/** data: URI -> File, so recovered pictures can go through the host's
+ *  imageUploadHandler exactly like a picked file does. `baseName` gets the extension
+ *  that matches the URI's MIME type. */
+export function dataUrlToFile(dataUrl, baseName) {
+    const m = dataUrl.match(/^data:([^;,]+);base64,(.*)$/);
+    if (!m)
+        return null;
+    const ext = (m[1].split('/')[1] || 'png').replace(/[^a-z0-9]/gi, '') || 'png';
+    try {
+        const bin = atob(m[2]);
+        const bytes = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; i++)
+            bytes[i] = bin.charCodeAt(i);
+        return new File([bytes], baseName + '.' + (ext === 'jpeg' ? 'jpg' : ext), { type: m[1] });
+    }
+    catch (e) {
+        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"]}