`prototype.markup` is rendered by default. Set the `markup` attribute on the model if the default markup is not desirable.
971723
function() {

        var element = this.model;
        var markup = element.get('markup') || element.markup;
        if (!markup) throw new Error('dia.ElementView: markup required');
        if (Array.isArray(markup)) return this.renderJSONMarkup(markup);
        if (typeof markup === 'string') return this.renderStringMarkup(markup);
        throw new Error('dia.ElementView: invalid markup');
    }
990539
def _render(self, template_name, context, renderer=None):
        """"""
        if renderer is None:
            renderer = get_default_renderer()
        return mark_safe(renderer.render(template_name, context))
1036239
function render(val) {
        // This only needs to be done when the user is in preview mode
        if (!$preview.is(":visible")) {
            return;
        }

        if (!val) {
            val = editor.getSession().getValue();
        }
        // Sanitize the content
        val = html_sanitize(val, urlX, idX);

        switch (renderMode) {
        case "plain":
            editor.getSession().setMode(textMode);
            val = val.replace(/\r\n|\r|\n/g, "<br />"); // Newlines
            val = val.replace(/  /g, "&nbsp;&nbsp;"); // Whitespaces
            $('#paper').html("<p></p>" + val);
            $('#import-button').attr("title", strings['import-button-title-plain']);
            $('#export-text').text(strings['export-text-plain']);
            break;

        case "textile":
            editor.getSession().setMode(textileMode);
            $('#paper').html(textile(val));
            $('#import-button').attr("title", strings['import-button-title-textile']);
            $('#export-text').text(strings['export-text-textile']);
            break;

        case "markdown":
            editor.getSession().setMode(markdownMode);
            $('#paper').html(markdownConverter.makeHtml(val));
            $('#import-button').attr("title", strings['import-button-title-markdown']);
            $('#export-text').text(strings['export-text-markdown']);
            break;

        case "latex":
            break;
        }
    }
114379
function(el, attr, val, ieAttr) {
        if (el && el.setAttribute) {
            attr = Y.DOM.CUSTOM_ATTRIBUTES[attr] || attr;
            el.setAttribute(attr, val, ieAttr);
        }
    }
189459
function(value, attr, pattern, model) {
        if (!hasValue(value) || !value.toString().match(defaultPatterns[pattern] || pattern)) {
          return this.format(getMessageKey(this.msgKey, defaultMessages[pattern]) || defaultMessages.inlinePattern, this.formatLabel(attr, model), pattern);
        }
      }
287612
function html(options) {
  return Object.assign(function (context) {
    var defaultOpts = {
      filename: 'index.html',
      template: 'templates/index.html',
      showErrors: false
    };

    // Merge the provided html config into the context
    var html = context.html || defaultOpts;

    /* Warning: Thar be mutation ahead! */
    /* eslint-disable fp/no-mutation */
    context.html = (0, _deepmerge2.default)(html, options, { clone: true });
    /* eslint-enable fp/no-mutation */

    // Return empty config snippet (configuration will be created by the post hook)
    return {};
  }, { post: postConfig });
}
957164
function(element, options) {
        var that = this;
        that.name = NAME;
        that.$ = $(element);

        that.options = $.extend({}, MarkDoc.DEFAULTS, this.$.data(), options);
        that.$.data('originContent', that.$.text());
        that.render();
    }
