- Element name, which is mapped to object.constructor.name under JavaScript.
- Attributes, which is a collection of key-value pairs, stored as normal JavaScript named properties.
- Contents, which is a list of child objects, stored as indexed properties inside the same JavaScript object.

Mark utilizes a novel feature in JavaScript that a plain JS object is actually array-like, it can contain both named properties and indexed properties.

So each Mark element is mapped to just one plain JavaScript object, which is more compact and efficient compared to other JSON-based DOM models (e.g. JsonML, virtual-dom, MicroXML), and is more intuitive to use under JS.

Roughly speaking, data models of JSON, XML, HTML are subsets of Mark data model, and Mark data model is a subset of JS data model.





You can refer to the data model spec for details.

Mark vs. JSON

Mark is a superset of JSON. It extends JSON notation with additional scalar and container types.

Compared to JSON, Mark has the following advantages:

- Additional scalar types supported under Mark, compared to JSON, include: symbol, decimal number, datetime, binary (supporting essentially all the major built-in data types under JS).
- For container types, other than array and map, Mark supports a new type element. Mark element has a type-name, which is important in identifying what the data represents; whereas JSON map is actually an anonymous object, missing the type name.
- Mark element has built-in mixed-content support, which is common in all markup formats, and thus allows Mark to conveniently represent document-oriented data, which is awkward for JSON.
- Mark incorporates some syntax enhancements to JSON ~(e.g. allowing comments, name without quotes)~, thus making the format more friendly for humans.

Some disadvantages of Mark, compared to JSON would be:

- It is no longer a subset of JavaScript literal syntax, although a Mark object is still a simple POJO in JS data model.
- It does not yet have wide support, like JSON, at the moment.

Mark vs. HTML/JSX

Compared to HTML/JSX, Mark has the following advantages:

- Mark is a generic data format, whereas HTML is a specialized format for web content.
- It does not have whitespace ambiguity, as the text objects are quoted explicitly. Thus Mark can be minified or prettified without worrying about changing the underlying content.
- Mark attributes can have complex values, like JSON, not just quoted string values as in HTML.
- It has a very clean syntax, whereas HTML5 parsing can be challenging even with HTML5 spec.
- It is always properly closed; whereas HTML self-closing tag syntax is non-extensible and error-prone.
- The DOM produced under Mark model, is just a hierarchy of POJO objects, which can be easily processed using the built-in JS functions or 3rd party libraries, making Mark an ideal candidate for virtual DOM and other application usages.

Mark vs. XML

Compared to XML, Mark has the following advantages:

- Mark attributes can have complex objects as values; whereas XML attribute values always need to be quoted and cannot have complex objects as values, which is not flexible in syntax and data model.
- Mark syntax is much cleaner than XML. It does not have whitespace ambiguity. It does not have all the legacy things like DTD. It does not have the verbose closing tag.
- The data model produced by Mark is fully typed, like JSON; whereas XML is only semi-typed, when there's no schema.

Mark vs. S-expressions

Lisp and S-expression gave rise to novel ideas like high-order composition, self-hosting program, data as code, code as data, etc.. It's the source of inspiration of Mark and Lambda Script.

The advantage of Mark over S-expressions is that it takes a more modern, web-first approach in its design, making it more readily usable in web and Node.js environments.

mark.js

mark.js is the JS library to work with data in Mark format. It consists of 4 modules:

- The core module mark.js, which provides parse() and stringify() functions, like JSON, and a direct Mark object construction function Mark(), and some functional APIs to work with the object content.
- Sub-module mark.mutate.js, which provides mutative APIs to change the Mark object data model.
- Sub-module mark.convert.js, which provides conversion between Mark format and other formats like HTML and XML.
- Sub-module mark.selector.js, which provides CSS selector based query interface on the Mark object model, like jQuery.

Usage

Install from NPM:

`
npm install mark-js --save
`

Then in your node script, use it as:

`js
const Mark = require('mark-js');
var obj = Mark.parse(