@inboxsdk/core 0.2.28 → 0.2.29-alpha.1

package/src/platform-implementation-js/lib/dom/block-and-reemit-keyboard-events.js

@@ -0,0 +1,36 @@
+import Kefir from 'kefir';
+export default function blockAndReemiteKeyboardEvents(element) {
+    // Gmail stops propagation of keyboard events from escaping
+    // a specific compose window, which prevents any React components rendered
+    // in the compose window's subtree from getting them (since React adds
+    // a single event listener on the document). By stopping propagation of
+    // the original event and reemiting it on the document, we preserve
+    // exisitng behavior while giving React a chance to hear it.
+    Kefir.merge([
+        Kefir.fromEvents(element, 'keypress'),
+        Kefir.fromEvents(element, 'keydown'),
+        Kefir.fromEvents(element, 'keyup'),
+    ]).onValue((event) => {
+        event.stopPropagation();
+        const fakeEvent = new KeyboardEvent(event.type, { bubbles: true });
+        Object.defineProperties(fakeEvent, {
+            cancelable: { value: event.cancelable },
+            bubbles: { value: event.bubbles },
+            target: { value: event.target },
+            detail: { value: event.detail },
+            key: { value: event.key },
+            code: { value: event.code },
+            location: { value: event.location },
+            ctrlKey: { value: event.ctrlKey },
+            shiftKey: { value: event.shiftKey },
+            altKey: { value: event.altKey },
+            metaKey: { value: event.metaKey },
+            repeat: { value: event.repeat },
+            isComposing: { value: event.isComposing },
+            charCode: { value: event.charCode },
+            keyCode: { value: event.keyCode },
+            which: { value: event.which },
+        });
+        document.dispatchEvent(fakeEvent);
+    });
+}

package/src/platform-implementation-js/lib/dom/element-view-mapper.js

@@ -1,20 +1,17 @@
-/* @flow */
-
-import type Kefir from 'kefir';
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = elementViewMapper;
 // Returns a function suitable for mapping over a stream returned from
 // makeElementChildStream or kefirMakeElementChildStream.
