@difizen/libro-rendermime 0.0.2-alpha.0

package/es/rendermime-utils.js

@@ -0,0 +1,603 @@
+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); }
+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 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 { isDisplayData, isDisplayUpdate, isError, isExecuteResult, isPrimitive, isStream, URL } from '@difizen/libro-common';
+import { URI } from '@difizen/mana-app';
+import escape from 'lodash.escape';
+/**
+ * Get the data from a notebook output.
+ */
+export function getData(output) {
+  var bundle = {};
+  if (isExecuteResult(output) || isDisplayData(output) || isDisplayUpdate(output)) {
+    bundle = output.data;
+  } else if (isStream(output)) {
+    if (output.name === 'stderr') {
+      bundle['application/vnd.jupyter.stderr'] = output.text;
+    } else {
+      bundle['application/vnd.jupyter.stdout'] = output.text;
+    }
+  } else if (isError(output)) {
+    bundle['application/vnd.jupyter.error'] = output;
+    var traceback = output.traceback.join('\n');
+    bundle['application/vnd.jupyter.stderr'] = traceback || "".concat(output.ename, ": ").concat(output.evalue);
+  }
+  return convertBundle(bundle);
+}
+
+/**
+ * Extract a value from a JSONObject.
+ */
+export function extract(value, key) {
+  var item = value[key];
+  if (item === undefined || isPrimitive(item)) {
+    return item;
+  }
+  return JSON.parse(JSON.stringify(item));
+}
+
+/**
+ * Convert a mime bundle to mime data.
+ */
+function convertBundle(bundle) {
+  var map = Object.create(null);
+  for (var mimeType in bundle) {
+    map[mimeType] = extract(bundle, mimeType);
+  }
+  return map;
+}
+var ANSI_COLORS = ['ansi-black', 'ansi-red', 'ansi-green', 'ansi-yellow', 'ansi-blue', 'ansi-magenta', 'ansi-cyan', 'ansi-white', 'ansi-black-intense', 'ansi-red-intense', 'ansi-green-intense', 'ansi-yellow-intense', 'ansi-blue-intense', 'ansi-magenta-intense', 'ansi-cyan-intense', 'ansi-white-intense'];
+
+/**
+ * Create HTML tags for a string with given foreground, background etc. and
+ * add them to the `out` array.
+ */
+function pushColoredChunk(chunk, fg, bg, bold, underline, inverse, out) {
+  var _fg = fg;
+  var _bg = bg;
+  if (chunk) {
+    var classes = [];
+    var styles = [];
+    if (bold && typeof _fg === 'number' && 0 <= _fg && _fg < 8) {
+      _fg += 8; // Bold text uses "intense" colors
+    }
+
+    if (inverse) {
+      var _ref = [_bg, _fg];
+      _fg = _ref[0];
+      _bg = _ref[1];
+    }
+    if (typeof _fg === 'number') {
+      classes.push(ANSI_COLORS[_fg] + '-fg');
+    } else if (_fg.length) {
+      styles.push("color: rgb(".concat(_fg, ")"));
+    } else if (inverse) {
+      classes.push('ansi-default-inverse-fg');
+    }
+    if (typeof _bg === 'number') {
+      classes.push(ANSI_COLORS[_bg] + '-bg');
+    } else if (_bg.length) {
+      styles.push("background-color: rgb(".concat(_bg, ")"));
+    } else if (inverse) {
+      classes.push('ansi-default-inverse-bg');
+    }
+    if (bold) {
+      classes.push('ansi-bold');
+    }
+    if (underline) {
+      classes.push('ansi-underline');
+    }
+    if (classes.length || styles.length) {
+      out.push('<span');
+      if (classes.length) {
+        out.push(" class=\"".concat(classes.join(' '), "\""));
+      }
+      if (styles.length) {
+        out.push(" style=\"".concat(styles.join('; '), "\""));
+      }
+      out.push('>');
+      out.push(chunk);
+      out.push('</span>');
+    } else {
+      out.push(chunk);
+    }
+  }
+}
+
+/**
+ * Convert ANSI extended colors to R/G/B triple.
+ */
+function getExtendedColors(numbers) {
+  var r;
+  var g;
+  var b;
+  var n = numbers.shift();
+  if (n === 2 && numbers.length >= 3) {
+    // 24-bit RGB
+    r = numbers.shift();
+    g = numbers.shift();
+    b = numbers.shift();
+    if ([r, g, b].some(function (c) {
+      return c < 0 || 255 < c;
+    })) {
+      throw new RangeError('Invalid range for RGB colors');
+    }
+  } else if (n === 5 && numbers.length >= 1) {
+    // 256 colors
+    var idx = numbers.shift();
+    if (idx < 0) {
+      throw new RangeError('Color index must be >= 0');
+    } else if (idx < 16) {
+      // 16 default terminal colors
+      return idx;
+    } else if (idx < 232) {
+      // 6x6x6 color cube, see https://stackoverflow.com/a/27165165/500098
+      r = Math.floor((idx - 16) / 36);
+      r = r > 0 ? 55 + r * 40 : 0;
+      g = Math.floor((idx - 16) % 36 / 6);
+      g = g > 0 ? 55 + g * 40 : 0;
+      b = (idx - 16) % 6;
+      b = b > 0 ? 55 + b * 40 : 0;
+    } else if (idx < 256) {
+      // grayscale, see https://stackoverflow.com/a/27165165/500098
+      r = g = b = (idx - 232) * 10 + 8;
+    } else {
+      throw new RangeError('Color index must be < 256');
+    }
+  } else {
+    throw new RangeError('Invalid extended color specification');
+  }
+  return [r, g, b];
+}
+/**
+ * Transform ANSI color escape codes into HTML <span> tags with CSS
+ * classes such as "ansi-green-intense-fg".
+ * The actual colors used are set in the CSS file.
+ * This also removes non-color escape sequences.
+ * This is supposed to have the same behavior as nbconvert.filters.ansi2html()
+ */
+export function ansiSpan(str) {
+  var ansiRe = /\x1b\[(.*?)([@-~])/g; // eslint-disable-line no-control-regex
+  var fg = [];
+  var bg = [];
+  var bold = false;
+  var underline = false;
+  var inverse = false;
+  var match;
+  var out = [];
+  var numbers = [];
+  var start = 0;
+  var _str = escape(str);
+  _str += '\x1b[m'; // Ensure markup for trailing text
+  // tslint:disable-next-line
+  while (match = ansiRe.exec(_str)) {
+    if (match[2] === 'm') {
+      var items = match[1].split(';');
+      for (var i = 0; i < items.length; i++) {
+        var item = items[i];
+        if (item === '') {
+          numbers.push(0);
+        } else if (item.search(/^\d+$/) !== -1) {
+          numbers.push(parseInt(item, 10));
+        } else {
+          // Ignored: Invalid color specification
+          numbers.length = 0;
+          break;
+        }
+      }
+    } else {
+      // Ignored: Not a color code
+    }
+    var chunk = _str.substring(start, match.index);
+    pushColoredChunk(chunk, fg, bg, bold, underline, inverse, out);
+    start = ansiRe.lastIndex;
+    while (numbers.length) {
+      var n = numbers.shift();
+      switch (n) {
+        case 0:
+          fg = bg = [];
+          bold = false;
+          underline = false;
+          inverse = false;
+          break;
+        case 1:
+        case 5:
+          bold = true;
+          break;
+        case 4:
+          underline = true;
+          break;
+        case 7:
+          inverse = true;
+          break;
+        case 21:
+        case 22:
+          bold = false;
+          break;
+        case 24:
+          underline = false;
+          break;
+        case 27:
+          inverse = false;
+          break;
+        case 30:
+        case 31:
+        case 32:
+        case 33:
+        case 34:
+        case 35:
+        case 36:
+        case 37:
+          fg = n - 30;
+          break;
+        case 38:
+          try {
+            fg = getExtendedColors(numbers);
+          } catch (e) {
+            numbers.length = 0;
+          }
+          break;
+        case 39:
+          fg = [];
+          break;
+        case 40:
+        case 41:
+        case 42:
+        case 43:
+        case 44:
+        case 45:
+        case 46:
+        case 47:
+          bg = n - 40;
+          break;
+        case 48:
+          try {
+            bg = getExtendedColors(numbers);
+          } catch (e) {
+            numbers.length = 0;
+          }
+          break;
+        case 49:
+          bg = [];
+          break;
+        case 90:
+        case 91:
+        case 92:
+        case 93:
+        case 94:
+        case 95:
+        case 96:
+        case 97:
+          fg = n - 90 + 8;
+          break;
+        case 100:
+        case 101:
+        case 102:
+        case 103:
+        case 104:
+        case 105:
+        case 106:
+        case 107:
+          bg = n - 100 + 8;
+          break;
+        default:
+        // Unknown codes are ignored
+      }
+    }
+  }
+
+  return out.join('');
+}
+/**
+ * Replace URLs with links.
+ *
+ * @param content - The text content of a node.
+ *
+ * @returns A list of text nodes and anchor elements.
+ */
+export function autolink(content) {
+  // Taken from Visual Studio Code:
+  // https://github.com/microsoft/vscode/blob/9f709d170b06e991502153f281ec3c012add2e42/src/vs/workbench/contrib/debug/browser/linkDetector.ts#L17-L18
+  var controlCodes = "\\u0000-\\u0020\\u007f-\\u009f";
+  var webLinkRegex = new RegExp('(?:[a-zA-Z][a-zA-Z0-9+.-]{2,}:\\/\\/|data:|www\\.)[^\\s' + controlCodes + '"]{2,}[^\\s' + controlCodes + '"\'(){}\\[\\],:;.!?]', 'ug');
+  var nodes = [];
+  var lastIndex = 0;
+  var match;
+  while (null !== (match = webLinkRegex.exec(content))) {
+    if (match.index !== lastIndex) {
+      nodes.push(document.createTextNode(content.slice(lastIndex, match.index)));
+    }
+    var url = match[0];
+    // Special case when the URL ends with ">" or "<"
+    var lastChars = url.slice(-1);
+    var endsWithGtLt = ['>', '<'].indexOf(lastChars) !== -1;
+    var len = endsWithGtLt ? url.length - 1 : url.length;
+    var anchor = document.createElement('a');
+    url = url.slice(0, len);
+    anchor.href = url.startsWith('www.') ? 'https://' + url : url;
+    anchor.rel = 'noopener';
+    anchor.target = '_blank';
+    anchor.appendChild(document.createTextNode(url.slice(0, len)));
+    nodes.push(anchor);
+    lastIndex = match.index + len;
+  }
+  if (lastIndex !== content.length) {
+    nodes.push(document.createTextNode(content.slice(lastIndex, content.length)));
+  }
+  return nodes;
+}
+/**
+ * Split a shallow node (node without nested nodes inside) at a given text content position.
+ *
+ * @param node the shallow node to be split
+ * @param at the position in textContent at which the split should occur
+ */
+export function splitShallowNode(node, at) {
+  var _node$textContent, _node$textContent2;
+  var pre = node.cloneNode();
+  pre.textContent = (_node$textContent = node.textContent) === null || _node$textContent === void 0 ? void 0 : _node$textContent.substr(0, at);
+  var post = node.cloneNode();
+  post.textContent = (_node$textContent2 = node.textContent) === null || _node$textContent2 === void 0 ? void 0 : _node$textContent2.substr(at);
+  return {
+    pre: pre,
+    post: post
+  };
+}
+export function sortedTypes(map) {
+  return Object.keys(map).sort(function (a, b) {
+    var p1 = map[a];
+    var p2 = map[b];
+    if (p1.rank !== p2.rank) {
+      return p1.rank - p2.rank;
+    }
+    return p1.id - p2.id;
+  });
+}
+
+/**
+ * Eval the script tags contained in a host populated by `innerHTML`.
+ *
+ * When script tags are created via `innerHTML`, the browser does not
+ * evaluate them when they are added to the page. This function works
+ * around that by creating new equivalent script nodes manually, and
+ * replacing the originals.
+ */
+export function evalInnerHTMLScriptTags(host) {
+  // Create a snapshot of the current script nodes.
+  var scripts = Array.from(host.getElementsByTagName('script'));
+
+  // Loop over each script node.
+  for (var _i = 0, _scripts = scripts; _i < _scripts.length; _i++) {
+    var script = _scripts[_i];
+    // Skip any scripts which no longer have a parent.
+    if (!script.parentNode) {
+      continue;
+    }
+
+    // Create a new script node which will be clone.
+    var clone = document.createElement('script');
+
+    // Copy the attributes into the clone.
+    var attrs = script.attributes;
+    for (var i = 0, n = attrs.length; i < n; ++i) {
+      var _attrs$i = attrs[i],
+        name = _attrs$i.name,
+        value = _attrs$i.value;
+      clone.setAttribute(name, value);
+    }
+
+    // Copy the text content into the clone.
+    clone.textContent = script.textContent;
+
+    // Replace the old script in the parent.
+    script.parentNode.replaceChild(clone, script);
+  }
+}
+
+/**
+ * Handle the default behavior of nodes.
+ */
+export function handleDefaults(node, resolver) {
+  // Handle anchor elements.
+  var anchors = node.getElementsByTagName('a');
+  for (var i = 0; i < anchors.length; i++) {
+    var el = anchors[i];
+    // skip when processing a elements inside svg
+    // which are of type SVGAnimatedString
+    if (!(el instanceof HTMLAnchorElement)) {
+      continue;
+    }
+    var path = el.href;
+    var isLocal = resolver && resolver.isLocal ? resolver.isLocal(path) : URL.isLocal(path);
+    // set target attribute if not already present
+    if (!el.target) {
+      el.target = isLocal ? '_self' : '_blank';
+    }
+    // set rel as 'noopener' for non-local anchors
+    if (!isLocal) {
+      el.rel = 'noopener';
+    }
+  }
+
+  // Handle image elements.
+  var imgs = node.getElementsByTagName('img');
+  for (var _i2 = 0; _i2 < imgs.length; _i2++) {
+    if (!imgs[_i2].alt) {
+      imgs[_i2].alt = 'Image';
+    }
+  }
+}
+
+/**
+ * Resolve the relative urls in element `src` and `href` attributes.
+ *
+ * @param node - The head html element.
+ *
+ * @param resolver - A url resolver.
+ *
+ * @param linkHandler - An optional link handler for nodes.
+ *
+ * @returns a promise fulfilled when the relative urls have been resolved.
+ */
+export function handleUrls(node, resolver, linkHandler) {
+  // Set up an array to collect promises.
+  var promises = [];
+
+  // Handle HTML Elements with src attributes.
+  var nodes = node.querySelectorAll('*[src]');
+  for (var i = 0; i < nodes.length; i++) {
+    promises.push(handleAttr(nodes[i], 'src', resolver));
+  }
+
+  // Handle anchor elements.
+  var anchors = node.getElementsByTagName('a');
+  for (var _i3 = 0; _i3 < anchors.length; _i3++) {
+    promises.push(handleAnchor(anchors[_i3], resolver, linkHandler));
+  }
+
+  // Handle link elements.
+  var links = node.getElementsByTagName('link');
+  for (var _i4 = 0; _i4 < links.length; _i4++) {
+    promises.push(handleAttr(links[_i4], 'href', resolver));
+  }
+
+  // Wait on all promises.
+  return Promise.all(promises).then(function () {
+    return undefined;
+  });
+}
+
+/**
+ * Handle a node with a `src` or `href` attribute.
+ */
+function handleAttr(_x, _x2, _x3) {
+  return _handleAttr.apply(this, arguments);
+}
+/**
+ * Handle an anchor node.
+ */
+function _handleAttr() {
+  _handleAttr = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(node, name, resolver) {
+    var source, isLocal, urlPath, url;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          source = node.getAttribute(name) || '';
+          isLocal = resolver.isLocal ? resolver.isLocal(source) : URL.isLocal(source);
+          if (!(!source || !isLocal)) {
+            _context.next = 4;
+            break;
+          }
+          return _context.abrupt("return");
+        case 4:
+          _context.prev = 4;
+          _context.next = 7;
+          return resolver.resolveUrl(source);
+        case 7:
+          urlPath = _context.sent;
+          _context.next = 10;
+          return resolver.getDownloadUrl(urlPath);
+        case 10:
+          url = _context.sent;
+          if (new URI(url).scheme !== 'data:') {
+            // Bust caching for local src attrs.
+            // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Using_XMLHttpRequest#Bypassing_the_cache
+            url += (/\?/.test(url) ? '&' : '?') + new Date().getTime();
+          }
+          node.setAttribute(name, url);
+          _context.next = 19;
+          break;
+        case 15:
+          _context.prev = 15;
+          _context.t0 = _context["catch"](4);
+          // If there was an error getting the url,
+          // just make it an empty link and report the error.
+          node.setAttribute(name, '');
+          throw _context.t0;
+        case 19:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[4, 15]]);
+  }));
+  return _handleAttr.apply(this, arguments);
+}
+function handleAnchor(anchor, resolver, linkHandler) {
+  // Get the link path without the location prepended.
+  // (e.g. "./foo.md#Header 1" vs "http://localhost:8888/foo.md#Header 1")
+  var href = anchor.getAttribute('href') || '';
+  var isLocal = resolver.isLocal ? resolver.isLocal(href) : URL.isLocal(href);
+  // Bail if it is not a file-like url.
+  if (!href || !isLocal) {
+    return Promise.resolve(undefined);
+  }
+  // Remove the hash until we can handle it.
+  var hash = anchor.hash;
+  if (hash) {
+    // Handle internal link in the file.
+    if (hash === href) {
+      anchor.target = '_self';
+      return Promise.resolve(undefined);
+    }
+    // For external links, remove the hash until we have hash handling.
+    href = href.replace(hash, '');
+  }
+  // Get the appropriate file path.
+  return resolver.resolveUrl(href).then(function (urlPath) {
+    // decode encoded url from url to api path
+    var path = decodeURIComponent(urlPath);
+    // Handle the click override.
+    if (linkHandler) {
+      linkHandler.handleLink(anchor, path, hash);
+    }
+    // Get the appropriate file download path.
+    return resolver.getDownloadUrl(urlPath);
+  }).then(function (url) {
+    // Set the visible anchor.
+    anchor.href = url + hash;
+    return;
+  }).catch(function () {
+    // If there was an error getting the url,
+    // just make it an empty link.
+    anchor.href = '';
+  });
+}
+
+/**
+ * Create a normalized id for a header element.
+ *
+ * @param header Header element
+ * @returns Normalized id
+ */
+export function createHeaderId(header) {
+  var _header$textContent;
+  return ((_header$textContent = header.textContent) !== null && _header$textContent !== void 0 ? _header$textContent : '').replace(/ /g, '-');
+}
+
+/**
+ * Apply ids to headers.
+ */
+// export function headerAnchors(node: HTMLElement): void {
+//   const headerNames = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'];
+//   for (const headerType of headerNames) {
+//     const headers = node.getElementsByTagName(headerType);
+//     for (let i = 0; i < headers.length; i++) {
+//       const header = headers[i];
+//       header.id = createHeaderId(header);
+//       const anchor = document.createElement('a');
+//       anchor.target = '_self';
+//       anchor.textContent = '¶';
+//       anchor.href = '#' + header.id;
+//       anchor.classList.add('libro-InternalAnchorLink');
+//       header.appendChild(anchor);
+//     }
+//   }
+// }
+// export function sessionConnection(
+//   s: Session.ISessionConnection | ISessionContext,
+// ): Session.ISessionConnection | null {
+//   return (s as any).sessionChanged
+//     ? (s as ISessionContext).session
+//     : (s as Session.ISessionConnection);
+// }

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@difizen/libro-rendermime",
+  "version": "0.0.2-alpha.0",
+  "description": "",
+  "keywords": [
+    "libro",
+    "notebook"
+  ],
+  "repository": "git@github.com:difizen/libro.git",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "typings": "./es/index.d.ts",
+      "default": "./es/index.js"
+    },
+    "./mock": {
+      "typings": "./es/mock/index.d.ts",
+      "default": "./es/mock/index.js"
+    },
+    "./es/mock": {
+      "typings": "./es/mock/index.d.ts",
+      "default": "./es/mock/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "es/index.js",
+  "module": "es/index.js",
+  "typings": "es/index.d.ts",
+  "files": [
+    "es",
+    "src"
+  ],
+  "dependencies": {
+    "@difizen/libro-common": "^0.0.2-alpha.0",
+    "@difizen/libro-core": "^0.0.2-alpha.0",
+    "@difizen/libro-markdown": "^0.0.2-alpha.0",
+    "@difizen/mana-app": "alpha",
+    "lodash.escape": "^4.0.1"
+  },
+  "peerDependencies": {
+    "react": "^18.2.0"
+  },
+  "devDependencies": {
+    "@types/lodash.escape": "^4.0.7",
+    "@types/react": "^18.2.25"
+  },
+  "scripts": {
+    "setup": "father build",
+    "build": "father build",
+    "test": ": Note: lint task is delegated to test:* scripts",
+    "test:vitest": "vitest run",
+    "test:jest": "jest",
+    "coverage": ": Note: lint task is delegated to coverage:* scripts",
+    "coverage:vitest": "vitest run --coverage",
+    "coverage:jest": "jest --coverage",
+    "lint": ": Note: lint task is delegated to lint:* scripts",
+    "lint:eslint": "eslint src",
+    "lint:tsc": "tsc --noEmit"
+  }
+}