@aj-shadow/z-abs-complayer-markup-client 0.0.0-aj-beta.221

package/project/client/markup/markup-documentation/markup-documentation-local-note.js

@@ -0,0 +1,33 @@
+
+'use strict';
+
+import GuidGenerator from 'z-abs-corelayer-cs/clientServer/guid-generator';
+
+
+class MarkupDocumentationLocalNote {
+  constructor() {
+    this.key = 'NOTE';
+    this.type = 'markup_local_note';
+  }
+  
+  stringify(dataLocalNote) {
+    return `${this.key}={"guid":"${dataLocalNote.guid}"}`;
+  }
+  
+  parse(markup) {
+    let dataLocalNote = null;
+    try {
+      dataLocalNote = JSON.parse(markup);
+    } 
+    catch(err) {}
+    if(dataLocalNote && dataLocalNote.guid) {
+      return dataLocalNote;
+    }
+    return {
+      guid: GuidGenerator.create()
+    };
+  }
+}
+
+
+module.exports = new MarkupDocumentationLocalNote() ;

package/project/client/markup/markup-documentation/markup-documentation-navigation.js

@@ -0,0 +1,109 @@
+
+'use strict';
+
+const DataDocumentationNavigation = require('../../data/data-documentation/data-documentation-navigation');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupDocumentationNavigation {
+  stringify(navigations) {
+    this._handleStacks(navigations);
+    const navigation = navigations.map((navigation) => {
+      let nameLength = 0;
+      let linkLength = 0;
+      navigation.refs.forEach((ref) => {
+        nameLength = Math.max(nameLength, ref.name.length);
+        linkLength = Math.max(linkLength, ref.link.length);
+      });
+      const headingLength = Math.max(nameLength + linkLength + 1, navigation.heading.length);
+      const head = `|${navigation.heading}${' '.repeat(headingLength - navigation.heading.length)}|`;
+      const rows = navigation.refs.map((ref) => {
+        return `|${ref.name}${' '.repeat(nameLength - ref.name.length)}|${ref.link}${' '.repeat(linkLength - ref.link.length)}|`;
+      });
+      return `${head}\n${rows.join('\n')}`
+    });
+    return `${navigation.join('\n\n')}`;
+  }
+  
+  parse(markup) {
+    const objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    const navigations = [];
+    const uniqueLinks = new Map();
+    let result = true;
+    objectTables.objects.forEach((objectTable) => {
+      if(1 <= objectTable.length) {
+        let heading;
+        if(1 === objectTable[0].columns.length) {
+          heading = objectTable[0].columns[0];
+        }
+        else {
+          return;
+        }
+        const navigation = {
+          heading: heading,
+          refs: []
+        };
+        navigations.push(navigation);
+        if(2 <= objectTable.length) {
+          for(let i = 1; i < objectTable.length; ++i) {
+            if(2 === objectTable[i].columns.length) {
+              const link = objectTable[i].columns[1];
+              if(uniqueLinks.has(link)) {
+                result = false;
+                objectTables.rows.forEach((row) => {
+                  if(2 === row.columns.length) {
+                    if(link === row.columns[1]) {
+                      row.success = false;
+                    }
+                  }
+                });
+              }
+              else {
+                uniqueLinks.set(link);
+              }
+              navigation.refs.push({
+                name: objectTable[i].columns[0],
+                link: link
+              });
+            }
+          }
+        }
+      }
+    });
+    if(result) {
+      return {
+        success: true,
+        navigations: navigations
+      };
+    }
+    else {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+  }
+  
+  _handleStacks(navigations) {
+    navigations.findIndex((navigation) => {
+      const refIndex = navigation.refs.findIndex((ref) => {
+        return null !== ref.link.match(/^\[\[stack\-[a-z-]+\]\]/);
+      });
+      if(-1 !== refIndex) {
+        navigation.refs = [{
+          name: '[[stack]]',
+          link: ''
+        }];
+      }
+    });
+  }
+}
+
+module.exports = new MarkupDocumentationNavigation();

package/project/client/markup/markup-documentation/markup-documentation-page.js

@@ -0,0 +1,262 @@
+
+'use strict';
+
+const MarkupChartLine = require('../markup-chart/markup-chart-line');
+const MarkupDocumentationAnchor = require('./markup-documentation-anchor');
+const MarkupDocumentationCode = require('./markup-documentation-code');
+const MarkupSequenceDiagram = require('../markup-sequence-diagram');
+const MarkupLab = require('../markup-lab');
+const MarkupFlowchart = require('../markup-flowchart');
+const MarkupNodeDiagram = require('../markup-node-diagram');
+const MarkupDocumentationApiStatus = require('./markup-documentation-api-status');
+const MarkupDocumentationDiv = require('./markup-documentation-div');
+const MarkupDocumentationStatus = require('./markup-documentation-documentation-status');
+const MarkupDocumentationEmbed = require('./markup-documentation-embed');
+const MarkupDocumentationIe = require('./markup-documentation-ie');
+const MarkupDocumentationRef = require('./markup-documentation-ref');
+const MarkupDocumentationResult = require('./markup-documentation-result');
+const MarkupDocumentationHtml = require('./markup-documentation-html');
+const MarkupDocumentationImage = require('./markup-documentation-image');
+const MarkupDocumentationLab = require('./markup-documentation-lab');
+const MarkupDocumentationLocalNote  = require('./markup-documentation-local-note');
+const MarkupDocumentationStateMachine = require('./markup-documentation-state-machine');
+const MarkupTable = require('../markup-table');
+const MarkupTestCase = require('../markup-test-case/markup-test-case');
+const MarkupTestSuite = require('../markup-test-suite/markup-test-suite');
+
+
+class MarkupDocumentationPage {
+  constructor() {
+    this.markups = new Map();
+    this.markupKeySimples = new Map();
+    this.markupTypeSimples = new Map();
+    this._addSimple(MarkupDocumentationApiStatus);
+    this._addSimple(MarkupDocumentationLocalNote);
+    this._addSimple(MarkupDocumentationAnchor);
+    this._addSimple(MarkupDocumentationStatus);
+    this._addSimple(MarkupDocumentationEmbed);
+    this._addSimple(MarkupDocumentationIe);
+    this._addSimple(MarkupDocumentationRef);
+    this._addSimple(MarkupDocumentationResult);
+    this._addSimple(MarkupDocumentationDiv);
+    this._addSimple(MarkupDocumentationImage);
+    this.markupTypeComplex = [];
+    this._addComplex(MarkupChartLine);
+    this._addComplex(MarkupDocumentationCode);
+    this._addComplex(MarkupFlowchart);
+    this._addComplex(MarkupDocumentationHtml);
+    this._addComplex(MarkupLab);
+    this._addComplex(MarkupNodeDiagram);
+    this._addComplex(MarkupSequenceDiagram);
+    this._addComplex(MarkupDocumentationStateMachine);
+    this._addComplex(MarkupTable);
+    this._addComplex(MarkupTestCase);
+    this._addComplex(MarkupTestSuite);
+  }
+  
+  stringify(page) {
+    if(undefined !== page) {
+      const stringified = page.map((value) => {
+        if('markup' === value.type) {
+          return value.value;
+        }
+        else if(MarkupDocumentationPage.RAW_NAME === value.type) {
+          return `${MarkupDocumentationPage.RAW_START}${value.value.replace(new RegExp('```', 'g'), '\\`\\`\\`')}${MarkupDocumentationPage.PART}`
+        }
+        else if(MarkupDocumentationPage.ESCAPE_NAME === value.type) {
+          return `${MarkupDocumentationPage.ESCAPE_START}\n${this._removeLastLineBreak(this._escapeStringify(value.value))}\n${MarkupDocumentationPage.PART}`
+        }
+        else {
+          for(let i = 0; i < this.markupTypeComplex.length; ++i) {
+            const markupObject = this.markupTypeComplex[i];
+            const markupName = markupObject.markupName();
+            if(markupName === value.type) {
+              return `${MarkupDocumentationPage.PART}${markupName}\n${markupObject.stringify(value.value, false)}\n${MarkupDocumentationPage.PART}`
+            }
+          }
+          const markupObject = this.markupTypeSimples.get(value.type);
+          if(markupObject) {
+            return `${MarkupDocumentationPage.SIMPLE_START}${markupObject.stringify(value.value)}${MarkupDocumentationPage.SIMPLE_STOP}`;
+          }
+        }
+      });
+      return `${stringified.join('')}`;
+    }
+    else {
+      return '';
+    }
+  }
+  
+  parse(markup) {
+    if(undefined !== markup) {
+      return this._getParse(markup);
+    }
+    else {
+      return [];
+    }
+  }
+  
+  _getParse(markup, fromIndex = 0, searchIndex = 0, foundParts = []) {
+    const indexStart = markup.indexOf(MarkupDocumentationPage.PART, searchIndex);
+    const indexSimpleStart = markup.indexOf(MarkupDocumentationPage.SIMPLE_START, searchIndex);
+    if ((indexStart < indexSimpleStart && -1 !== indexStart) || (-1 !== indexStart && -1 === indexSimpleStart)) {
+      let indexStop = markup.indexOf(MarkupDocumentationPage.PART, indexStart + MarkupDocumentationPage.PART_LENGTH);
+      if(-1 === indexStop) {
+        indexStop = indexStart + MarkupDocumentationPage.PART_LENGTH;
+      }
+      if(markup.substr(indexStart, MarkupDocumentationPage.RAW_LENGTH, indexStop).startsWith(MarkupDocumentationPage.RAW_START)) {
+        if(fromIndex !== indexStart) {
+          this._setParseValue(foundParts, markup, fromIndex, indexStart);
+        }
+        const value = markup.substring(indexStart + MarkupDocumentationPage.RAW_START_LENGTH, indexStop);
+        foundParts.push({
+          type: MarkupDocumentationPage.RAW_NAME,
+          value: value,
+          lines: value.split('\n').length
+        });
+        fromIndex = indexStop + MarkupDocumentationPage.PART_LENGTH;
+        return this._getParse(markup, fromIndex, indexStop + MarkupDocumentationPage.PART_LENGTH, foundParts);
+      }
+      else if(markup.substr(indexStart, MarkupDocumentationPage.ESCAPE_START_LENGTH, indexStop).startsWith(MarkupDocumentationPage.ESCAPE_START)) {
+        if(fromIndex !== indexStart) {
+          this._setParseValue(foundParts, markup, fromIndex, indexStart);
+        }
+        const stringValue = markup.substring(indexStart + MarkupDocumentationPage.ESCAPE_START_LENGTH, indexStop);
+        const value = this._removeFirstLineBreak(this._regExpFixReplace(stringValue));
+        foundParts.push({
+          type: MarkupDocumentationPage.ESCAPE_NAME,
+          value: value,
+          lines: stringValue.split('\n').length
+        });
+        fromIndex = indexStop + MarkupDocumentationPage.PART_LENGTH;
+        return this._getParse(markup, fromIndex, indexStop + MarkupDocumentationPage.PART_LENGTH, foundParts);
+      }
+      else {
+        for(let i = 0; i < this.markupTypeComplex.length; ++i) {
+          const markupObject = this.markupTypeComplex[i];
+          const markupName = markupObject.markupName();
+          const startLength = MarkupDocumentationPage.PART_LENGTH + markupName.length;
+          if(markup.substr(indexStart, startLength).startsWith(MarkupDocumentationPage.PART + markupName)) {
+            if(fromIndex !== indexStart) {
+              this._setParseValue(foundParts, markup, fromIndex, indexStart);
+            }
+            const linesValue = markup.substring(indexStart, indexStop + MarkupDocumentationPage.PART_LENGTH);
+            const stringValue = markup.substring(indexStart + startLength + 1, indexStop - 1);
+            const value = markupObject.parse(stringValue);
+            foundParts.push({
+              type: markupName,
+              value: value,
+              lines: linesValue.split('\n').length
+            });
+            fromIndex = indexStop + MarkupDocumentationPage.PART_LENGTH;
+            return this._getParse(markup, fromIndex, indexStop + MarkupDocumentationPage.PART_LENGTH, foundParts);
+          }
+        }
+      }
+      return this._getParse(markup, fromIndex, indexStop + MarkupDocumentationPage.PART_LENGTH, foundParts);
+    }
+    else if ((indexSimpleStart < indexStart && -1 !== indexSimpleStart) || (-1 !== indexSimpleStart && -1 === indexStart)) {
+      let indexSimpleStop = markup.indexOf(MarkupDocumentationPage.SIMPLE_STOP, indexSimpleStart + MarkupDocumentationPage.SIMPLE_START_LENGTH);
+      let simple = markup.substring(indexSimpleStart + MarkupDocumentationPage.SIMPLE_START_LENGTH, indexSimpleStop);
+      let simpleKeyStopIndex = simple.indexOf('=');
+      let key = simple;
+      let json = '';
+      if(-1 !== simpleKeyStopIndex) {
+        key = simple.substring(0, simpleKeyStopIndex);
+        json = simple.substring(simpleKeyStopIndex + 1);
+      }
+      let markupObject = this.markupKeySimples.get(key);
+      if(markupObject) {
+        if(fromIndex !== indexSimpleStart) {
+          this._setParseValue(foundParts, markup, fromIndex, indexSimpleStart);
+        }
+        foundParts.push({
+          type: markupObject.type,
+          value: markupObject.parse(json, indexSimpleStop),
+          lines: 1
+        });
+        fromIndex = indexSimpleStop + MarkupDocumentationPage.SIMPLE_STOP_LENGTH;
+        return this._getParse(markup, fromIndex, fromIndex, foundParts);
+      }
+      return this._getParse(markup, fromIndex, indexSimpleStart + MarkupDocumentationPage.SIMPLE_START_LENGTH, foundParts);
+    }
+    else {
+      this._setParseValue(foundParts, markup, fromIndex);
+      return foundParts;
+    }
+  }
+  
+  _setParseValue(foundParts, markup, start, stop) {
+    const value = markup.substring(start, stop);
+    if(0 !== value.length) {
+      foundParts.push({
+        type: 'markup',
+        value: value,
+        lines: value.split('\n').length
+      });
+    }
+  }
+  
+  _regExpFixReplace(s, start = 0) {
+    let index = s.indexOf('\\`\\`\\`');
+    if(-1 == index) {
+      return s;
+    }
+    return this._regExpFixReplace(`${s.substr(0, index)}\`\`\`${s.substring(index + 6)}`, index + 6 + 1);
+  }
+  
+  _escapeStringify(s, start=0) {
+    let index = s.indexOf('```');
+    if(-1 == index) {
+      return s;
+    }
+    return this._escapeStringify(`${s.substr(0, index)}\\\`\\\`\\\`${s.substring(index + 3)}`, index + 3 + 1);
+  }
+  
+  _removeFirstLineBreak(s) {
+    if(s.startsWith('\n')) {
+      return s.substring(1);
+    }
+    else {
+      return s;
+    }
+  }
+  
+  _removeLastLineBreak(s) {
+    if(s.endsWith('\n')) {
+      return s.substring(0, s.length - 1);
+    }
+    else {
+      return s;
+    }
+  }
+  
+  _addSimple(markupObject) {
+    this.markupKeySimples.set(markupObject.key, markupObject);
+    this.markupTypeSimples.set(markupObject.type, markupObject);
+  }
+  
+  _addComplex(markupObject) {
+    this.markupTypeComplex.push(markupObject);
+  }
+}
+
+MarkupDocumentationPage.PART = '```';
+MarkupDocumentationPage.PART_LENGTH = MarkupDocumentationPage.PART.length;
+
+MarkupDocumentationPage.SIMPLE_START = '[[';
+MarkupDocumentationPage.SIMPLE_START_LENGTH = MarkupDocumentationPage.SIMPLE_START.length;
+
+MarkupDocumentationPage.SIMPLE_STOP = ']]';
+MarkupDocumentationPage.SIMPLE_STOP_LENGTH = MarkupDocumentationPage.SIMPLE_STOP.length;
+
+MarkupDocumentationPage.RAW_NAME = 'raw';
+MarkupDocumentationPage.RAW_START = MarkupDocumentationPage.PART + MarkupDocumentationPage.RAW_NAME;
+MarkupDocumentationPage.RAW_START_LENGTH = MarkupDocumentationPage.RAW_START.length;
+
+MarkupDocumentationPage.ESCAPE_NAME = 'escape';
+MarkupDocumentationPage.ESCAPE_START = MarkupDocumentationPage.PART + MarkupDocumentationPage.ESCAPE_NAME;
+MarkupDocumentationPage.ESCAPE_START_LENGTH = MarkupDocumentationPage.ESCAPE_START.length;
+
+
+module.exports = new MarkupDocumentationPage();

package/project/client/markup/markup-documentation/markup-documentation-ref.js

@@ -0,0 +1,28 @@
+
+'use strict';
+
+
+class MarkupDocumentationRef {
+  constructor() {
+    this.key = 'REF';
+    this.type = 'markup_ref';
+  }
+  
+  stringify(dataRef) {
+    return `${this.key}=${dataRef.text}, ${dataRef.refName}`;
+  }
+  
+  parse(markup) {
+    const parameters = markup.split(',');
+    parameters.forEach((parameter, index) => {
+      parameters[index] = parameter.trim();
+    });
+    return {
+      text: 1 <= parameters.length ? parameters[0] : 'Unknown',
+      refName: 2 <= parameters.length ? parameters[1] : 'Unknown'
+    };
+  }
+}
+
+
+module.exports = new MarkupDocumentationRef() ;

package/project/client/markup/markup-documentation/markup-documentation-result.js

@@ -0,0 +1,21 @@
+
+'use strict';
+
+
+class MarkupDocumentationResult {
+  constructor() {
+    this.key = 'RESULT';
+    this.type = 'markup_result';
+  }
+  
+  stringify(dataResult) {
+    return `${this.key}=${dataResult}`;
+  }
+  
+  parse(markup) {
+    return markup;
+  }
+}
+
+
+module.exports = new MarkupDocumentationResult() ;

package/project/client/markup/markup-documentation/markup-documentation-state-machine.js

@@ -0,0 +1,194 @@
+
+'use strict';
+
+const MarkupParseHelper = require('../markup-parse-helper');
+const DataStateMachineDiagramConfig = require('../../data/data-state-machine/data-state-machine-config');
+const DataStateMachine = require('../../data/data-state-machine/data-state-machine');
+const DataStateMachineState = require('../../data/data-state-machine/data-state-machine-state');
+const DataStateMachineTransition = require('../../data/data-state-machine/data-state-machine-transition');
+const MarkupPatternConfig = require('../markup-pattern-config');
+
+
+class MarkupDocumentationStateMachine {
+  markupName() {
+    return 'state';
+  }
+  
+  stringify(stateMachine) {
+    let stringified = '';
+    if('' !== stateMachine.title) {
+      stringified += `${MarkupDocumentationStateMachine.TAG_TITLE}${stateMachine.title}\n`;
+    }
+    stringified += MarkupPatternConfig.stringify(stateMachine.dataStateMachineDiagramConfig);
+    if(1 <= stateMachine.stateRows.length) {
+      for(let i = 0; i < stateMachine.stateRows.length; ++i) {
+        if(stateMachine.stateRows[i][0].comment) {
+          stringified += '// ';
+        }
+        stringified += 'States[';
+        const firstState = stateMachine.stateRows[i][0];
+        stringified += firstState.name;
+         for(let j = 1; j < stateMachine.stateRows[i].length; ++j) {
+          const block = stateMachine.stateRows[i][j];
+          stringified += `, ${block.name}`;
+        }
+        stringified += ']\n';
+      }
+    }
+    else {
+      stringified += 'States[]';
+    }
+    for(let i = 0; i < stateMachine.transitions.length; ++i) {
+      const transition = stateMachine.transitions[i];
+      if(-1 !== transition.fromXIndex && -1 !== transition.fromYIndex && -1 !== transition.toXIndex && -1 !== transition.toYIndex) {
+        const fromState = this._getStateFromName(stateMachine, transition.fromStateName);
+        const toState = this._getStateFromName(stateMachine, transition.toStateName);
+        if(null !== fromState && null !== toState) {
+          stringified += '\n';
+          if(transition.comment) {
+            stringified += '// ';
+          }
+          stringified += `${fromState.name} ${this._stringifyTransitionType(transition)} ${toState.name}[${transition.type}]: ${transition.data}`;
+          continue;
+        }
+      }
+      stringified += `\n${transition.data}`
+    }
+    return stringified;
+  }
+  
+  parse(markup) {
+    let rows = MarkupParseHelper.getRows(markup);
+    let dataStateMachine = new DataStateMachine();
+    rows.forEach((row) => {
+      this._parseRow(dataStateMachine, row);
+    });
+    return dataStateMachine;
+  }
+  
+  _parseRow(dataStateMachine, row, comment = false) {
+    const trimRow = row.trim();
+    if(trimRow.startsWith('//')) {
+      this._parseRow(dataStateMachine, trimRow.substring(2), true);
+    }
+    else if(trimRow.startsWith(MarkupDocumentationStateMachine.TAG_TITLE)) {
+      dataStateMachine.setTitle(trimRow.substr(MarkupDocumentationStateMachine.TAG_TITLE_LENGTH));
+    }
+    else if(trimRow.startsWith('States')) {
+      let index = 0;
+      while(true) {
+        const start = trimRow.indexOf('[', index);
+        if(-1 === start) {
+          break;
+        }
+        const stop = trimRow.indexOf(']', start + 1);
+        const stateNames = trimRow.substring(start + 1, -1 !== stop ? stop : undefined).split(',');
+        if(null !== stateNames) {
+          dataStateMachine.addStateRow();
+          stateNames.forEach((stateName) => {
+            let trimState = '';
+            if(stateName.startsWith(',') && stateName.endsWith(',')) {
+              trimState = stateName.substring(1, stateName.length - 1).trim();
+            }
+            else {
+              trimState = stateName.trim();
+            }
+            dataStateMachine.addState(new DataStateMachineState(trimState, comment));
+          });
+        }
+        if(-1 === stop) {
+          break;
+        }
+        else {
+          index = stop;
+        }
+      }
+    }
+    else if(trimRow.startsWith('Config')) {
+      MarkupPatternConfig.parse(trimRow, dataStateMachine);
+    }
+    else {
+      let type = 'normal';
+      let data = '';
+      let typeStartIndex = trimRow.indexOf('[');
+      let typeStopIndex = trimRow.indexOf(']');
+      if(-1 !== typeStartIndex && -1 !== typeStopIndex) {
+        let types = trimRow.slice(typeStartIndex + 1, typeStopIndex).match(/([^\s,]+)/g);
+        if(types && 1 === types.length) {
+          type = types[0];
+        }
+      }
+      let dataIndex = trimRow.indexOf(':');
+      if(-1 !== dataIndex) {
+        data = trimRow.substring(dataIndex + 1, trimRow.length).trim();
+      }
+      let transitionTypeIndex = this._parseTransitionTypeIndex(trimRow);
+      if(-1 !== transitionTypeIndex) {
+        const transitionType = this._parseTransitionType(trimRow, transitionTypeIndex);
+        const from = trimRow.substring(0, transitionTypeIndex).trim();
+        const to = trimRow.substring(transitionTypeIndex + transitionType.size, typeStartIndex).trim();
+        const fromState = this._getStateFromName(dataStateMachine, from);
+        const toState = this._getStateFromName(dataStateMachine, to);
+        if(null !== fromState && null !== toState) {
+          dataStateMachine.addTransition(new DataStateMachineTransition(data, type, transitionType.type, fromState, toState, comment));
+        }
+        /*else if(-1 !== fromIndex) {
+          dataStateMachine.addTransition(new DataStateMachineTransition(trimRow, type, transitionType.type, fromState, toState));
+        }*/
+      }
+    }
+  }
+  
+  _stringifyTransitionType(transition) {
+    if('simplex' === transition.transitionType) {
+      return '->';
+    }
+    else if('duplex' === transition.transitionType) {
+      return '<->';
+    }
+  }
+  
+  _parseTransitionTypeIndex(row) {
+    let index = row.indexOf('<->');
+    if(-1 !== index) {
+      return index;
+    }
+    index = row.indexOf('->');
+    if(-1 !== index) {
+      return index;
+    }
+    return -1;
+  }
+  
+  _parseTransitionType(row, index) {
+    if('->' === row.substr(index, 2)) {
+      return {
+        type: 'simplex',
+        size: 2
+      };
+    }
+    else if('<->' === row.substr(index, 3)) {
+      return {
+        type: 'duplex',
+        size: 3
+      };
+    }
+    return '';
+  }
+  
+  _getStateFromName(dataStateMachine, stateName) {
+    for(let i = 0; i < dataStateMachine.stateRows.length; ++i) {
+      for(let j = 0; j < dataStateMachine.stateRows[i].length; ++j) {
+        if(dataStateMachine.stateRows[i][j].name === stateName) {
+          return dataStateMachine.stateRows[i][j];
+        }
+      }
+    }
+    return null;
+  }
+}
+
+MarkupDocumentationStateMachine.TAG_TITLE = 'Title: ';
+MarkupDocumentationStateMachine.TAG_TITLE_LENGTH = MarkupDocumentationStateMachine.TAG_TITLE.length;
+
+module.exports = new MarkupDocumentationStateMachine();