-type View = { destroy(): void };
-import type { ElementWithLifetime } from './make-element-child-stream';
-
-export default function elementViewMapper<T: View>(
-  viewFn: (el: HTMLElement) => T
-): (event: ElementWithLifetime) => T {
-  return (event) => {
+function elementViewMapper(viewFn) {
+  return event => {
     const view = viewFn(event.el);
     event.removalStream.take(1).onValue(() => {
       view.destroy();
     });
     return view;
   };
-}
+}

package/src/platform-implementation-js/lib/dom/generic-button-view.d.ts

@@ -10,3 +10,4 @@ export default class GenericButtonView {
     deactivate(): void;
     private _setupEventStream;
 }
+//# sourceMappingURL=generic-button-view.d.ts.map

package/src/platform-implementation-js/lib/dom/generic-button-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-button-view.d.ts","sourceRoot":"","sources":["../../../../../../src/platform-implementation-js/lib/dom/generic-button-view.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,MAAM,CAAC,OAAO,OAAO,iBAAiB;IACpC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAwB;IACrD,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;gBAE7B,OAAO,EAAE,WAAW;IAMhC,OAAO;IAKP,UAAU,IAAI,WAAW;IAIzB,cAAc,IAAI,KAAK,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC;IAI5C,QAAQ;IAIR,UAAU;IAIV,OAAO,CAAC,iBAAiB;CAoB1B"}

package/src/platform-implementation-js/lib/dom/generic-button-view.js

@@ -0,0 +1,39 @@
+import * as Kefir from 'kefir';
+import kefirBus from 'kefir-bus';
+export default class GenericButtonView {
+    _eventStream = kefirBus();
+    _element;
+    constructor(element) {
+        this._element = element;
+        this._setupEventStream();
+    }
+    destroy() {
+        this._element.remove();
+        this._eventStream.end();
+    }
+    getElement() {
+        return this._element;
+    }
+    getEventStream() {
+        return this._eventStream;
+    }
+    activate() {
+        /* do nothing */
+    }
+    deactivate() {
+        /* do nothing */
+    }
+    _setupEventStream() {
+        const clickEventStream = Kefir.fromEvents(this._element, 'click');
+        clickEventStream.onValue((event) => {
+            event.stopPropagation();
+            event.preventDefault();
+        });
+        this._eventStream.plug(clickEventStream.map((event) => {
+            return {
+                eventName: 'click',
+                domEvent: event,
+            };
+        }));
+    }
+}

package/src/platform-implementation-js/lib/dom/get-insert-before-element.d.ts

@@ -1 +1,2 @@
 export default function getInsertBeforeElement(checkElement: HTMLElement, childElements: ArrayLike<any>, dataAttributes: string[]): HTMLElement | null;
+//# sourceMappingURL=get-insert-before-element.d.ts.map

package/src/platform-implementation-js/lib/dom/get-insert-before-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-insert-before-element.d.ts","sourceRoot":"","sources":["../../../../../../src/platform-implementation-js/lib/dom/get-insert-before-element.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,OAAO,UAAU,sBAAsB,CAC5C,YAAY,EAAE,WAAW,EACzB,aAAa,EAAE,SAAS,CAAC,GAAG,CAAC,EAC7B,cAAc,EAAE,MAAM,EAAE,GACvB,WAAW,GAAG,IAAI,CAkBpB"}

package/src/platform-implementation-js/lib/dom/get-insert-before-element.js

@@ -0,0 +1,39 @@
+// Use insert-element-in-order instead of this!
+export default function getInsertBeforeElement(checkElement, childElements, dataAttributes) {
+    const checkValues = {};
+    dataAttributes.forEach(function (attribute) {
+        const stringValue = checkElement.getAttribute(attribute);
+        checkValues[attribute] =
+            stringValue == null ? null : parseIfNumber(stringValue) ?? stringValue;
+    });
+    for (let ii = 0; ii < childElements.length; ii++) {
+        const child = childElements[ii];
+        if (_isChildAfter(checkValues, child, dataAttributes)) {
+            return child;
+        }
+    }
+    return null;
+}
+function _isChildAfter(checkValues, child, dataAttributes) {
+    for (let ii = 0; ii < dataAttributes.length; ii++) {
+        const attribute = dataAttributes[ii];
+        const stringValue = child.getAttribute(attribute);
+        const value = stringValue == null ? null : parseIfNumber(stringValue) ?? stringValue;
+        if (value > checkValues[attribute]) {
+            return true;
+        }
+        else if (value < checkValues[attribute]) {
+            return false;
+        }
+    }
+    return false;
+}
+function parseIfNumber(value) {
+    const n = parseFloat(value);
+    if (!isNaN(n) && isFinite(n)) {
+        return n;
+    }
+    else {
+        return null;
+    }
+}

package/src/platform-implementation-js/lib/dom/get-selection.js

@@ -1,61 +1,32 @@
-/* @flow */
+"use strict";
 
-import t from 'transducers.js';
-
-function isRangeEmpty(range: Range): boolean {
-  return (
-    range.startContainer === range.endContainer &&
-    range.startOffset === range.endOffset
-  );
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSelectedHTMLInElement = getSelectedHTMLInElement;
+exports.getSelectedTextInElement = getSelectedTextInElement;
+var _transducers = _interopRequireDefault(require("transducers.js"));
+function isRangeEmpty(range) {
+  return range.startContainer === range.endContainer && range.startOffset === range.endOffset;
 }
 
 // returns true if either end appears to be inside the element
-function isRangeInElement(range: Range, el: HTMLElement): boolean {
+function isRangeInElement(range, el) {
   return el.contains(range.startContainer) || el.contains(range.endContainer);
 }
-
-function isRangeSuitable(range: Range, el: HTMLElement): boolean {
+function isRangeSuitable(range, el) {
   return !isRangeEmpty(range) && isRangeInElement(range, el);
 }
-
-export function getSelectedTextInElement(
-  element: HTMLElement,
-  lastRange?: ?Range
-): ?string {
-  const selection = (document: any).getSelection();
-  return t.toArray(
-    [
-      selection && selection.rangeCount ? selection.getRangeAt(0) : null,
-      lastRange,
-    ],
-    t.compose(
-      t.keep(),
-      t.filter((range: Range) => isRangeSuitable(range, element)),
-      t.map((range: Range) => range.toString()),
-      t.take(1)
-    )
-  )[0];
-}
-
-export function getSelectedHTMLInElement(
-  element: HTMLElement,
-  lastRange?: ?Range
-): ?string {
-  const selection = (document: any).getSelection();
-  return t.toArray(
-    [
-      selection && selection.rangeCount ? selection.getRangeAt(0) : null,
-      lastRange,
-    ],
-    t.compose(
-      t.keep(),
-      t.filter((range: Range) => isRangeSuitable(range, element)),
-      t.map((range: Range) => {
-        const div = document.createElement('div');
-        div.appendChild(range.cloneContents());
-        return div.innerHTML;
-      }),
-      t.take(1)
-    )
-  )[0];
+function getSelectedTextInElement(element, lastRange) {
+  const selection = document.getSelection();
+  return _transducers.default.toArray([selection && selection.rangeCount ? selection.getRangeAt(0) : null, lastRange], _transducers.default.compose(_transducers.default.keep(), _transducers.default.filter(range => isRangeSuitable(range, element)), _transducers.default.map(range => range.toString()), _transducers.default.take(1)))[0];
 }
+function getSelectedHTMLInElement(element, lastRange) {
+  const selection = document.getSelection();
+  return _transducers.default.toArray([selection && selection.rangeCount ? selection.getRangeAt(0) : null, lastRange], _transducers.default.compose(_transducers.default.keep(), _transducers.default.filter(range => isRangeSuitable(range, element)), _transducers.default.map(range => {
+    const div = document.createElement('div');
+    div.appendChild(range.cloneContents());
+    return div.innerHTML;
+  }), _transducers.default.take(1)))[0];
+}

package/src/platform-implementation-js/lib/dom/insert-element-in-order.d.ts

@@ -1 +1,2 @@
 export default function insertElementInOrder(container: HTMLElement, el: HTMLElement, orderAttrs?: string[], insertBeforeNonSdk?: boolean): void;
+//# sourceMappingURL=insert-element-in-order.d.ts.map

package/src/platform-implementation-js/lib/dom/insert-element-in-order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-element-in-order.d.ts","sourceRoot":"","sources":["../../../../../../src/platform-implementation-js/lib/dom/insert-element-in-order.ts"],"names":[],"mappings":"AAQA,MAAM,CAAC,OAAO,UAAU,oBAAoB,CAC1C,SAAS,EAAE,WAAW,EACtB,EAAE,EAAE,WAAW,EACf,UAAU,GAAE,MAAM,EAAwB,EAC1C,kBAAkB,GAAE,OAAe,QAkCpC"}

package/src/platform-implementation-js/lib/dom/insert-element-in-order.js

@@ -0,0 +1,38 @@
+import t from 'transducers.js';
+const DEFAULT_ORDER_ATTRS = [
+    'data-group-order-hint',
+    'data-order-hint',
+    'data-insertion-order-hint',
+];
+export default function insertElementInOrder(container, el, orderAttrs = DEFAULT_ORDER_ATTRS, insertBeforeNonSdk = false) {
+    // get the first element with higher order hints
+    const insertBeforeElement = t.toArray(Array.prototype.slice.call(container.children), t.compose(t.filter((cel) => {
+        let hadAnyOrderAttrs = false;
+        for (const name of orderAttrs) {
+            const attr = el.getAttribute(name);
+            const cattr = cel.getAttribute(name);
+            if (attr == null || cattr == null)
+                continue;
+            hadAnyOrderAttrs = true;
+            let comparison;
+            if (!isNaN(parseFloat(attr)) && !isNaN(parseFloat(cattr))) {
+                comparison = parseFloat(cattr) - parseFloat(attr);
+            }
+            else {
+                comparison = cattr.localeCompare(attr);
+            }
+            if (comparison > 0)
+                return true;
+            if (comparison < 0)
+                return false;
+            // If the elements had equal hint values, then check the next hint.
+        }
+        if (insertBeforeNonSdk) {
+            return !hadAnyOrderAttrs;
+        }
+        else {
+            return false;
+        }
+    }), t.take(1)))[0];
+    container.insertBefore(el, insertBeforeElement);
+}

package/src/platform-implementation-js/lib/dom/insert-html-at-cursor.js

@@ -1,113 +1,81 @@
-/* @flow */
+"use strict";
 
-import * as ud from 'ud';
-import Kefir from 'kefir';
-
-var insertHTMLatCursor = ud.defn(
-  module,
-  function insertHTMLatCursor(
-    element: HTMLElement,
-    html: string,
-    oldRange: ?Object
-  ): ?HTMLElement {
-    element.focus();
-
-    if (element instanceof HTMLTextAreaElement) {
-      var oldStart = (element: any).selectionStart;
-      // first delete selected range
-      if ((element: any).selectionStart < (element: any).selectionEnd) {
-        element.value =
-          element.value.substring(0, (element: any).selectionStart) +
-          element.value.substring((element: any).selectionEnd);
-      }
-      // insert into position
-      element.value =
-        element.value.substring(0, oldStart) +
-        html +
-        element.value.substring(oldStart);
-      // set caret
-      (element: any).selectionStart = oldStart + html.length;
-      (element: any).selectionEnd = oldStart + html.length;
-    } else {
-      var editable = null;
-      if ((element: any).getSelection) {
-        editable = element;
-      } else if (element.ownerDocument && element.ownerDocument.getSelection) {
-        editable = element.ownerDocument;
-      }
-
-      if (editable) {
-        var sel = (editable: any).getSelection();
-        if (sel.getRangeAt && sel.rangeCount) {
-          var range = oldRange || sel.getRangeAt(0);
-          range.deleteContents();
-
-          var frag;
-          if (html instanceof DocumentFragment) {
-            frag = html;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var ud = _interopRequireWildcard(require("ud"));
+var _kefir = _interopRequireDefault(require("kefir"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var insertHTMLatCursor = ud.defn(module, function insertHTMLatCursor(element, html, oldRange) {
+  element.focus();
+  if (element instanceof HTMLTextAreaElement) {
+    var oldStart = element.selectionStart;
+    // first delete selected range
+    if (element.selectionStart < element.selectionEnd) {
+      element.value = element.value.substring(0, element.selectionStart) + element.value.substring(element.selectionEnd);
+    }
+    // insert into position
+    element.value = element.value.substring(0, oldStart) + html + element.value.substring(oldStart);
+    // set caret
+    element.selectionStart = oldStart + html.length;
+    element.selectionEnd = oldStart + html.length;
+  } else {
+    var editable = null;
+    if (element.getSelection) {
+      editable = element;
+    } else if (element.ownerDocument && element.ownerDocument.getSelection) {
+      editable = element.ownerDocument;
+    }
+    if (editable) {
+      var sel = editable.getSelection();
+      if (sel.getRangeAt && sel.rangeCount) {
+        var range = oldRange || sel.getRangeAt(0);
+        range.deleteContents();
+        var frag;
+        if (html instanceof DocumentFragment) {
+          frag = html;
+        } else {
+          frag = document.createDocumentFragment();
+          if (html instanceof HTMLElement) {
+            frag.appendChild(html);
           } else {
-            frag = document.createDocumentFragment();
-            if (html instanceof HTMLElement) {
-              frag.appendChild(html);
-            } else {
-              var el = document.createElement('div');
-              el.innerHTML = html;
-              var node;
-              while ((node = el.firstChild)) {
-                frag.appendChild(node);
-              }
+            var el = document.createElement('div');
+            el.innerHTML = html;
+            var node;
+            while (node = el.firstChild) {
+              frag.appendChild(node);
             }
           }
+        }
+        var firstChild = frag.firstElementChild;
+        range.insertNode(frag);
 
-          var firstChild: HTMLElement = (frag: any).firstElementChild;
-          range.insertNode(frag);
+        // Simulate a mousedown event to kill any existing focus-fixers.
+        var event = document.createEvent('MouseEvents');
+        event.initMouseEvent('mousedown', false, true, window, 1, 0, 0, 0, 0, false, false, false, false, 0, null);
+        event.preventDefault();
+        element.dispatchEvent(event);
 
-          // Simulate a mousedown event to kill any existing focus-fixers.
-          var event = document.createEvent('MouseEvents');
-          (event: any).initMouseEvent(
-            'mousedown',
-            false,
-            true,
-            window,
-            1,
-            0,
-            0,
-            0,
-            0,
-            false,
-            false,
-            false,
-            false,
-            0,
-            null
-          );
-          event.preventDefault();
-          element.dispatchEvent(event);
+        // Preserve the cursor position
+        range.collapse(false);
+        sel.removeAllRanges();
+        sel.addRange(range);
+        var nextUserCursorMove = _kefir.default.merge([_kefir.default.fromEvents(element, 'mousedown'), _kefir.default.fromEvents(element, 'keypress')]);
 
-          // Preserve the cursor position
-          range.collapse(false);
+        // Whenever the body element gets focus, manually make sure the cursor
+        // is in the right position, because Chrome likes to put it in the
+        // previous location instead because it hates us.
+        var focus = _kefir.default.fromEvents(element, 'focus').takeUntilBy(nextUserCursorMove).onValue(function () {
           sel.removeAllRanges();
           sel.addRange(range);
-
-          var nextUserCursorMove = Kefir.merge([
-            Kefir.fromEvents(element, 'mousedown'),
-            Kefir.fromEvents(element, 'keypress'),
-          ]);
-
-          // Whenever the body element gets focus, manually make sure the cursor
-          // is in the right position, because Chrome likes to put it in the
-          // previous location instead because it hates us.
-          var focus = Kefir.fromEvents(element, 'focus')
-            .takeUntilBy(nextUserCursorMove)
-            .onValue(function () {
-              sel.removeAllRanges();
-              sel.addRange(range);
-            });
-
-          return firstChild;
-        }
+        });
+        return firstChild;
       }
     }
   }
-);
-export default insertHTMLatCursor;
+});
+var _default = insertHTMLatCursor;
+exports.default = _default;

package/src/platform-implementation-js/lib/dom/is-node-in-range.js

@@ -1,19 +1,17 @@
-/* @flow */
+"use strict";
 
-export default function isNodeInRange(node: ?Node, range: ?Range): boolean {
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isNodeInRange;
+function isNodeInRange(node, range) {
   if (!range) {
     return false;
   }
-
   if (!node) {
     return false;
   }
-
   const newRange = document.createRange();
   newRange.selectNode(node);
-
-  return (
-    newRange.compareBoundaryPoints(Range.START_TO_END, range) < 1 &&
-    range.compareBoundaryPoints(Range.START_TO_END, newRange) < 1
-  );
-}
+  return newRange.compareBoundaryPoints(Range.START_TO_END, range) < 1 && range.compareBoundaryPoints(Range.START_TO_END, newRange) < 1;
+}

package/src/platform-implementation-js/lib/dom/keyboard-shortcut-stream.d.ts

@@ -1,2 +1,3 @@
 import * as Kefir from 'kefir';
 export default function keyboardShortcutStream(chord: string): Kefir.Observable<any, never>;
+//# sourceMappingURL=keyboard-shortcut-stream.d.ts.map

package/src/platform-implementation-js/lib/dom/keyboard-shortcut-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard-shortcut-stream.d.ts","sourceRoot":"","sources":["../../../../../../src/platform-implementation-js/lib/dom/keyboard-shortcut-stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAM/B,MAAM,CAAC,OAAO,UAAU,sBAAsB,CAC5C,KAAK,EAAE,MAAM,GACZ,KAAK,CAAC,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,CAc9B"}

package/src/platform-implementation-js/lib/dom/keyboard-shortcut-stream.js

@@ -0,0 +1,12 @@
+import * as Kefir from 'kefir';
+import Combokeys from 'combokeys-capture';
+const combokeys = typeof document !== 'undefined' && new Combokeys(document.body, true);
+export default function keyboardShortcutStream(chord) {
+    return Kefir.stream((emitter) => {
+        return (combokeys &&
+            combokeys.bind(chord, function (domEvent) {
+                emitter.emit(domEvent);
+                return false;
+            }, 'keydown'));
+    });
+}

package/src/platform-implementation-js/lib/dom/make-element-child-stream.d.ts

@@ -5,3 +5,4 @@ export interface ItemWithLifetime<T> {
 }
 export type ElementWithLifetime = ItemWithLifetime<HTMLElement>;
 export default function makeElementChildStream(element: HTMLElement): Kefir.Observable<ElementWithLifetime, never>;
+//# sourceMappingURL=make-element-child-stream.d.ts.map

package/src/platform-implementation-js/lib/dom/make-element-child-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-element-child-stream.d.ts","sourceRoot":"","sources":["../../../../../../src/platform-implementation-js/lib/dom/make-element-child-stream.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC;IACf,QAAQ,CAAC,aAAa,EAAE,KAAK,CAAC,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;CACvD;AACD,MAAM,MAAM,mBAAmB,GAAG,gBAAgB,CAAC,WAAW,CAAC,CAAC;AAIhE,MAAM,CAAC,OAAO,UAAU,sBAAsB,CAC5C,OAAO,EAAE,WAAW,GACnB,KAAK,CAAC,UAAU,CAAC,mBAAmB,EAAE,KAAK,CAAC,CA6E9C"}

package/src/platform-implementation-js/lib/dom/make-element-child-stream.js

@@ -0,0 +1,79 @@
+import asap from 'asap';
+import * as Kefir from 'kefir';
+import kefirStopper from 'kefir-stopper';
+// Emits events whenever the given element has any children added or removed.
+// Also when first listened to, it emits events for existing children.
+export default function makeElementChildStream(element) {
+    if (!element || !element.nodeType) {
+        throw new Error('Expected element, got ' + String(element));
+    }
+    return Kefir.stream((emitter) => {
+        const removalStreams = new Map();
+        let ended = false;
+        function newEl(el) {
+            if (el.nodeType !== 1)
+                return;
+            if (removalStreams.has(el)) {
+                throwLater(new Error('Already had removalStream for element with class ' + el.className));
+            }
+            const removalStream = kefirStopper();
+            removalStreams.set(el, removalStream);
+            try {
+                emitter.emit({ el, removalStream });
+            }
+            catch (err) {
+                throwLater(err);
+            }
+        }
+        function removedEl(el) {
+            if (el.nodeType !== 1)
+                return;
+            const removalStream = removalStreams.get(el);
+            removalStreams.delete(el);
+            if (removalStream) {
+                try {
+                    removalStream.destroy();
+                }
+                catch (err) {
+                    throwLater(err);
+                }
+            }
+            else {
+                throwLater(new Error('Could not find removalStream for element with class ' +
+                    el.className));
+            }
+        }
+        const observer = new MutationObserver(function (mutations) {
+            mutations.forEach((mutation) => {
+                Array.prototype.forEach.call(mutation.addedNodes, newEl);
+                Array.prototype.forEach.call(mutation.removedNodes, removedEl);
+            });
+        });
+        // We don't want to emit the start children synchronously before all
+        // stream listeners are subscribed.
+        asap(() => {
+            if (!ended) {
+                observer.observe(element, { childList: true });
+                // Clone child list first because it can change
+                Array.prototype.slice.call(element.children).forEach(newEl);
+            }
+        });
+        return function () {
+            ended = true;
+            observer.disconnect();
+            asap(() => {
+                removalStreams.forEach((removalStream) => {
+                    removalStream.destroy();
+                });
+            });
+        };
+    });
+}
+// Throw error at a later time where our error-logger can pick it up. This
+// avoids having this module depend on logger.js which we can't import because
+// this module is used in the injected script too.
+function throwLater(err) {
+    setTimeout(() => {
+        throw err;
+    }, 1);
+}

package/src/platform-implementation-js/lib/dom/make-element-stream-merger.d.ts

@@ -1,3 +1,4 @@
 import * as Kefir from 'kefir';
 import { ItemWithLifetime } from './make-element-child-stream';
 export default function makeElementStreamMerger<T>(): (event: ItemWithLifetime<T>) => Kefir.Observable<ItemWithLifetime<T>, never>;
+//# sourceMappingURL=make-element-stream-merger.d.ts.map

package/src/platform-implementation-js/lib/dom/make-element-stream-merger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-element-stream-merger.d.ts","sourceRoot":"","sources":["../../../../../../src/platform-implementation-js/lib/dom/make-element-stream-merger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAE/D,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAAC,CAAC,KAAK,CACpD,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC,KACvB,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CA4BhD"}