Generate the internal widget markup
@param {aria.templates.MarkupWriter} out
@protected
348732
function (out) {
            var textContent = this._cfg.text;
            // String cast
            if (textContent !== null) {
                textContent = '' + textContent;
            } else {
                textContent = '';
            }
            this.textContent = textContent;
            out.write('<span class="createdEllipisElement">' + ariaUtilsString.escapeHTML(this.textContent)
                    + "</span>");
        }
702001
function (out) {
            var cfg = this._cfg, cssPrefix = this._cssPrefix; // sclass = cfg.sclass
            out.write(['</span></td>', '<td class="', cssPrefix, 'rs ', cssPrefix, 'bkgC"></td>', '</tr>', '<tr>',
                    '<td class="', cssPrefix, 'blc ', cssPrefix, 'bkgA"></td>', '<td class="', cssPrefix, 'bs ',
                    cssPrefix, 'bkgB">', this.__addFrameIcon(cfg, cssPrefix, 'bottom'), '</td>', '<td class="',
                    cssPrefix, 'brc ', cssPrefix, 'bkgA"></td>', '</tr>', '</tbody></table>'].join(''));

        }
175996
function (out) {
            out.write("<div class=\"" + this.CSS_CLASS + "\">");

            if (this._cfg.contentMacro) {
                out.callMacro(this._cfg.contentMacro);
            }

            out.write("</div>");
        }
558429
function (out) {
            var cfg = this._cfg, cssPrefix = this._cssPrefix; // , state = cfg.stateObject;
            var frameContainerClass = (cfg.block !== true) ? ' ' : 'class="xBlock"';
            var sizeInfo = {
                style : '',
                /*
                 * TODO: the CSS class cssClass should not define any padding, margin or border for the frame to be
                 * correctly displayed
                 */
                className : 'xFrameContent ' + cssPrefix + 'c ' + cfg.cssClass
            };
            this._appendInnerSizeInfo(sizeInfo);
            var displayInline = "";

            if (this._inlineBlock) {
                displayInline = "vertical-align: middle;display: inline";
                displayInline += (ariaCoreBrowser.isIE7) ? ";zoom:1" : "-block;";
            }

            out.write(['<table cellspacing="0" cellpadding="0" style="position: relative;' + displayInline + '"',
                    frameContainerClass, '><tbody isFrame="1">', '<tr>', '<td class="', cssPrefix, 'tlc ', cssPrefix,
                    'bkgA"></td>', '<td class="', cssPrefix, 'ts ', cssPrefix,
                    'bkgB">' + this.__addFrameIcon(cfg, cssPrefix, 'top') + '</td>', '<td class="', cssPrefix, 'trc ',
                    cssPrefix, 'bkgA"></td>', '</tr>', '<tr>', '<td class="', cssPrefix, 'ls ', cssPrefix,
                    'bkgC"></td>', '<td class="', cssPrefix, 'm">', '<span ',
                    Aria.testMode && this._baseId ? ' id="' + this._baseId + '"' : '',
                    (sizeInfo.style ? 'style="' + sizeInfo.style + '"' : ''), ' class="', sizeInfo.className, '">'].join(''));
        }
356572
def write out, indent=-1
      out << '<!ENTITY '
      out << '% ' if @reference
      out << @name
      out << ' '
      if @external
        out << @external << ' '
        if @pubid
          q = @pubid.include?('"')?"'":'"'
          out << q << @pubid << q << ' '
        end
        q = @ref.include?('"')?"'":'"'
        out << q << @ref << q
        out << ' NDATA ' << @ndata if @ndata
      else
        q = @value.include?('"')?"'":'"'
        out << q << @value << q
      end
      out << '>'
    end
1001434
function (out, statement) {
                    var ifstruct = statement.parent;
                    if (ifstruct.name != "if") {
                        return out.logError(statement, statementsSingleton.ELSE_WITHOUT_IF);
                    } else if (ifstruct[Aria.FRAMEWORK_PREFIX + "elsepresent"]) {
                        return out.logError(statement, statementsSingleton.ELSE_ALREADY_USED);
                    }
                    ifstruct[Aria.FRAMEWORK_PREFIX + "elsepresent"] = true;
                    out.decreaseIndent();
                    out.writeln("} else {");
                    out.increaseIndent();
                }
268126
function (out) {
            var skinObj = this._skinObj, cfg = this._cfg;
            out.write(['<div class="x', this._skinnableClass, '_', cfg.sclass, '" style="float:left;position:relative',
                    skinObj.border ? ';border:' + skinObj.border : '',
                    skinObj.borderPadding ? ';padding:' + skinObj.borderPadding + 'px' : '', ';height:',
                    skinObj.sprHeight, 'px;width:', cfg.gaugeWidth, 'px;">'].join(""));
        }
