opentiny 6.9.0

package/src/core/test/ts/browser/dom/StyleSheetLoaderRegistryTest.ts

@@ -0,0 +1,40 @@
+import { describe, it } from '@ephox/bedrock-client';
+import { SugarDocument, SugarElement, SugarShadowDom } from '@ephox/sugar';
+import { assert } from 'chai';
+
+import StyleSheetLoader from 'tinymce/core/api/dom/StyleSheetLoader';
+import * as StyleSheetLoaderRegistry from 'tinymce/core/dom/StyleSheetLoaderRegistry';
+
+describe('browser.tinymce.core.dom.StyleSheetLoaderRegistry', () => {
+  it('same element gets same instance (document)', () => {
+    const sslr = StyleSheetLoaderRegistry.create();
+    const ssl1: StyleSheetLoader = sslr.forElement(SugarDocument.getDocument(), {});
+    const ssl2: StyleSheetLoader = sslr.forElement(SugarDocument.getDocument(), {});
+    assert.strictEqual(ssl2, ssl1, 'Should be the same');
+  });
+
+  it('same element gets same instance (ShadowRoot)', function () {
+    if (!SugarShadowDom.isSupported()) {
+      this.skip();
+    }
+
+    const div = document.createElement('div');
+    const sr = div.attachShadow({ mode: 'open' });
+    const innerDiv = document.createElement('div');
+    sr.appendChild(innerDiv);
+
+    const sslr = StyleSheetLoaderRegistry.create();
+
+    const ssl1: StyleSheetLoader = sslr.forElement(SugarElement.fromDom(sr), {});
+    const ssl2: StyleSheetLoader = sslr.forElement(SugarElement.fromDom(sr), {});
+    const ssl3: StyleSheetLoader = sslr.forElement(SugarElement.fromDom(innerDiv), {});
+    const ssl4: StyleSheetLoader = sslr.forElement(SugarElement.fromDom(innerDiv), {});
+    assert.strictEqual(ssl2, ssl1, 'Should be the same: shadow root x 2');
+    assert.strictEqual(ssl3, ssl2, 'Should be the same: shadow root and child');
+    assert.strictEqual(ssl4, ssl3, 'Should be the same: child x 2');
+
+    const sslDoc: StyleSheetLoader = sslr.forElement(SugarDocument.getDocument(), {});
+
+    assert.notStrictEqual(sslDoc, ssl4, 'Loader for document should be different to loader for shadow root child');
+  });
+});

package/src/core/test/ts/browser/dom/StyleSheetLoaderTest.ts

@@ -0,0 +1,70 @@
+import { UiFinder } from '@ephox/agar';
+import { before, describe, it } from '@ephox/bedrock-client';
+import { Attribute, SelectorFilter, SugarElement, SugarHead } from '@ephox/sugar';
+import { assert } from 'chai';
+
+import StyleSheetLoader from 'tinymce/core/api/dom/StyleSheetLoader';
+
+describe('browser.tinymce.core.dom.StyleSheetLoaderTest', () => {
+  const contentCss = '/project/tinymce/js/tinymce/skins/content/default/content.css';
+  const skinCss = '/project/tinymce/js/tinymce/skins/ui/oxide/skin.css';
+  let loader: StyleSheetLoader;
+
+  const baseLinkExists = (url: string, head: SugarElement<HTMLHeadElement>) => {
+    const links = SelectorFilter.descendants(head, `link[href="${url}"]`);
+    assert.lengthOf(links, 1, 'Should have one link loaded');
+    assert.equal(Attribute.get(links[0], 'referrerPolicy'), 'origin', 'Should have referrer policy attribute');
+    assert.equal(Attribute.get(links[0], 'crossorigin'), 'anonymous', 'Should have crossorigin attribute');
+  };
+
+  const linkExists = (url: string) => baseLinkExists(url, SugarHead.head());
+
+  const linkNotExists = (url: string) => UiFinder.notExists(SugarHead.head(), `link[href="${url}"]`);
+
+  const pLoadUrl = (url: string): Promise<void> =>
+    loader.load(url);
+
+  const pLoadAllUrls = (urls: string[]): Promise<string[]> =>
+    loader.loadAll(urls);
+
+  const unloadUrl = (url: string) => loader.unload(url);
+
+  const unloadAllUrls = (urls: string[]) => loader.unloadAll(urls);
+
+  before(() => {
+    loader = StyleSheetLoader(document, {
+      maxLoadTime: 500,
+      contentCssCors: true,
+      referrerPolicy: 'origin'
+    });
+  });
+
+  it('TINY-3926: Load and then unload removes the loaded stylesheet', async () => {
+    await pLoadUrl(contentCss);
+    linkExists(contentCss);
+    unloadUrl(contentCss);
+    linkNotExists(contentCss);
+  });
+
+  it('TINY-3926: Load and then unload all urls should leave no stylesheets', async () => {
+    await pLoadAllUrls([ contentCss, skinCss ]);
+    linkExists(contentCss);
+    linkExists(skinCss);
+    unloadAllUrls([ skinCss, contentCss ]);
+    linkNotExists(contentCss);
+    linkNotExists(skinCss);
+  });
+
+  it('TINY-3926: Unload removes loaded stylesheets, but only on last reference', async () => {
+    // Load 2 links and ensure only one link is loaded
+    await pLoadUrl(contentCss);
+    await pLoadUrl(contentCss);
+    linkExists(contentCss);
+    // Unload once shouldn't remove the link
+    unloadUrl(contentCss);
+    linkExists(contentCss);
+    // Unload a second time should remove since the stylesheet was loaded twice
+    unloadUrl(contentCss);
+    linkNotExists(contentCss);
+  });
+});

