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

package/project/client/data/data-test-data/data-test-data-system-global.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const DataTableKeyValue = require('../data-table-key-value');
+
+
+class DataTestDataSystemGlobal extends DataTableKeyValue {
+  constructor(name, sut, sutInstance, value, description) {
+    super();
+    this.name = name;
+    this.sut = sut;
+    this.sutInstance = sutInstance;
+    this.value = value;
+    this.description = description;
+  }
+}
+
+module.exports = DataTestDataSystemGlobal;

package/project/client/data/data-test-data/data-test-data-system-local.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const DataTableKeyValue = require('../data-table-key-value');
+
+
+class DataTestDataSystemLocal extends DataTableKeyValue {
+  constructor(name, sut, sutInstance, value, description) {
+    super();
+    this.name = name;
+    this.sut = sut;
+    this.sutInstance = sutInstance;
+    this.value = value;
+    this.description = description;
+  }
+}
+
+module.exports = DataTestDataSystemLocal;

package/project/client/data/data-test-suite/data-test-suite-abstraction.js

@@ -0,0 +1,72 @@
+
+'use strict';
+
+const DataTableKeyValue = require('../data-table-key-value');
+
+
+class DataTestSuiteAbstraction extends DataTableKeyValue {
+  constructor(name, execution, iterationsTs) {
+    super([
+      ['execution', (rowData) => {return 'serial'}],
+      ['iterations', (rowData) => {return 1}]
+    ],
+    [
+      ['execution', (rowData) => {
+        switch(rowData.execution) {
+          case 'serial':
+          case 'parallel':
+            return DataTableKeyValue.ALLOWED_OK;
+          default:
+            return DataTableKeyValue.ALLOWED_NOK_VALUE;
+        }
+      }],
+      ['iterations', (rowData) => {
+        if(Number.isInteger(Number.parseFloat(rowData.iterations)) && rowData.iterations >= 1) {
+          return DataTableKeyValue.ALLOWED_OK;
+        }
+        else {
+          return DataTableKeyValue.ALLOWED_NOK_VALUE;
+        }
+      }]
+    ]);
+    this.name = name;
+    this.execution = execution;
+    this.iterationsTs = iterationsTs;
+    this._commentOut_ = false;
+  }
+  
+  commentOut() {
+    this._commentOut_ = true;
+  }
+  
+  getValue(heading, rowData) {
+    if('name' !== heading) {
+      return super.getValue(heading, rowData);
+    }
+    else {
+      const value = super.getValue(heading, rowData);
+      const paths = value.value.split('.');
+      if(0 === paths.length) {
+        value.link = '/';
+        return value;
+      }
+      let link = '';
+      if('tc' === paths[0]) {
+        link = '/test-cases';
+      }
+      else if('ts' === paths[0]) {
+        link = '/test-suites';
+      }
+      if(1 === paths.length) {
+        value.link = link;
+        return value;
+      }
+      paths.splice(0, 1);
+      link += '/' + paths.join('/');
+      value.link = link;
+      return value;
+    } 
+  }
+}
+
+module.exports = DataTestSuiteAbstraction;

package/project/client/data/data-test-suite/data-test-suite.js

@@ -0,0 +1,15 @@
+
+'use strict';
+
+
+class TestSuite {
+  constructor(abstractions = []) {
+    this.abstractions = abstractions;
+  }
+  
+  addAbstraction(abstraction) {
+    this.abstractions.push(abstraction);
+  }
+}
+
+module.exports = TestSuite;

package/project/client/data/data-tree/data-tree-node.js

@@ -0,0 +1,17 @@
+
+'use strict';
+
+
+class DataTreeNode {
+  constructor(name, data, nodes = []) {
+    this.name = name;
+    this.data = data;
+    this.nodes = nodes;
+  }
+  
+  addNode(node) {
+    this.nodes.push(node);
+  }
+}
+
+module.exports = DataTreeNode;

package/project/client/data/data-tree/data-tree.js

@@ -0,0 +1,13 @@
+
+'use strict';
+
+const DataTreeNode = require('./data-tree-node');
+
+
+class DataTree {
+  constructor() {
+    this.root = new DataTreeNode();
+  }
+}
+
+module.exports = DataTree;

