@glimmer/runtime/dist/commonjs/es5/lib/compat/svg-inner-html-fix.js

Minimal runtime needed to render Glimmer templates

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.applySVGInnerHTMLFix = applySVGInnerHTMLFix;
exports.SVG_NAMESPACE = void 0;

var _util = require("@glimmer/util");

var _operations = require("../dom/operations");

function _inheritsLoose(subClass, superClass) {
  subClass.prototype = Object.create(superClass.prototype);
  subClass.prototype.constructor = subClass;
  subClass.__proto__ = superClass;
}

var SVG_NAMESPACE = "http://www.w3.org/2000/svg"
/* SVG */
; // Patch:    insertAdjacentHTML on SVG Fix
// Browsers: Safari, IE, Edge, Firefox ~33-34
// Reason:   insertAdjacentHTML does not exist on SVG elements in Safari. It is
//           present but throws an exception on IE and Edge. Old versions of
//           Firefox create nodes in the incorrect namespace.
// Fix:      Since IE and Edge silently fail to create SVG nodes using
//           innerHTML, and because Firefox may create nodes in the incorrect
//           namespace using innerHTML on SVG elements, an HTML-string wrapping
//           approach is used. A pre/post SVG tag is added to the string, then
//           that whole string is added to a div. The created nodes are plucked
//           out and applied to the target location on DOM.

exports.SVG_NAMESPACE = SVG_NAMESPACE;

function applySVGInnerHTMLFix(document, DOMClass, svgNamespace) {
  if (!document) return DOMClass;

  if (!shouldApplyFix(document, svgNamespace)) {
    return DOMClass;
  }

  var div = document.createElement('div');
  return /*#__PURE__*/function (_DOMClass) {
    _inheritsLoose(DOMChangesWithSVGInnerHTMLFix, _DOMClass);

    function DOMChangesWithSVGInnerHTMLFix() {
      return _DOMClass.apply(this, arguments) || this;
    }

    var _proto = DOMChangesWithSVGInnerHTMLFix.prototype;

    _proto.insertHTMLBefore = function insertHTMLBefore(parent, nextSibling, html) {
      if (html === '') {
        return _DOMClass.prototype.insertHTMLBefore.call(this, parent, nextSibling, html);
      }

      if (parent.namespaceURI !== svgNamespace) {
        return _DOMClass.prototype.insertHTMLBefore.call(this, parent, nextSibling, html);
      }

      return fixSVG(parent, div, html, nextSibling);
    };

    return DOMChangesWithSVGInnerHTMLFix;
  }(DOMClass);
}

function fixSVG(parent, div, html, reference) {
  false && (0, _util.assert)(html !== '', 'html cannot be empty');
  var source; // This is important, because descendants of the <foreignObject> integration
  // point are parsed in the HTML namespace

  if (parent.tagName.toUpperCase() === 'FOREIGNOBJECT') {
    // IE, Edge: also do not correctly support using `innerHTML` on SVG
    // namespaced elements. So here a wrapper is used.
    var wrappedHtml = '<svg><foreignObject>' + html + '</foreignObject></svg>';
    (0, _util.clearElement)(div);
    div.insertAdjacentHTML("afterbegin"
    /* afterbegin */
    , wrappedHtml);
    source = div.firstChild.firstChild;
  } else {
    // IE, Edge: also do not correctly support using `innerHTML` on SVG
    // namespaced elements. So here a wrapper is used.
    var _wrappedHtml = '<svg>' + html + '</svg>';

    (0, _util.clearElement)(div);
    div.insertAdjacentHTML("afterbegin"
    /* afterbegin */
    , _wrappedHtml);
    source = div.firstChild;
  }

  return (0, _operations.moveNodesBefore)(source, parent, reference);
}

function shouldApplyFix(document, svgNamespace) {
  var svg = document.createElementNS(svgNamespace, 'svg');

  try {
    svg.insertAdjacentHTML("beforeend"
    /* beforeend */
    , '<circle></circle>');
  } catch (e) {// IE, Edge: Will throw, insertAdjacentHTML is unsupported on SVG
    // Safari: Will throw, insertAdjacentHTML is not present on SVG
  } finally {
    // FF: Old versions will create a node in the wrong namespace
    if (svg.childNodes.length === 1 && svg.firstChild.namespaceURI === SVG_NAMESPACE) {
      // The test worked as expected, no fix required
      return false;
    }

    return true;
  }
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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