@difizen/libro-rendermime 0.0.2-alpha.0

package/es/renderers.js

@@ -0,0 +1,327 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["host", "source"];
+function _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return exports; }; var exports = {}, Op = Object.prototype, hasOwn = Op.hasOwnProperty, defineProperty = Object.defineProperty || function (obj, key, desc) { obj[key] = desc.value; }, $Symbol = "function" == typeof Symbol ? Symbol : {}, iteratorSymbol = $Symbol.iterator || "@@iterator", asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator", toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; function define(obj, key, value) { return Object.defineProperty(obj, key, { value: value, enumerable: !0, configurable: !0, writable: !0 }), obj[key]; } try { define({}, ""); } catch (err) { define = function define(obj, key, value) { return obj[key] = value; }; } function wrap(innerFn, outerFn, self, tryLocsList) { var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, generator = Object.create(protoGenerator.prototype), context = new Context(tryLocsList || []); return defineProperty(generator, "_invoke", { value: makeInvokeMethod(innerFn, self, context) }), generator; } function tryCatch(fn, obj, arg) { try { return { type: "normal", arg: fn.call(obj, arg) }; } catch (err) { return { type: "throw", arg: err }; } } exports.wrap = wrap; var ContinueSentinel = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var IteratorPrototype = {}; define(IteratorPrototype, iteratorSymbol, function () { return this; }); var getProto = Object.getPrototypeOf, NativeIteratorPrototype = getProto && getProto(getProto(values([]))); NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype); var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); function defineIteratorMethods(prototype) { ["next", "throw", "return"].forEach(function (method) { define(prototype, method, function (arg) { return this._invoke(method, arg); }); }); } function AsyncIterator(generator, PromiseImpl) { function invoke(method, arg, resolve, reject) { var record = tryCatch(generator[method], generator, arg); if ("throw" !== record.type) { var result = record.arg, value = result.value; return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) { invoke("next", value, resolve, reject); }, function (err) { invoke("throw", err, resolve, reject); }) : PromiseImpl.resolve(value).then(function (unwrapped) { result.value = unwrapped, resolve(result); }, function (error) { return invoke("throw", error, resolve, reject); }); } reject(record.arg); } var previousPromise; defineProperty(this, "_invoke", { value: function value(method, arg) { function callInvokeWithMethodAndArg() { return new PromiseImpl(function (resolve, reject) { invoke(method, arg, resolve, reject); }); } return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } }); } function makeInvokeMethod(innerFn, self, context) { var state = "suspendedStart"; return function (method, arg) { if ("executing" === state) throw new Error("Generator is already running"); if ("completed" === state) { if ("throw" === method) throw arg; return doneResult(); } for (context.method = method, context.arg = arg;;) { var delegate = context.delegate; if (delegate) { var delegateResult = maybeInvokeDelegate(delegate, context); if (delegateResult) { if (delegateResult === ContinueSentinel) continue; return delegateResult; } } if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) { if ("suspendedStart" === state) throw state = "completed", context.arg; context.dispatchException(context.arg); } else "return" === context.method && context.abrupt("return", context.arg); state = "executing"; var record = tryCatch(innerFn, self, context); if ("normal" === record.type) { if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue; return { value: record.arg, done: context.done }; } "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg); } }; } function maybeInvokeDelegate(delegate, context) { var methodName = context.method, method = delegate.iterator[methodName]; if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel; var record = tryCatch(method, delegate.iterator, context.arg); if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel; var info = record.arg; return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel); } function pushTryEntry(locs) { var entry = { tryLoc: locs[0] }; 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry); } function resetTryEntry(entry) { var record = entry.completion || {}; record.type = "normal", delete record.arg, entry.completion = record; } function Context(tryLocsList) { this.tryEntries = [{ tryLoc: "root" }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0); } function values(iterable) { if (iterable) { var iteratorMethod = iterable[iteratorSymbol]; if (iteratorMethod) return iteratorMethod.call(iterable); if ("function" == typeof iterable.next) return iterable; if (!isNaN(iterable.length)) { var i = -1, next = function next() { for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next; return next.value = undefined, next.done = !0, next; }; return next.next = next; } } return { next: doneResult }; } function doneResult() { return { value: undefined, done: !0 }; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", { value: GeneratorFunctionPrototype, configurable: !0 }), defineProperty(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: !0 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) { var ctor = "function" == typeof genFun && genFun.constructor; return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name)); }, exports.mark = function (genFun) { return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun; }, exports.awrap = function (arg) { return { __await: arg }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () { return this; }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { void 0 === PromiseImpl && (PromiseImpl = Promise); var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) { return result.done ? result.value : iter.next(); }); }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () { return this; }), define(Gp, "toString", function () { return "[object Generator]"; }), exports.keys = function (val) { var object = Object(val), keys = []; for (var key in object) keys.push(key); return keys.reverse(), function next() { for (; keys.length;) { var key = keys.pop(); if (key in object) return next.value = key, next.done = !1, next; } return next.done = !0, next; }; }, exports.values = values, Context.prototype = { constructor: Context, reset: function reset(skipTempReset) { if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined); }, stop: function stop() { this.done = !0; var rootRecord = this.tryEntries[0].completion; if ("throw" === rootRecord.type) throw rootRecord.arg; return this.rval; }, dispatchException: function dispatchException(exception) { if (this.done) throw exception; var context = this; function handle(loc, caught) { return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught; } for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i], record = entry.completion; if ("root" === entry.tryLoc) return handle("end"); if (entry.tryLoc <= this.prev) { var hasCatch = hasOwn.call(entry, "catchLoc"), hasFinally = hasOwn.call(entry, "finallyLoc"); if (hasCatch && hasFinally) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } else if (hasCatch) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); } else { if (!hasFinally) throw new Error("try statement without catch or finally"); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } } } }, abrupt: function abrupt(type, arg) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { var finallyEntry = entry; break; } } finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null); var record = finallyEntry ? finallyEntry.completion : {}; return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record); }, complete: function complete(record, afterLoc) { if ("throw" === record.type) throw record.arg; return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel; }, finish: function finish(finallyLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel; } }, catch: function _catch(tryLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc === tryLoc) { var record = entry.completion; if ("throw" === record.type) { var thrown = record.arg; resetTryEntry(entry); } return thrown; } } throw new Error("illegal catch attempt"); }, delegateYield: function delegateYield(iterable, resultName, nextLoc) { return this.delegate = { iterator: values(iterable), resultName: resultName, nextLoc: nextLoc }, "next" === this.method && (this.arg = undefined), ContinueSentinel; } }, exports; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+import { concatMultilineString } from '@difizen/libro-common';
+import { ansiSpan, autolink, evalInnerHTMLScriptTags, handleDefaults, handleUrls, splitShallowNode } from "./rendermime-utils.js";
+
+/**
+ * Render text into a host node.
+ *
+ * @param options - The options for rendering.
+ *
+ * @returns A promise which resolves when rendering is complete.
+ */
+export function renderText(options) {
+  // Unpack the options.
+  var host = options.host,
+    sanitizer = options.sanitizer,
+    source = options.source,
+    mimeType = options.mimeType;
+  var data = concatMultilineString(JSON.parse(JSON.stringify(source)));
+  // Create the HTML content.
+  var content = sanitizer.sanitize(ansiSpan(data), {
+    allowedTags: ['span']
+  });
+  if (mimeType === 'application/vnd.jupyter.stderr') {
+    host.setAttribute('data-mime-type', 'application/vnd.jupyter.stderr');
+  }
+  // Set the sanitized content for the host node.
+  var pre = document.createElement('pre');
+  pre.innerHTML = content;
+  var preTextContent = pre.textContent;
+  if (preTextContent) {
+    // Note: only text nodes and span elements should be present after sanitization in the `<pre>` element.
+    var linkedNodes = autolink(preTextContent);
+    var inAnchorElement = false;
+    var combinedNodes = [];
+    var preNodes = Array.from(pre.childNodes);
+    while (preNodes.length && linkedNodes.length) {
+      var _preNode$textContent, _linkNode$textContent;
+      // Use non-null assertions to workaround TypeScript context awareness limitation
+      // (if any of the arrays were empty, we would not enter the body of the loop).
+      var preNode = preNodes.shift();
+      var linkNode = linkedNodes.shift();
+
+      // This should never happen because we modify the arrays in flight so they should end simultaneously,
+      // but this makes the coding assistance happy and might make it easier to conceptualize.
+      if (typeof preNode === 'undefined') {
+        combinedNodes.push(linkNode);
+        break;
+      }
+      if (typeof linkNode === 'undefined') {
+        combinedNodes.push(preNode);
+        break;
+      }
+      var preLen = (_preNode$textContent = preNode.textContent) === null || _preNode$textContent === void 0 ? void 0 : _preNode$textContent.length;
+      var linkLen = (_linkNode$textContent = linkNode.textContent) === null || _linkNode$textContent === void 0 ? void 0 : _linkNode$textContent.length;
+      if (preLen && linkLen) {
+        if (preLen > linkLen) {
+          // Split pre node and only keep the shorter part
+          var _splitShallowNode = splitShallowNode(preNode, linkLen),
+            keep = _splitShallowNode.pre,
+            postpone = _splitShallowNode.post;
+          preNodes.unshift(postpone);
+          preNode = keep;
+        } else if (linkLen > preLen) {
+          var _splitShallowNode2 = splitShallowNode(linkNode, preLen),
+            _keep = _splitShallowNode2.pre,
+            _postpone = _splitShallowNode2.post;
+          linkedNodes.unshift(_postpone);
+          linkNode = _keep;
+        }
+      }
+      var lastCombined = combinedNodes[combinedNodes.length - 1];
+
+      // If we are already in an anchor element and the anchor element did not change,
+      // we should insert the node from <pre> which is either Text node or coloured span Element
+      // into the anchor content as a child
+      if (inAnchorElement && linkNode.href === lastCombined.href) {
+        lastCombined.appendChild(preNode);
+      } else {
+        // the `linkNode` is either Text or AnchorElement;
+        var isAnchor = linkNode.nodeType !== Node.TEXT_NODE;
+        // if we are NOT about to start an anchor element, just add the pre Node
+        if (!isAnchor) {
+          combinedNodes.push(preNode);
+          inAnchorElement = false;
+        } else {
+          // otherwise start a new anchor; the contents of the `linkNode` and `preNode` should be the same,
+          // so we just put the neatly formatted `preNode` inside the anchor node (`linkNode`)
+          // and append that to combined nodes.
+          linkNode.textContent = '';
+          linkNode.appendChild(preNode);
+          combinedNodes.push(linkNode);
+          inAnchorElement = true;
+        }
+      }
+    }
+    // TODO: replace with `.replaceChildren()` once the target ES version allows it
+    pre.innerHTML = '';
+    for (var _i = 0, _combinedNodes = combinedNodes; _i < _combinedNodes.length; _i++) {
+      var child = _combinedNodes[_i];
+      pre.appendChild(child);
+    }
+  }
+  host.appendChild(pre);
+  host.classList.add('libro-text-render');
+
+  // Return the rendered promise.
+  return Promise.resolve(undefined);
+}
+
+/**
+ * Render an image into a host node.
+ *
+ * @param options - The options for rendering.
+ *
+ * @returns A promise which resolves when rendering is complete.
+ */
+export function renderImage(options) {
+  // Unpack the options.
+  var host = options.host,
+    mimeType = options.mimeType,
+    source = options.source,
+    width = options.width,
+    height = options.height,
+    needsBackground = options.needsBackground,
+    unconfined = options.unconfined;
+
+  // Clear the content in the host.
+  host.textContent = '';
+
+  // Create the image element.
+  var img = document.createElement('img');
+
+  // Set the source of the image.
+  img.src = "data:".concat(mimeType, ";base64,").concat(source);
+
+  // Set the size of the image if provided.
+  if (typeof height === 'number') {
+    img.height = height;
+  }
+  if (typeof width === 'number') {
+    img.width = width;
+  }
+  if (needsBackground === 'light') {
+    img.classList.add('jp-needs-light-background');
+  } else if (needsBackground === 'dark') {
+    img.classList.add('jp-needs-dark-background');
+  }
+  if (unconfined === true) {
+    img.classList.add('jp-mod-unconfined');
+  }
+
+  // Add the image to the host.
+  host.appendChild(img);
+
+  // Return the rendered promise.
+  return Promise.resolve(undefined);
+}
+
+/**
+ * Render HTML into a host node.
+ *
+ * @param options - The options for rendering.
+ *
+ * @returns A promise which resolves when rendering is complete.
+ */
+export function renderHTML(options) {
+  // Unpack the options.
+  var host = options.host,
+    trusted = options.trusted,
+    sanitizer = options.sanitizer,
+    resolver = options.resolver,
+    linkHandler = options.linkHandler;
+  var source = options.source;
+
+  // translator = translator || nullTranslator;
+  // const trans = translator?.load('jupyterlab');
+  var originalSource = source;
+
+  // Bail early if the source is empty.
+  if (!source) {
+    host.textContent = '';
+    return Promise.resolve(undefined);
+  }
+
+  // Sanitize the source if it is not trusted. This removes all
+  // `<script>` tags as well as other potentially harmful HTML.
+  if (!trusted) {
+    originalSource = "".concat(source);
+    source = sanitizer.sanitize(source);
+  }
+
+  // Set the inner HTML of the host.
+  host.innerHTML = source;
+  if (host.getElementsByTagName('script').length > 0) {
+    // If output it trusted, eval any script tags contained in the HTML.
+    // This is not done automatically by the browser when script tags are
+    // created by setting `innerHTML`.
+    if (trusted) {
+      evalInnerHTMLScriptTags(host);
+    } else {
+      var container = document.createElement('div');
+      var warning = document.createElement('pre');
+      warning.textContent = 'This HTML output contains inline scripts. Are you sure that you want to run arbitrary Javascript within your JupyterLab session?';
+      var runButton = document.createElement('button');
+      runButton.textContent = 'Run';
+      runButton.onclick = function () {
+        host.innerHTML = originalSource;
+        evalInnerHTMLScriptTags(host);
+        if (host.firstChild) {
+          host.removeChild(host.firstChild);
+        }
+      };
+      container.appendChild(warning);
+      container.appendChild(runButton);
+      host.insertBefore(container, host.firstChild);
+    }
+  }
+
+  // Handle default behavior of nodes.
+  handleDefaults(host, resolver);
+
+  // Patch the urls if a resolver is available.
+  var promise;
+  if (resolver) {
+    promise = handleUrls(host, resolver, linkHandler);
+  } else {
+    promise = Promise.resolve(undefined);
+  }
+
+  // Return the final rendered promise.
+  return promise;
+}
+
+/**
+ * Render SVG into a host node.
+ *
+ * @param options - The options for rendering.
+ *
+ * @returns A promise which resolves when rendering is complete.
+ */
+export function renderSVG(options) {
+  // Unpack the options.
+  var host = options.host,
+    unconfined = options.unconfined;
+  var source = options.source;
+  // Clear the content if there is no source.
+  if (!source) {
+    host.textContent = '';
+    return Promise.resolve(undefined);
+  }
+
+  // // Display a message if the source is not trusted.
+  // if (!trusted) {
+  //   host.textContent = 'Cannot display an untrusted SVG. Maybe you need to run the cell?';
+  //   return Promise.resolve(undefined);
+  // }
+
+  // Add missing SVG namespace (if actually missing)
+  var patt = '<svg[^>]+xmlns=[^>]+svg';
+  if (source.search(patt) < 0) {
+    source = source.replace('<svg', '<svg xmlns="http://www.w3.org/2000/svg"');
+  }
+
+  // Render in img so that user can save it easily
+  var img = new Image();
+  img.src = "data:image/svg+xml,".concat(encodeURIComponent(source));
+  host.appendChild(img);
+  if (unconfined === true) {
+    host.classList.add('jp-mod-unconfined');
+  }
+  return Promise.resolve();
+}
+
+/**
+ * Render Markdown into a host node.
+ *
+ * @param options - The options for rendering.
+ *
+ * @returns A promise which resolves when rendering is complete.
+ */
+export function renderMarkdown(_x) {
+  return _renderMarkdown.apply(this, arguments);
+}
+function _renderMarkdown() {
+  _renderMarkdown = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(options) {
+    var host, source, others, html;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          // Unpack the options.
+          host = options.host, source = options.source, others = _objectWithoutProperties(options, _excluded); // Clear the content if there is no source.
+          if (source) {
+            _context.next = 4;
+            break;
+          }
+          host.textContent = '';
+          return _context.abrupt("return");
+        case 4:
+          html = ''; // Fallback if the application does not have any markdown parser.
+          html = "<pre>".concat(source, "</pre>");
+
+          // Render HTML.
+          _context.next = 8;
+          return renderHTML(_objectSpread({
+            host: host,
+            source: html,
+            shouldTypeset: false
+          }, others));
+        case 8:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _renderMarkdown.apply(this, arguments);
+}

package/es/rendermime-factory.d.ts

@@ -0,0 +1,30 @@
+import type { IRendererFactory } from './rendermime-protocol.js';
+/**
+ * A mime renderer factory for raw html.
+ */
+export declare const htmlRendererFactory: IRendererFactory;
+/**
+ * A mime renderer factory for images.
+ */
+export declare const imageRendererFactory: IRendererFactory;
+/**
+ * A mime renderer factory for LaTeX.
+ */
+export declare const latexRendererFactory: IRendererFactory;
+/**
+ * A mime renderer factory for Markdown.
+ */
+export declare const markdownRendererFactory: IRendererFactory;
+/**
+ * A mime renderer factory for svg.
+ */
+export declare const svgRendererFactory: IRendererFactory;
+/**
+ * A mime renderer factory for plain and jupyter console text data.
+ */
+export declare const textRendererFactory: IRendererFactory;
+/**
+ * The standard factories provided by the rendermime package.
+ */
+export declare const standardRendererFactories: IRendererFactory[];
+//# sourceMappingURL=rendermime-factory.d.ts.map

package/es/rendermime-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rendermime-factory.d.ts","sourceRoot":"","sources":["../src/rendermime-factory.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAEjE;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,gBAMjC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,gBAMlC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,gBAMlC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,EAAE,gBAMrC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,gBAMhC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,gBAUjC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,yBAAyB,EAAE,gBAAgB,EAQvD,CAAC"}

package/es/rendermime-factory.js

@@ -0,0 +1,73 @@
+import { HTMLRender, ImageRender, LatexRender, MarkdownRender, SVGRender, TextRender } from "./components/index.js";
+/**
+ * A mime renderer factory for raw html.
+ */
+export var htmlRendererFactory = {
+  renderType: 'htmlRenderer',
+  safe: true,
+  mimeTypes: ['text/html'],
+  defaultRank: 50,
+  render: HTMLRender
+};
+
+/**
+ * A mime renderer factory for images.
+ */
+export var imageRendererFactory = {
+  renderType: 'imageRenderer',
+  safe: true,
+  mimeTypes: ['image/bmp', 'image/png', 'image/jpeg', 'image/gif', 'image/webp'],
+  defaultRank: 90,
+  render: ImageRender
+};
+
+/**
+ * A mime renderer factory for LaTeX.
+ */
+export var latexRendererFactory = {
+  renderType: 'latexRenderer',
+  safe: true,
+  mimeTypes: ['text/latex'],
+  defaultRank: 70,
+  render: LatexRender
+};
+
+/**
+ * A mime renderer factory for Markdown.
+ */
+export var markdownRendererFactory = {
+  renderType: 'markdownRenderer',
+  safe: true,
+  mimeTypes: ['text/markdown'],
+  defaultRank: 60,
+  render: MarkdownRender
+};
+
+/**
+ * A mime renderer factory for svg.
+ */
+export var svgRendererFactory = {
+  renderType: 'svgRenderer',
+  safe: false,
+  mimeTypes: ['image/svg+xml'],
+  defaultRank: 80,
+  render: SVGRender
+};
+
+/**
+ * A mime renderer factory for plain and jupyter console text data.
+ */
+export var textRendererFactory = {
+  renderType: 'textRenderer',
+  safe: true,
+  mimeTypes: ['text/plain', 'application/vnd.jupyter.stdout', 'application/vnd.jupyter.stderr'],
+  defaultRank: 120,
+  render: TextRender
+};
+
+/**
+ * The standard factories provided by the rendermime package.
+ */
+export var standardRendererFactories = [htmlRendererFactory, markdownRendererFactory, latexRendererFactory, svgRendererFactory, imageRendererFactory,
+// javaScriptRendererFactory,
+textRendererFactory];

package/es/rendermime-module.d.ts

@@ -0,0 +1,3 @@
+import { ManaModule } from '@difizen/mana-app';
+export declare const LibroRenderMimeModule: ManaModule;
+//# sourceMappingURL=rendermime-module.d.ts.map

package/es/rendermime-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rendermime-module.d.ts","sourceRoot":"","sources":["../src/rendermime-module.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAS/C,eAAO,MAAM,qBAAqB,YAQP,CAAC"}

package/es/rendermime-module.js

@@ -0,0 +1,11 @@
+import { MarkdownModule } from '@difizen/libro-markdown';
+import { ManaModule } from '@difizen/mana-app';
+import { standardRendererFactories as initialFactories } from "./rendermime-factory.js";
+import { IRenderMimeRegistryOptions, RenderMimeContribution } from "./rendermime-protocol.js";
+import { RenderMimeRegistry } from "./rendermime-registry.js";
+export var LibroRenderMimeModule = ManaModule.create().contribution(RenderMimeContribution).register(RenderMimeRegistry, {
+  token: IRenderMimeRegistryOptions,
+  useValue: {
+    initialFactories: initialFactories
+  }
+}).dependOn(MarkdownModule);