package/src/core/test/ts/browser/dom/TreeWalkerTest.ts

@@ -0,0 +1,97 @@
+import { before, describe, it } from '@ephox/bedrock-client';
+import { assert } from 'chai';
+
+import DomTreeWalker from 'tinymce/core/api/dom/TreeWalker';
+
+import * as ViewBlock from '../../module/test/ViewBlock';
+
+describe('browser.tinymce.core.dom.TreeWalkerTest', () => {
+  const viewBlock = ViewBlock.bddSetup();
+  let nodes: Node[];
+
+  before(() => {
+    const all = (node: Node) => {
+      let list = [ node ];
+
+      if (node.hasChildNodes()) {
+        for (let i = 0; i < node.childNodes.length; i++) {
+          list = list.concat(all(node.childNodes[i]));
+        }
+      }
+
+      return list;
+    };
+
+    viewBlock.update(
+      '1' +
+      '<ul>' +
+        '<li>' +
+          '2' +
+          '<ul>' +
+            '<li>3</li>' +
+            '<li>4</li>' +
+          '</ul>' +
+          '</li>' +
+          '<li>' +
+          '5' +
+          '<ul>' +
+            '<li>6</li>' +
+            '<li>7</li>' +
+          '</ul>' +
+        '</li>' +
+      '</ul>' +
+      '8'
+    );
+
+    nodes = all(viewBlock.get()).slice(1);
+  });
+
+  const compareNodeLists = (expectedNodes: ArrayLike<Node>, actualNodes: ArrayLike<Node>) => {
+    if (expectedNodes.length !== actualNodes.length) {
+      return false;
+    }
+
+    for (let i = 0; i < expectedNodes.length; i++) {
+      if (expectedNodes[i] !== actualNodes[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  };
+
+  it('next', () => {
+    const walker = new DomTreeWalker(nodes[0], viewBlock.get());
+
+    const actualNodes: Node[] = [ walker.current() as Node ];
+    while ((walker.next())) {
+      actualNodes.push(walker.current() as Node);
+    }
+
+    assert.isTrue(compareNodeLists(nodes, actualNodes), 'Should be the same');
+  });
+
+  it('prev2', () => {
+    const walker = new DomTreeWalker(nodes[nodes.length - 1], viewBlock.get());
+
+    let actualNodes: Node[] = [ walker.current() as Node ];
+    while ((walker.prev2())) {
+      actualNodes.push(walker.current() as Node);
+    }
+
+    actualNodes = actualNodes.reverse();
+    assert.isTrue(compareNodeLists(nodes, actualNodes), 'Should be the same');
+  });
+
+  it('prev2(shallow:true)', () => {
+    const walker = new DomTreeWalker(nodes[nodes.length - 1], viewBlock.get());
+
+    let actualNodes: Node[] = [ walker.current() as Node ];
+    while ((walker.prev2(true))) {
+      actualNodes.push(walker.current() as Node);
+    }
+
+    actualNodes = actualNodes.reverse();
+    assert.isTrue(compareNodeLists(viewBlock.get().childNodes, actualNodes), 'Should be the same');
+  });
+});

package/src/core/test/ts/browser/dom/TrimBodyTest.ts

@@ -0,0 +1,188 @@
+import { context, describe, it } from '@ephox/bedrock-client';
+import { Arr } from '@ephox/katamari';
+import { PlatformDetection } from '@ephox/sand';
+import { assert } from 'chai';
+
+import * as TrimBody from 'tinymce/core/dom/TrimBody';
+
+describe('browser.tinymce.core.dom.TrimBodyTest', () => {
+  const isSafari = PlatformDetection.detect().browser.isSafari();
+
+  context('trim', () => {
+    it('trim should trim body containing trimmmable nodes', () => {
+      const tempAttrs = [ 'data-mce-selected' ];
+      const body = document.createElement('div');
+      const initialHtml = '<p>Test</p><span data-mce-bogus="all">bogus</span><span data-mce-bogus="1">bogus1</span><p>Test</p><!-- \ufeffcomment --><noscript>\ufeffnoscript</noscript><span data-mce-selected="true">tempAttr</span><p>Test</p>';
+      body.innerHTML = initialHtml;
+      const trimmedBody = TrimBody.trim(body, tempAttrs);
+      assert.strictEqual(trimmedBody.innerHTML, '<p>Test</p><span data-mce-bogus="1">bogus1</span><p>Test</p><!----><noscript></noscript><span>tempAttr</span><p>Test</p>', 'Should trim trimmable nodes');
+      assert.strictEqual(body.innerHTML, initialHtml, 'Should not modify original body');
+      assert.notStrictEqual(trimmedBody, body, 'Should trim and return a new body when body is trimmable');
+    });
+
+    it('trim should not trim body without trimmable nodes', () => {
+      const tempAttrs = [ 'data-mce-selected' ];
+      const body = document.createElement('div');
+      const initialHtml = '<p>Test</p><span data-mce-bogus="1">bogus1</span><p>Test</p><!-- comment --><noscript>noscript</noscript><span>span</span><p>Test</p>';
+      body.innerHTML = initialHtml;
+      const trimmedBody = TrimBody.trim(body, tempAttrs);
+      assert.strictEqual(trimmedBody.innerHTML, initialHtml, 'Should not trim body without temporary nodes');
+      assert.strictEqual(trimmedBody, body, 'Should return the original body when body is not trimmable');
+    });
+  });
+
+  context('Zwsp comments', () => {
+    it('hasZwspComment', () => {
+      const commentDivWithZwsp = document.createElement('div');
+      commentDivWithZwsp.innerHTML = `<p>Test</p><!-- \ufeffcomment --><p>Test</p>`;
+      assert.isTrue(TrimBody.hasZwspComment(commentDivWithZwsp));
+
+      const commentDiv = document.createElement('div');
+      commentDiv.innerHTML = '<p>Test</p><!-- comment --><p>Test</p>';
+      assert.isFalse(TrimBody.hasZwspComment(commentDiv));
+
+      const commentlessDiv = document.createElement('div');
+      commentlessDiv.innerHTML = '<p>Test</p><p>Test</p>';
+      assert.isFalse(TrimBody.hasZwspComment(commentlessDiv));
+    });
+
+    it('emptyZwspComments', () => {
+      const commentDivWithZwsp = document.createElement('div');
+      commentDivWithZwsp.innerHTML = '<!-- \ufeffcommentent --><p>Test</p><!-- comm\ufeffent --><!-- \ufeff --><!-- commentwithoutufeff --><p>Test</p>';
+      TrimBody.emptyZwspComments(commentDivWithZwsp);
+      assert.strictEqual(commentDivWithZwsp.innerHTML, '<!----><p>Test</p><!----><!----><!-- commentwithoutufeff --><p>Test</p>');
+
+      const commentDiv = document.createElement('div');
+      commentDiv.innerHTML = '<p>Test</p><!-- comment --><p>Test</p>';
+      TrimBody.emptyZwspComments(commentDiv);
+      assert.strictEqual(commentDiv.innerHTML, '<p>Test</p><!-- comment --><p>Test</p>');
+
+      const commentlessDiv = document.createElement('div');
+      commentlessDiv.innerHTML = '<p>Test</p><p>Test</p>';
+      TrimBody.emptyZwspComments(commentlessDiv);
+      assert.strictEqual(commentlessDiv.innerHTML, '<p>Test</p><p>Test</p>');
+    });
+  });
+
+  context('Temporary nodes', () => {
+    it('hasTemporaryNode', () => {
+      const bogusDiv = document.createElement('div');
+      bogusDiv.innerHTML = '<p>Test</p><span data-mce-bogus="all">bogus</span><p>Test</p>';
+      assert.isTrue(TrimBody.hasTemporaryNode([], bogusDiv));
+
+      const tempAttrDiv = document.createElement('div');
+      tempAttrDiv.innerHTML = '<p>Test</p><span data-mce-selected="true">tempAttr</span><p>Test</p>';
+      assert.isTrue(TrimBody.hasTemporaryNode([ 'data-mce-selected' ], tempAttrDiv));
+
+      const templessDiv = document.createElement('div');
+      templessDiv.innerHTML = '<p>Test</p><p>Test</p>';
+      assert.isFalse(TrimBody.hasTemporaryNode([ 'data-mce-selected' ], templessDiv));
+    });
+
+    it('trimTemporaryNodes', () => {
+      const bogusDiv = document.createElement('div');
+      bogusDiv.innerHTML = '<p>Test</p><span data-mce-bogus="all">bogusall</span><p>Test</p><span data-mce-bogus="1">bogus1</span><span data-mce-bogus="all">bogusall2</span>';
+      TrimBody.trimTemporaryNodes([], bogusDiv);
+      assert.strictEqual(bogusDiv.innerHTML, '<p>Test</p><p>Test</p><span data-mce-bogus="1">bogus1</span>');
+
+      const tempAttrDiv = document.createElement('div');
+      tempAttrDiv.innerHTML = '<p>Test</p><span data-mce-selected="true">tempAttr</span><p data-mce-selected="false">Test</p>';
+      TrimBody.trimTemporaryNodes([ 'data-mce-selected' ], tempAttrDiv);
+      assert.strictEqual(tempAttrDiv.innerHTML, '<p>Test</p><span>tempAttr</span><p>Test</p>');
+
+      const templessDiv = document.createElement('div');
+      templessDiv.innerHTML = '<p>Test</p><p>Test</p>';
+      TrimBody.trimTemporaryNodes([ 'data-mce-selected' ], templessDiv);
+      assert.strictEqual(templessDiv.innerHTML, '<p>Test</p><p>Test</p>');
+    });
+  });
+
+  context('Unescaped zwsp text', () => {
+    const unescapedClosingTextParents = [
+      'noscript',
+      'style',
+      'script',
+      'xmp',
+      'iframe',
+      'noembed',
+      'noframes'
+    ];
+
+    it('hasUnescapedZwspText with div parent should always return false', () => {
+      const divZwspText = document.createElement('div');
+      divZwspText.innerHTML = `<p>Test</p><div>\ufeffTest</div><p>Test</p>`;
+      assert.isFalse(TrimBody.hasUnescapedZwspText(divZwspText));
+
+      const divText = document.createElement('div');
+      divText.innerHTML = `<p>Test</p><div>Test</div><p>Test</p>`;
+      assert.isFalse(TrimBody.hasUnescapedZwspText(divText));
+    });
+
+    it('emptyUnescapedZwspTexts with div parent should do nothing', () => {
+      const divZwspText = document.createElement('div');
+      divZwspText.innerHTML = `<p>Test</p><div>\ufeffTest</div><p>Test</p>`;
+      TrimBody.emptyUnescapedZwspTexts(divZwspText);
+      assert.strictEqual(divZwspText.innerHTML, `<p>Test</p><div>\ufeffTest</div><p>Test</p>`);
+
+      const divText = document.createElement('div');
+      divText.innerHTML = `<p>Test</p><div>Test</div><p>Test</p>`;
+      TrimBody.emptyUnescapedZwspTexts(divText);
+      assert.strictEqual(divText.innerHTML, `<p>Test</p><div>Test</div><p>Test</p>`);
+    });
+
+    Arr.each(unescapedClosingTextParents, (parent) => {
+      it(`hasUnescapedZwspText with ${parent} parent`, () => {
+        const unescapedZwspText = document.createElement('div');
+        unescapedZwspText.innerHTML = `<p>Test</p><${parent}>Test\ufeffTest</${parent}><p>Test</p>`;
+        assert.isTrue(TrimBody.hasUnescapedZwspText(unescapedZwspText));
+
+        const unescapedText = document.createElement('div');
+        unescapedText.innerHTML = `<p>Test</p><${parent}>Test</${parent}><p>Test</p>`;
+        assert.isFalse(TrimBody.hasUnescapedZwspText(unescapedText));
+      });
+
+      it(`emptyUnescapedZwspTexts with ${parent} parent`, () => {
+        const unescapedZwspText = document.createElement('div');
+        unescapedZwspText.innerHTML = `<p>Test</p><${parent}>Test\ufeffTest</${parent}><p>Test</p>`;
+        TrimBody.emptyUnescapedZwspTexts(unescapedZwspText);
+        assert.strictEqual(unescapedZwspText.innerHTML, `<p>Test</p><${parent}></${parent}><p>Test</p>`);
+
+        const unescapedText = document.createElement('div');
+        unescapedText.innerHTML = `<p>Test</p><${parent}>Test</${parent}><p>Test</p>`;
+        TrimBody.emptyUnescapedZwspTexts(unescapedText);
+        assert.strictEqual(unescapedText.innerHTML, `<p>Test</p><${parent}>Test</${parent}><p>Test</p>`);
+      });
+    });
+
+    // TINY-10305: <plaintext> is special because it is used without a closing tag and turns everything after it into its own content.
+    // Modern browsers will add a closing </plaintext> at the end of the body.
+    // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/plaintext
+    context('plaintext', () => {
+      const plaintext = 'plaintext';
+
+      it('hasUnescapedZwspText with plaintext parent', () => {
+        const unescapedZwspText = document.createElement('div');
+        unescapedZwspText.innerHTML = `<p>Test</p><${plaintext}>Test\ufeffTest<p>Test</p>`;
+        assert.isTrue(TrimBody.hasUnescapedZwspText(unescapedZwspText));
+
+        const unescapedText = document.createElement('div');
+        unescapedText.innerHTML = `<p>Test</p><${plaintext}>Test<p>Test</p>`;
+        assert.isFalse(TrimBody.hasUnescapedZwspText(unescapedText));
+      });
+
+      it('emptyUnescapedZwspTexts with plaintext parent', () => {
+        const unescapedZwspText = document.createElement('div');
+        unescapedZwspText.innerHTML = `<p>Test</p><${plaintext}>Test\ufeffTest<p>Test</p>`;
+        TrimBody.emptyUnescapedZwspTexts(unescapedZwspText);
+        assert.strictEqual(unescapedZwspText.innerHTML, `<p>Test</p><${plaintext}></${plaintext}>`);
+
+        const unescapedText = document.createElement('div');
+        unescapedText.innerHTML = `<p>Test</p><${plaintext}>Test<p>Test</p>`;
+        TrimBody.emptyUnescapedZwspTexts(unescapedText);
+        // TINY-10305: Safari escapes text nodes within <plaintext>.
+        assert.strictEqual(unescapedText.innerHTML,
+          isSafari ? `<p>Test</p><${plaintext}>Test&lt;p&gt;Test&lt;/p&gt;</${plaintext}>` : `<p>Test</p><${plaintext}>Test<p>Test</p></${plaintext}>`);
+      });
+    });
+  });
+});

package/src/core/test/ts/browser/dom/TrimNodeTest.ts

@@ -0,0 +1,52 @@
+import { describe, it } from '@ephox/bedrock-client';
+import { assert } from 'chai';
+
+import DOMUtils from 'tinymce/core/api/dom/DOMUtils';
+import Schema from 'tinymce/core/api/html/Schema';
+import * as TrimNode from 'tinymce/core/dom/TrimNode';
+
+describe('browser.tinymce.core.dom.TrimNodeTest', () => {
+  const dom = DOMUtils(document, {});
+  const baseSchema = Schema();
+
+  const testTrim = (label: string, inputHtml: string, expectedTrimmedHtml: string) => {
+    it(label, () => {
+      const elm = document.createElement('div');
+      elm.innerHTML = inputHtml;
+      TrimNode.trimNode(dom, elm.firstChild as Node, baseSchema);
+
+      const actual = elm.innerHTML;
+      assert.equal(actual, expectedTrimmedHtml, 'is correct trimmed html');
+    });
+  };
+
+  testTrim('Empty span should be removed', '<p><span></span>x</p>', '<p>x</p>');
+  testTrim('Non-empty span should not be removed', '<p><span>x</span>&nbsp;</p>', '<p><span>x</span>&nbsp;</p>');
+  testTrim('Nbsp between inline elements should not be removed', '<p><span>x</span>&nbsp;<span>x</span></p>', '<p><span>x</span>&nbsp;<span>x</span></p>');
+  testTrim('Bookmarks should not be removed 1', '<p><span data-mce-type="bookmark"></span> y</p>', '<p><span data-mce-type="bookmark"></span> y</p>');
+  testTrim('Bookmarks should not be removed 2', '<p>a <span>b <span data-mce-type="bookmark"></span> c</span></p>', '<p>a <span>b <span data-mce-type="bookmark"></span> c</span></p>');
+  testTrim('Trailing nbsp within inline element should not be removed', '<p><strong><span>x</span>&nbsp;</strong></p>', '<p><strong><span>x</span>&nbsp;</strong></p>');
+  testTrim('Anchor should not be removed', '<p><a id="anchor"></a><span>x</span></p>', '<p><a id="anchor"></a><span>x</span></p>');
+  testTrim('Bogus BR should not be removed', '<p><br data-mce-bogus="1"></p>', '<p><br data-mce-bogus="1"></p>');
+  testTrim('Space between inline elements should not be removed', '<p><strong>x</strong> <em>y</em></p>', '<p><strong>x</strong> <em>y</em></p>');
+  testTrim('New line between inline elements should not be removed', '<pre><strong>x</strong>\n<em>y</em></pre>', '<pre><strong>x</strong>\n<em>y</em></pre>');
+
+  it('Fragmented text node', () => {
+    const emptyTextNode = document.createTextNode(' ');
+    const elm = document.createElement('div');
+    elm.innerHTML = '<strong>abc</strong>abc';
+    elm.insertBefore(emptyTextNode, elm.lastChild);
+    elm.insertBefore(emptyTextNode.cloneNode(), elm.firstChild);
+
+    const actual = TrimNode.trimNode(dom, elm, baseSchema);
+
+    assert.equal(actual.innerHTML, ' <strong>abc</strong> abc', 'Empty text node shouldn\'t be trimmed');
+  });
+
+  it('Document node', () => {
+    const expected = document.implementation.createHTMLDocument('test');
+    const actual = TrimNode.trimNode(dom, expected, baseSchema);
+
+    assert.strictEqual(actual, expected, 'Should return document as is');
+  });
+});

package/src/core/test/ts/browser/file/BlobCacheTest.ts

@@ -0,0 +1,98 @@
+import { before, describe, it } from '@ephox/bedrock-client';
+import { assert } from 'chai';
+
+import { BlobCache, BlobInfoData } from 'tinymce/core/api/file/BlobCache';
+
+describe('browser.tinymce.core.file.BlobCacheTest', () => {
+  const uriToBlob = (base64: string, type: string) => {
+    const str = atob(base64);
+    const arr = new Uint8Array(str.length);
+
+    for (let i = 0; i < arr.length; i++) {
+      arr[i] = str.charCodeAt(i);
+    }
+    return new Blob([ arr ], { type });
+  };
+
+  const id = 'blob0';
+  const base64 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII='; // 1x1 transparent png
+  const type = 'image/png';
+  const blob = uriToBlob(base64, type);
+  const name = 'blank';
+  const filename = 'blank.png';
+  const specifiedFilename = 'blank.jfif';
+  const uri = 'http://localhost/blank.png';
+
+  let blobCache: BlobCache;
+
+  before(() => {
+    blobCache = BlobCache();
+  });
+
+  it('create original version', () => {
+    const blobInfo = blobCache.create(id, blob, base64, name);
+    assert.deepEqual(
+      [ blobInfo.id(), blobInfo.base64(), blobInfo.filename() ],
+      [ id, base64, filename ],
+      'Testing original version of create() method'
+    );
+
+    blobCache.add(blobInfo);
+
+    assert.deepEqual(blobCache.get(id), blobInfo, 'Testing get()');
+    assert.isTrue(blobInfo.blobUri().indexOf('blob:') === 0, 'BlobInfo instance has blobUri() accessor');
+    assert.deepEqual(blobCache.getByUri(blobInfo.blobUri()), blobInfo, 'Testing getByUri(), findFirst()');
+    assert.deepEqual(blobCache.getByData(base64, type), blobInfo, 'Testing getByData()');
+
+    blobCache.removeByUri(blobInfo.blobUri());
+    assert.isUndefined(blobCache.getByUri(blobInfo.blobUri()), 'Testing removeByUri()');
+
+    assert.throws(() => {
+      blobCache.create({ blob } as BlobInfoData);
+      assert.fail('Exception should be thrown if BlobInfo is created without blob or base64 entries');
+    }, /.*/, 'Exception should be thrown if BlobInfo is created without blob or base64 entries');
+  });
+
+  it('create with object', () => {
+    const blobInfo = blobCache.create({
+      id,
+      blob,
+      base64,
+      name,
+      uri
+    });
+
+    assert.deepEqual(
+      [ blobInfo.id(), blobInfo.base64(), blobInfo.filename(), blobInfo.uri() ],
+      [ id, base64, filename, uri ],
+      'Testing if create() method accepts object'
+    );
+  });
+
+  it('create original version with filename', () => {
+    const blobInfo = blobCache.create(id, blob, base64, name, specifiedFilename);
+
+    assert.deepEqual(
+      [ blobInfo.id(), blobInfo.base64(), blobInfo.name(), blobInfo.filename() ],
+      [ id, base64, name, specifiedFilename ],
+      'Testing original version of create() method with specified filename'
+    );
+  });
+
+  it('create with object containing filename', () => {
+    const blobInfo = blobCache.create({
+      id,
+      blob,
+      base64,
+      name,
+      uri,
+      filename: specifiedFilename
+    });
+
+    assert.deepEqual(
+      [ blobInfo.id(), blobInfo.base64(), blobInfo.filename(), blobInfo.uri() ],
+      [ id, base64, specifiedFilename, uri ],
+      'Testing create() method with specified filename'
+    );
+  });
+});

package/src/core/test/ts/browser/file/ConversionsTest.ts

@@ -0,0 +1,25 @@
+import { describe, it } from '@ephox/bedrock-client';
+import { assert } from 'chai';
+
+import * as Conversions from 'tinymce/core/file/Conversions';
+
+describe('browser.tinymce.core.file.ConversionsTest', () => {
+  const invalidBlobUriSrc = 'blob:70BE8432-BA4D-4787-9AB9-86563351FBF7';
+
+  it('uriToBlob', () => {
+    return Conversions.uriToBlob('data:text/plain;base64,SGVsbG8sIFdvcmxkIQ%3D%3D')
+      .then(Conversions.blobToDataUri)
+      .then((dataUri) => {
+        assert.equal(dataUri, 'data:text/plain;base64,SGVsbG8sIFdvcmxkIQ==');
+      });
+  });
+
+  it('uriToBlob with invalid src', () => {
+    return Conversions.uriToBlob(invalidBlobUriSrc).then(() => {
+      assert.fail('Conversion should fail.');
+    }, (error) => {
+      assert.typeOf(error, 'object');
+      assert.include(error.message, invalidBlobUriSrc);
+    });
+  });
+});

package/src/core/test/ts/browser/file/ImageScannerTest.ts

@@ -0,0 +1,71 @@
+import { before, describe, it } from '@ephox/bedrock-client';
+import { LegacyUnit } from '@ephox/wrap-mcagar';
+import { assert } from 'chai';
+
+import Env from 'tinymce/core/api/Env';
+import { BlobCache } from 'tinymce/core/api/file/BlobCache';
+import * as Conversions from 'tinymce/core/file/Conversions';
+import { BlobInfoImagePair, ImageScanner } from 'tinymce/core/file/ImageScanner';
+import { UploadStatus } from 'tinymce/core/file/UploadStatus';
+
+import * as ViewBlock from '../../module/test/ViewBlock';
+
+describe('browser.tinymce.core.file.ImageScannerTest', () => {
+  const viewBlock = ViewBlock.bddSetup();
+  const base64Src = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAAAAACH5BAAAAAAALAAAAAABAAEAAAICTAEAOw==';
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" height="100" width="100"><circle cx="50" cy="50" r="40" stroke="black" stroke-width="3" fill="red"></svg>`;
+  const encodedSrc = 'data:image/svg+xml,' + encodeURIComponent(svg);
+  const invalidBlobUriSrc = 'blob:70BE8432-BA4D-4787-9AB9-86563351FBF7';
+  let blobUriSrc: string | undefined;
+
+  before(() => {
+    return Conversions.uriToBlob(base64Src).then((blob) => {
+      blobUriSrc = URL.createObjectURL(blob);
+    });
+  });
+
+  it('findAll', () => {
+    const imageScanner = ImageScanner(UploadStatus(), BlobCache());
+
+    viewBlock.update(
+      '<img src="' + base64Src + '">' +
+      '<img src="' + blobUriSrc + '">' +
+      '<img src="' + encodedSrc + '">' +
+      '<img src="' + Env.transparentSrc + '">' +
+      '<img src="' + base64Src + '" data-mce-bogus="1">' +
+      '<img src="' + base64Src + '" data-mce-placeholder="1">' +
+      '<img src="' + invalidBlobUriSrc + '">'
+    );
+
+    return imageScanner.findAll(viewBlock.get()).then((result) => {
+      assert.lengthOf(result, 4);
+      const base64ImageResult = result[0] as BlobInfoImagePair;
+      const encodedImageResult = result[2] as BlobInfoImagePair;
+      assert.typeOf(result[result.length - 1], 'object', 'Last item is not the image, but error object.');
+      assert.equal('data:image/gif;base64,' + base64ImageResult.blobInfo.base64(), base64Src);
+      LegacyUnit.equalDom(base64ImageResult.image, viewBlock.get().firstChild as HTMLImageElement);
+      assert.equal('data:image/svg+xml;base64,' + encodedImageResult.blobInfo.base64(), 'data:image/svg+xml;base64,' + btoa(svg));
+      LegacyUnit.equalDom(encodedImageResult.image, viewBlock.get().childNodes.item(2));
+    });
+  });
+
+  it('findAll (filtered)', () => {
+    const imageScanner = ImageScanner(UploadStatus(), BlobCache());
+
+    const predicate = (img: HTMLImageElement) => {
+      return !img.hasAttribute('data-skip');
+    };
+
+    viewBlock.update(
+      '<img src="' + base64Src + '">' +
+      '<img src="' + base64Src + '" data-skip="1">'
+    );
+
+    return imageScanner.findAll(viewBlock.get(), predicate).then((result) => {
+      assert.lengthOf(result, 1);
+      const firstResult = result[0] as BlobInfoImagePair;
+      assert.equal('data:image/gif;base64,' + firstResult.blobInfo.base64(), base64Src);
+      LegacyUnit.equalDom(firstResult.image, viewBlock.get().firstChild as HTMLImageElement);
+    });
+  });
+});