package/project/client/markup/markup-addresses/markup-addresses-client-address.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataAddressesClientAddressGlobal = require('../../data/addresses/data-addresses-client-address-global');
+const DataAddressesClientAddressLocal = require('../../data/addresses/data-addresses-client-address-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupAddressesClientAddress {
+  stringify(dataAddressesClientAddressGlobal, dataAddressesClientAddressLocal) {
+    return `\n${MarkupTableKeyValue.stringify(new DataAddressesClientAddressLocal(), dataAddressesClientAddressLocal, true)}\n\n${MarkupTableKeyValue.stringify(new DataAddressesClientAddressGlobal(), dataAddressesClientAddressGlobal, true)}\n`;
+  }
+  
+  parse(markup) {
+    let objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataAddressesClientAddressGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataAddressesClientAddressLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupAddressesClientAddress();

package/project/client/markup/markup-addresses/markup-addresses-client-interface.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataAddressesClientInterfaceGlobal = require('../../data/addresses/data-addresses-client-interface-global');
+const DataAddressesClientInterfaceLocal = require('../../data/addresses/data-addresses-client-interface-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupAddressesClientInterface {
+  stringify(dataAddressesClientInterfaceGlobal, dataAddressesClientInterfaceLocal) {
+    return `\n${MarkupTableKeyValue.stringify(new DataAddressesClientInterfaceLocal(), dataAddressesClientInterfaceLocal, true)}\n\n${MarkupTableKeyValue.stringify(new DataAddressesClientInterfaceGlobal(), dataAddressesClientInterfaceGlobal, true)}\n`;
+  }
+  
+  parse(markup) {
+    const objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataAddressesClientInterfaceGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataAddressesClientInterfaceLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupAddressesClientInterface();

package/project/client/markup/markup-addresses/markup-addresses-dns.js

@@ -0,0 +1,32 @@
+
+'use strict';
+
+const DataAddressesDnsGlobal = require('../../data/addresses/data-addresses-dns-global');
+const DataAddressesDnsLocal = require('../../data/addresses/data-addresses-dns-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupAddressesDns {
+  stringify(dataAddressesDnsGlobal, dataAddressesDnsLocal) {
+    return `\n${MarkupTableKeyValue.stringify(new DataAddressesDnsLocal(), dataAddressesDnsLocal, true)}\n\n${MarkupTableKeyValue.stringify(new DataAddressesDnsGlobal(), dataAddressesDnsGlobal, true)}\n`;
+  }
+  
+  parse(markup) {
+    let objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataAddressesDnsGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataAddressesDnsLocal, objectTables.objects)
+    };
+  }
+}
+
+
+module.exports = new MarkupAddressesDns();

package/project/client/markup/markup-addresses/markup-addresses-dst.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataAddressesDstGlobal = require('../../data/addresses/data-addresses-dst-global');
+const DataAddressesDstLocal = require('../../data/addresses/data-addresses-dst-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupAddressesDst {
+  stringify(dataAddressesDstGlobal, dataAddressesDstLocal) {
+    return `\n${MarkupTableKeyValue.stringify(new DataAddressesDstLocal(), dataAddressesDstLocal, true)}\n\n${MarkupTableKeyValue.stringify(new DataAddressesDstGlobal(), dataAddressesDstGlobal, true)}\n`;
+  }
+  
+  parse(markup) {
+    let objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataAddressesDstGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataAddressesDstLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupAddressesDst();

package/project/client/markup/markup-addresses/markup-addresses-network-interface.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataAddressesNetworkInterfaceGlobal = require('../../data/addresses/data-addresses-network-interface-global');
+const DataAddressesNetworkInterfaceLocal = require('../../data/addresses/data-addresses-network-interface-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupAddressesNetworkInterface {
+  stringify(dataAddressesNetworkInterfaceGlobal, dataAddressesNetworkInterfaceLocal) {
+    return `\n${MarkupTableKeyValue.stringify(new DataAddressesNetworkInterfaceLocal(), dataAddressesNetworkInterfaceLocal, true)}\n\n${MarkupTableKeyValue.stringify(new DataAddressesNetworkInterfaceGlobal(), dataAddressesNetworkInterfaceGlobal, true)}\n`;
+  }
+  
+  parse(markup) {
+    let objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataAddressesNetworkInterfaceGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataAddressesNetworkInterfaceLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupAddressesNetworkInterface();

package/project/client/markup/markup-addresses/markup-addresses-ports.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataAddressesPortsGlobal = require('../../data/addresses/data-addresses-ports-global');
+const DataAddressesPortsLocal = require('../../data/addresses/data-addresses-ports-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupAddressesPorts {
+  stringify(dataAddressesPortsGlobal, dataAddressesPortsLocal) {
+    return `\n${MarkupTableKeyValue.stringify(new DataAddressesPortsLocal(), dataAddressesPortsLocal, true)}\n\n${MarkupTableKeyValue.stringify(new DataAddressesPortsGlobal(), dataAddressesPortsGlobal, true)}\n`;
+  }
+  
+  parse(markup) {
+    let objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataAddressesPortsGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataAddressesPortsLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupAddressesPorts();

package/project/client/markup/markup-addresses/markup-addresses-server-address.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataAddressesServerAddressGlobal = require('../../data/addresses/data-addresses-server-address-global');
+const DataAddressesServerAddressLocal = require('../../data/addresses/data-addresses-server-address-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupAddressesServerAddress {
+  stringify(dataAddressesServerAddressGlobal, dataAddressesServerAddressLocal) {
+    return `\n${MarkupTableKeyValue.stringify(new DataAddressesServerAddressLocal(), dataAddressesServerAddressLocal, true)}\n\n${MarkupTableKeyValue.stringify(new DataAddressesServerAddressGlobal(), dataAddressesServerAddressGlobal, true)}\n`;
+  }
+  
+  parse(markup) {
+    let objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataAddressesServerAddressGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataAddressesServerAddressLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupAddressesServerAddress();

package/project/client/markup/markup-addresses/markup-addresses-server-interface.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataAddressesServerInterfaceGlobal = require('../../data/addresses/data-addresses-server-interface-global');
+const DataAddressesServerInterfaceLocal = require('../../data/addresses/data-addresses-server-interface-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupAddressesServerInterface {
+  stringify(dataAddressesServerInterfaceGlobal, dataAddressesServerInterfaceLocal) {
+    return `\n${MarkupTableKeyValue.stringify(new DataAddressesServerInterfaceLocal(), dataAddressesServerInterfaceLocal, true)}\n\n${MarkupTableKeyValue.stringify(new DataAddressesServerInterfaceGlobal(), dataAddressesServerInterfaceGlobal, true)}\n`;
+  }
+  
+  parse(markup) {
+    let objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataAddressesServerInterfaceGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataAddressesServerInterfaceLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupAddressesServerInterface();

package/project/client/markup/markup-addresses/markup-addresses-src.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataAddressesSrcGlobal = require('../../data/addresses/data-addresses-src-global');
+const DataAddressesSrcLocal = require('../../data/addresses/data-addresses-src-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupAddressesSrc {
+  stringify(dataAddressesSrcGlobal, dataAddressesSrcLocal) {
+    return `\n${MarkupTableKeyValue.stringify(new DataAddressesSrcLocal(), dataAddressesSrcLocal, true)}\n\n${MarkupTableKeyValue.stringify(new DataAddressesSrcGlobal(), dataAddressesSrcGlobal, true)}\n`;
+  }
+  
+  parse(markup) {
+    let objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataAddressesSrcGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataAddressesSrcLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupAddressesSrc();

package/project/client/markup/markup-addresses/markup-addresses-srv.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataAddressesSrvGlobal = require('../../data/addresses/data-addresses-srv-global');
+const DataAddressesSrvLocal = require('../../data/addresses/data-addresses-srv-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupAddressesSrv {
+  stringify(dataAddressesSrvGlobal, dataAddressesSrvLocal) {
+    return `\n${MarkupTableKeyValue.stringify(new DataAddressesSrvLocal(), dataAddressesSrvLocal, true)}\n\n${MarkupTableKeyValue.stringify(new DataAddressesSrvGlobal(), dataAddressesSrvGlobal, true)}\n`;
+  }
+  
+  parse(markup) {
+    let objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataAddressesSrvGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataAddressesSrvLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupAddressesSrv();

package/project/client/markup/markup-addresses/markup-addresses-sut-address.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataAddressesSutAddressGlobal = require('../../data/addresses/data-addresses-sut-address-global');
+const DataAddressesSutAddressLocal = require('../../data/addresses/data-addresses-sut-address-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupAddressesSutAddress {
+  stringify(dataAddressesSutAddressGlobal, dataAddressesSutAddressLocal) {
+    return `\n${MarkupTableKeyValue.stringify(new DataAddressesSutAddressLocal(), dataAddressesSutAddressLocal, true)}\n\n${MarkupTableKeyValue.stringify(new DataAddressesSutAddressGlobal(), dataAddressesSutAddressGlobal, true)}\n`;
+  }
+  
+  parse(markup) {
+    let objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataAddressesSutAddressGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataAddressesSutAddressLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupAddressesSutAddress();

package/project/client/markup/markup-addresses/markup-addresses-sut-interface.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataAddressesSutInterfaceGlobal = require('../../data/addresses/data-addresses-sut-interface-global');
+const DataAddressesSutInterfaceLocal = require('../../data/addresses/data-addresses-sut-interface-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupAddressesSutInterface {
+  stringify(dataAddressesSutInterfaceGlobal, dataAddressesSutInterfaceLocal) {
+    return `\n${MarkupTableKeyValue.stringify(new DataAddressesSutInterfaceLocal(), dataAddressesSutInterfaceLocal, true)}\n\n${MarkupTableKeyValue.stringify(new DataAddressesSutInterfaceGlobal(), dataAddressesSutInterfaceGlobal, true)}\n`;
+  }
+  
+  parse(markup) {
+    let objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataAddressesSutInterfaceGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataAddressesSutInterfaceLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupAddressesSutInterface();

package/project/client/markup/markup-chart/markup-chart-line.js

@@ -0,0 +1,92 @@
+
+'use strict';
+
+const DataChartAxis = require('../../data/data-chart/data-chart-axis');
+const DataChartGrid = require('../../data/data-chart/data-chart-grid');
+const DataChartLine = require('../../data/data-chart/data-chart-line/data-chart-line');
+const DataChartLineConfig = require('../../data/data-chart/data-chart-line/data-chart-line-config');
+const MarkupPatternData = require('../markup-pattern-data');
+const MarkupPatternConfig = require('../markup-pattern-config');
+const MarkupPatternFunction = require('../markup-pattern-function');
+
+
+class MarkupChartLine {
+  markupName() {
+    return 'chart-line';
+  }
+  
+  stringify(dataChartLine) {
+    let stringified = '';
+    if('' !== dataChartLine.title) {
+      stringified += `${MarkupChartLine.TAG_TITLE} ${dataChartLine.title}\n`;
+    }
+    stringified += MarkupPatternConfig.stringify(dataChartLine.dataChartLineConfig);
+    if(1 <= dataChartLine.axes.length) {
+      stringified += MarkupPatternFunction.stringify('Axis', dataChartLine.axes);
+    }
+    if(null !== dataChartLine.grid) {
+      stringified += MarkupPatternFunction.stringify('Grid', dataChartLine.grid);
+    }
+    if(1 <= dataChartLine.data.size) {
+      stringified += MarkupPatternData.stringify(dataChartLine.data);
+    }
+    return stringified;
+  }
+  
+  parse(markup) {
+    const rows = this._getRows(markup);
+    const dataChartLine = new DataChartLine();
+    rows.forEach((row) => {
+      this._parseRow(dataChartLine, row);
+    });
+    return dataChartLine;
+  }
+  
+  _parseRow(dataChartLine, row) {
+    const trimRow = row.trim();
+    if(trimRow.startsWith(MarkupChartLine.TAG_TITLE)) {
+      dataChartLine.addTitle(trimRow.substr(MarkupChartLine.TAG_TITLE_LENGTH).trim());
+    }
+    else if(trimRow.startsWith('Axis')) {
+      MarkupPatternFunction.parse(trimRow, (...parameters) => {
+        dataChartLine.addAxis(new DataChartAxis(...parameters));
+      });
+    }
+    else if(trimRow.startsWith('Grid')) {
+      MarkupPatternFunction.parse(trimRow, (...parameters) => {
+        dataChartLine.setGrid(new DataChartGrid(...parameters));
+      });
+    }
+    else if(trimRow.startsWith('Line')) {
+      MarkupPatternData.parse(trimRow, dataChartLine);
+    }
+    else if(trimRow.startsWith('Config')) {
+      MarkupPatternConfig.parse(trimRow, dataChartLine);
+    }
+  }
+  
+  _getRows(markup) {
+    let index = 0;
+    let nextIndex = 0;
+    let rows = [];
+    let length = markup.length;
+    while(index < length) {
+      nextIndex = markup.indexOf('\n', index);
+      if(-1 !== nextIndex) {
+        rows.push(markup.substring(index, nextIndex).trim());
+        index = nextIndex + 1;
+      }
+      else {
+        rows.push(markup.substring(index, length).trim());
+        index = length;
+      }
+    }
+    return rows;
+  }
+}
+
+MarkupChartLine.TAG_TITLE = 'Title:';
+MarkupChartLine.TAG_TITLE_LENGTH = MarkupChartLine.TAG_TITLE.length;
+
+
+module.exports = new MarkupChartLine();

package/project/client/markup/markup-content/markup-content-audio.js

@@ -0,0 +1,31 @@
+
+'use strict';
+
+const DataContentAudioGlobal = require('../../data/data-content/data-content-audio-global');
+const DataContentAudioLocal = require('../../data/data-content/data-content-audio-local');
+const MarkupTableKeyValue = require('../markup-table-key-value');
+const MarkupTablesParser = require('../markup-tables-parser');
+
+
+class MarkupContentAudio {
+  stringify(dataContentGlobals, dataContentLocals) {
+    return `\n${MarkupTableKeyValue.stringify(new DataContentAudioLocal(), dataContentLocals, true)}\n\n${MarkupTableKeyValue.stringify(new DataContentAudioGlobal(), dataContentGlobals, true)}\n`;
+  }
+  
+  parse(markup) {
+    const objectTables = MarkupTablesParser.parse(markup);
+    if(!objectTables.success) {
+      return {
+        success: false,
+        rows: objectTables.rows
+      };
+    }
+    return {
+      success: true,
+      globals: MarkupTableKeyValue.parse(DataContentAudioGlobal, objectTables.objects),
+      locals: MarkupTableKeyValue.parse(DataContentAudioLocal, objectTables.objects)
+    };
+  }
+}
+
+module.exports = new MarkupContentAudio();