454294
function (out) {
            var oSelf = this;
            ariaUtilsArray.forEach(this._iconsLeft, function (value) {
                oSelf._writeIcon(value, out);
            });
            this._frame.writeMarkupBegin(out);
        }
1277049
function _renderMarkdown( htmlDoc ) {
    const replacements = {};

    // First turn all outputs into text so *<span class="or-output></span>* can be detected
    htmlDoc.find( '/root/form//span[contains(@class, "or-output")]' ).forEach( ( el, index ) => {
        const key = `---output-${index}`;
        const textNode = el.childNodes()[ 0 ].clone();
        replacements[ key ] = el.toString();
        textNode.text( key );
        el.replace( textNode );
        // Note that we end up in a situation where we likely have sibling text nodes...
    } );

    // Now render markdown
    htmlDoc.find( '/root/form//span[contains(@class, "question-label") or contains(@class, "or-hint")]' ).forEach( ( el, index ) => {
        let key;
        /**
         * Using text() is done because:
         * a) We are certain that these <span>s do not contain other elements, other than formatting/markdown <span>s.
         * b) This avoids the need to merge any sibling text nodes that could have been created in the previous step.
         *
         * Note that text() will convert &gt; to >
         */
        const original = el.text().replace( '<', '&lt;' ).replace( '>', '&gt;' );
        const rendered = markdown.toHtml( original );
        if ( original !== rendered ) {
            key = `$$$${index}`;
            replacements[ key ] = rendered;
            el.text( key );
        }
    } );

    // TODO: does this result in self-closing tags?
    let htmlStr = _docToString( htmlDoc );

    // Now replace the placeholders with the rendered HTML
    // in reverse order so outputs are done last
    Object.keys( replacements ).reverse().forEach( key => {
        const replacement = replacements[ key ];
        if ( replacement ) {
            htmlStr = htmlStr.replace( key, replacement );
        }
    } );

    return htmlStr;
}
496655
function getOuterHTML (el) {
  if (el.outerHTML) {
    return el.outerHTML
  } else {
    const container = document.createElement('div');
    container.appendChild(el.cloneNode(true));
    return container.innerHTML
  }
}
580834
function (out) {
            this._out = out;
            var macrolibs = this._macrolibs || [];
            for (var i = 0, l = macrolibs.length; i < l; i++) {
                macrolibs[i]._setOut(out);
            }
        }
1270854
function Widget(options) {
  this.__data = {};
  try {
    var e;
    if (typeof options === 'undefined') options = {};
    if (typeof options.innerHTML !== 'undefined' && typeof options.childNodes !== 'undefined') {
      // On passe directement un élément.
      options = {element: options};
    }
    if (typeof options.tag === 'undefined') options.tag = "div";
    if (options.element) {
      this.element(options.element);
    } else if (typeof options.id !== 'undefined') {
      e = window.document.getElementById(options.id);
      if (!e) {
        throw Error("Can't find element with id: \"" + options.id + "\"!");
      }
      this.element(e);
    } else {
      this.element(window.document.createElement(options.tag));
      this.addClass("wdg", "custom");
    }
  }
  catch (ex) {
    console.error("[widget] ", ex);
    console.error("[Widget] ", JSON.stringify(options));
    throw Error(ex);
  }
}
1022751
function OutputView(outputData, outputTerminal) {
  this.outputData = outputData;
  this.outputTerminal = outputTerminal;

  this.url = util.createUrlLookup(module);

  // Elements attached to this by template().
  this.elems = {
    rowin: null,
    rowout: null,
    hide: null,
    show: null,
    duration: null,
    throb: null,
    prompt: null
  };

  var template = this.outputTerminal.template.cloneNode(true);
  domtemplate.template(template, this, this.outputTerminal.templateOptions);

  this.outputTerminal.element.appendChild(this.elems.rowin);
  this.outputTerminal.element.appendChild(this.elems.rowout);

  this.outputData.onClose.add(this.closed, this);
  this.outputData.onChange.add(this.changed, this);
}
613854
function () {
                this.$InputElement.initWidget.call(this);

                var bindings = this._cfg.bind;
                if (bindings.checked) {
                    var newValue = this._transform(bindings.checked.transform, bindings.checked.inside[bindings.checked.to], "toWidget");
                    if (newValue != null) {
                        this._domElt.checked = newValue;
                    }
                } else {
                    this.$logWarn(this.BINDING_NEEDED, [this.$class, "checked"]);
                }
            }