803575
function Markdown(data = '', options = {}) {

    this.initData = data;
    this.renderTree = null;
    this.html = '';

    this.fullInfo = !!options.fullInfo;
    this.dialect = options.dialect || Markdown.Dialect.DEFAULT;

}
843279
function(markup) {

	var container = document.createElement('div');
	container.innerHTML = markup;

	return new NWTNodeInstance(container.childNodes[0]);
}
479318
function(a){var b;
// the final two arguments are the length, and the entire string itself;
// we don't care about those.
if(arguments.length<7)throw new Error("markup() must be called from String.prototype.replace()");return b=e.apply(null,arguments),'<span class="'+d[b]+'">'+a+"</span>"}
330203
function (markup) {
		var vmlStyle = 'display:inline-block;behavior:url(#default#VML);',
			isIE8 = this.isIE8;

		markup = markup.join('');

		if (isIE8) { // add xmlns and style inline
			markup = markup.replace('/>', ' xmlns="urn:schemas-microsoft-com:vml" />');
			if (markup.indexOf('style="') === -1) {
				markup = markup.replace('/>', ' style="' + vmlStyle + '" />');
			} else {
				markup = markup.replace('style="', 'style="' + vmlStyle);
			}

		} else { // add namespace
			markup = markup.replace('<', '<hcv:');
		}

		return markup;
	}
965742
def render(self, name, value, attrs=None, renderer=None):
        
        context = self.get_context(name, value, attrs)
        return self._render(self.template_name, context, renderer)
240750
function(newModel) {
      var t = this;
      if (newModel) {
        t.model = newModel;
      }
      t.json = t.isBackbone ? t.model.toJSON() : t.model;

      // If a non-object, just print it
      if (typeof t.json !== 'object') {
        t.$el.html('');
        $(t.template.line({name:'value', value:t.json})).appendTo(t.$el);
        return;
      }

      // Re-render if the object elements differ
      var newKeys = _.keys(t.json);
      if (newKeys.length !== t.keys.length || newKeys.length !== _.intersection(t.keys, newKeys).length) {
        return t.render();
      }
      t.keys = newKeys;

      // Set each element
      for (var elemName in t.json) {
        var elem = t.elems[elemName];
        elem.value = t.getElemValue(elemName);
        t.setElemValue(elem);
      }
      return t;
    }
839032
function buildTooltip(markup) {
    element = $compile(markup)(parentScope);
    parentScope.testModel = {};

    parentScope.$apply();
    $material.flushOutstandingAnimations();

    return element;
  }
645862
function (e) {
    if (e.prevValue === e.newValue) { return; }

    var newPag     = e.newValue,
        oldPag     = e.prevValue,
        containers = this._defaultPaginatorContainers();

    if (oldPag) {
        if (oldPag.getContainerNodes()[0] == containers[0]) {
            oldPag.set('containers',[]);
        }
        oldPag.destroy();

        // Convenience: share the default containers if possible.
        // Otherwise, remove the default containers from the DOM.
        if (containers[0]) {
            if (newPag && !newPag.getContainerNodes().length) {
                newPag.set('containers',containers);
            } else {
                // No new Paginator to use existing containers, OR new
                // Paginator has configured containers.
                for (var i = containers.length - 1; i >= 0; --i) {
                    if (containers[i]) {
                        containers[i].parentNode.removeChild(containers[i]);
                    }
                }
            }
        }
    }

    if (!this._bInit) {
        this.render();

    }

    if (newPag) {
        this.renderPaginator();
    }

}
1367450
function () {
      this._super.apply(this, arguments);

      if (!this.elementId) {
        this.elementId = _emberMetalUtils.guidFor(this);
      }

      this.scheduledRevalidation = false;

      this[INIT_WAS_CALLED] = true;

      if (typeof this.didInitAttrs === 'function') {
        _emberMetalDebug.deprecate('[DEPRECATED] didInitAttrs called in ' + this.toString() + '.', false, {
          id: 'ember-views.did-init-attrs',
          until: '3.0.0',
          url: 'http://emberjs.com/deprecations/v2.x#toc_ember-component-didinitattrs'
        });
      }

      _emberMetalDebug.assert('Using a custom `.render` function is no longer supported.', !this.render);
    }
116736
function render() {
  return function(...args) {
    return (
      <PseudoContext.Consumer>
        {value => {
          if (!value) {
            return defaultTextRender.apply(this, args);
          }
          return renderText(args, this);
        }}
      </PseudoContext.Consumer>
    );
  };
}