1157359
function (cfg, ctxt) {
        this._setAutomaticBindings(cfg);
        this.$Widget.constructor.apply(this, arguments);
        /**
         * 1 Minimum width in px that must be kept for the input markup To be overridden by sub-classes
         * @type Number
         * @protected
         */
        this._minInputMarkupWidth = 5;

        /**
         * Default value to assign to _inputMarkupWidth if no constraint apply
         * @type Number
         * @protected
         */
        this._defaultInputMarkupWidth = -1;

        /**
         * The amount of padding that should be put between the label and the field if the labelPos is left or right
         * @type Number
         * @protected
         */
        this._labelPadding = 2;

        /**
         * Maximum size to assign to the width of the input if the value passed is too big
         * @type Number
         * @protected
         */
        this._maxInputMarkupWidth = -1;

        /**
         * Width of the input.
         * @type Number
         * @protected
         */
        this._inputMarkupWidth = -1;

        /**
         * Label DOM element
         * @type HTMLElement
         * @protected
         */
        this._label = null;

        /**
         * LabelId
         * @type String
         */
        this._labelId = (this._cfg.waiAria && !this._cfg.hideLabel) ? this._createDynamicId() : null;

        /**
         * Flag for input that has to be displayed in full width
         * @type Boolean
         * @protected
         */
        this._fullWidth = false;

        /**
         * Height of the label.
         * @type Number
         * @protected
         */
        this._inputMarkupHeight = -1;

        /**
         * @type Boolean
         * @private
         */
        this._isIE7OrLess = ariaCoreBrowser.isOldIE && ariaCoreBrowser.majorVersion < 8;
    }
336898
function (out) {
            // --------------------------------------------------- destructuring

            var cfg = this._cfg;

            var waiAria = cfg.waiAria;
            var waiTitleTag = cfg.waiTitleTag;

            // ------------------------------------------------------ processing

            if (waiAria) {
                out.write('</a>');
                if (waiTitleTag) {
                    out.write('</' + waiTitleTag + '>');
                }
            }

            this._frame.writeMarkupEnd(out);
        }
1239764
function( editor ) {
			var genericDefinition = CKEDITOR.plugins.indent.genericDefinition;

			// Register generic commands.
			setupGenericListeners( editor, editor.addCommand( 'indent', new genericDefinition( true ) ) );
			setupGenericListeners( editor, editor.addCommand( 'outdent', new genericDefinition() ) );

			// Create and register toolbar button if possible.
			if ( editor.ui.addButton ) {
				editor.ui.addButton( 'Indent', {
					label: editor.lang.indent.indent,
					command: 'indent',
					directional: true,
					toolbar: 'indent,20'
				} );

				editor.ui.addButton( 'Outdent', {
					label: editor.lang.indent.outdent,
					command: 'outdent',
					directional: true,
					toolbar: 'indent,10'
				} );
			}

			// Register dirChanged listener.
			editor.on( 'dirChanged', function( evt ) {
				var range = editor.createRange(),
					dataNode = evt.data.node;

				range.setStartBefore( dataNode );
				range.setEndAfter( dataNode );

				var walker = new CKEDITOR.dom.walker( range ),
					node;

				while ( ( node = walker.next() ) ) {
					if ( node.type == CKEDITOR.NODE_ELEMENT ) {
						// A child with the defined dir is to be ignored.
						if ( !node.equals( dataNode ) && node.getDirection() ) {
							range.setStartAfter( node );
							walker = new CKEDITOR.dom.walker( range );
							continue;
						}

						// Switch alignment classes.
						var classes = editor.config.indentClasses;
						if ( classes ) {
							var suffix = ( evt.data.dir == 'ltr' ) ? [ '_rtl', '' ] : [ '', '_rtl' ];
							for ( var i = 0; i < classes.length; i++ ) {
								if ( node.hasClass( classes[ i ] + suffix[ 0 ] ) ) {
									node.removeClass( classes[ i ] + suffix[ 0 ] );
									node.addClass( classes[ i ] + suffix[ 1 ] );
								}
							}
						}

						// Switch the margins.
						var marginLeft = node.getStyle( 'margin-right' ),
							marginRight = node.getStyle( 'margin-left' );

						marginLeft ? node.setStyle( 'margin-left', marginLeft ) : node.removeStyle( 'margin-left' );
						marginRight ? node.setStyle( 'margin-right', marginRight ) : node.removeStyle( 'margin-right' );
					}
				}
			} );
		}