npm - marked - Versions diffs - 0.3.13 → 0.3.17 - Mend

marked 0.3.13 → 0.3.17

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/README.md CHANGED Viewed

@@ -1,52 +1,46 @@
-# marked
+<ul>
+  <li><a href="#marked">About</a></li>
+  <li><a href="#install">Installation</a></li>
+  <li><a href="#usage">Usage</a></li>
+  <li><a href="#specifications">Supported Markdown specifications</a></li>
+  <li><a href="#security">Security</a></li>
+  <li><a href="#contributing">Contributing</a></li>
+  <li><a href="#authors">Authors</a></li>
+  <li><a href="#license">License</a></li>
+</ul>
-> A full-featured markdown parser and compiler, written in JavaScript. Built
-> for speed.
+<h2 id="marked">Marked</h2>
-[![NPM version](https://badge.fury.io/js/marked.svg)][badge]
+Marked is
-## Install
+1. built for speed.<sup>*</sup>
+2. a low-level markdown compiler that allows frequent parsing of large chunks of markdown without caching or blocking for long periods of time.<sup>**</sup>
+3. light-weight while implementing all markdown features from the supported flavors & specifications.<sup>***</sup>
+4. available as a command line interface (CLI) and running in client- or server-side JavaScript projects.
-``` bash
-npm install marked --save
-```
-or if you want to use the `marked` CLI tool (not necessary when using npm run-scripts):
-``` bash
-npm install -g marked
-```
+<p><small><sup>*</sup> Still working on metrics for comparative analysis and definition.</small><br>
+<small><sup>**</sup> As few dependencies as possible.</small><br>
+<small><sup>***</sup> Strict compliance could result in slower processing when running comparative benchmarking.</small></p>
-## Usage
+<h2 id="installation">Installation</h2>
-Minimal usage:
+**CLI:** `npm install -g marked`
-```js
-var marked = require('marked');
-console.log(marked('I am using __markdown__.'));
-// Outputs: <p>I am using <strong>markdown</strong>.</p>
-```
+**In-browser:** `npm install marked --save`
-Example setting options:
+<h2 id="usage">Usage</h2>
-```js
-var marked = require('marked');
-marked.setOptions({
-  renderer: new marked.Renderer(),
-  gfm: true,
-  tables: true,
-  breaks: false,
-  pedantic: false,
-  sanitize: false,
-  smartLists: true,
-  smartypants: false,
-  xhtml: false
-});
+**CLI**
-console.log(marked('I am using __markdown__.'));
+``` bash
+$ marked -o hello.html
+hello world
+^D
+$ cat hello.html
+<p>hello world</p>
 ```
-### Browser
+**Browser**
 ```html
 <!doctype html>
@@ -54,7 +48,7 @@ console.log(marked('I am using __markdown__.'));
 <head>
   <meta charset="utf-8"/>
   <title>Marked in the browser</title>
-  <script src="lib/marked.js"></script>
+  <script src="/path/to/marked.min.js"></script>
 </head>
 <body>
   <div id="content"></div>
@@ -66,352 +60,38 @@ console.log(marked('I am using __markdown__.'));
 </html>
 ```
-## marked(markdownString [,options] [,callback])
-### markdownString
-Type: `string`
-String of markdown source to be compiled.
-### options
-Type: `object`
-Hash of options. Can also be set using the `marked.setOptions` method as seen
-above.
-### callback
-Type: `function`
-Function called when the `markdownString` has been fully parsed when using
-async highlighting. If the `options` argument is omitted, this can be used as
-the second argument.
-## Options
-### highlight
-Type: `function`
-A function to highlight code blocks. The first example below uses async highlighting with
-[node-pygmentize-bundled][pygmentize], and the second is a synchronous example using
-[highlight.js][highlight]:
-```js
-var marked = require('marked');
-var markdownString = '```js\n console.log("hello"); \n```';
-// Async highlighting with pygmentize-bundled
-marked.setOptions({
-  highlight: function (code, lang, callback) {
-    require('pygmentize-bundled')({ lang: lang, format: 'html' }, code, function (err, result) {
-      callback(err, result.toString());
-    });
-  }
-});
-// Using async version of marked
-marked(markdownString, function (err, content) {
-  if (err) throw err;
-  console.log(content);
-});
-// Synchronous highlighting with highlight.js
-marked.setOptions({
-  highlight: function (code) {
-    return require('highlight.js').highlightAuto(code).value;
-  }
-});
-console.log(marked(markdownString));
-```
-#### highlight arguments
-`code`
-Type: `string`
-The section of code to pass to the highlighter.
-`lang`
-Type: `string`
-The programming language specified in the code block.
-`callback`
-Type: `function`
-The callback function to call when using an async highlighter.
-### renderer
-Type: `object`
-Default: `new Renderer()`
-An object containing functions to render tokens to HTML.
-#### Overriding renderer methods
-The renderer option allows you to render tokens in a custom manner. Here is an
-example of overriding the default heading token rendering by adding an embedded anchor tag like on GitHub:
-```javascript
-var marked = require('marked');
-var renderer = new marked.Renderer();
-renderer.heading = function (text, level) {
-  var escapedText = text.toLowerCase().replace(/[^\w]+/g, '-');
-  return '<h' + level + '><a name="' +
-                escapedText +
-                 '" class="anchor" href="#' +
-                 escapedText +
-                 '"><span class="header-link"></span></a>' +
-                  text + '</h' + level + '>';
-};
-console.log(marked('# heading+', { renderer: renderer }));
-```
-This code will output the following HTML:
-```html
-<h1>
-  <a name="heading-" class="anchor" href="#heading-">
-    <span class="header-link"></span>
-  </a>
-  heading+
-</h1>
-```
-#### Block level renderer methods
-- code(*string* code, *string* language)
-- blockquote(*string* quote)
-- html(*string* html)
-- heading(*string* text, *number*  level)
-- hr()
-- list(*string* body, *boolean* ordered)
-- listitem(*string*  text)
-- paragraph(*string* text)
-- table(*string* header, *string* body)
-- tablerow(*string* content)
-- tablecell(*string* content, *object* flags)
-`flags` has the following properties:
-```js
-{
-    header: true || false,
-    align: 'center' || 'left' || 'right'
-}
-```
-#### Inline level renderer methods
-- strong(*string* text)
-- em(*string* text)
-- codespan(*string* code)
-- br()
-- del(*string* text)
-- link(*string* href, *string* title, *string* text)
-- image(*string* href, *string* title, *string* text)
-- text(*string* text)
-### gfm
-Type: `boolean`
-Default: `true`
-Enable [GitHub flavored markdown][gfm].
-### tables
-Type: `boolean`
-Default: `true`
-Enable GFM [tables][tables].
-This option requires the `gfm` option to be true.
-### breaks
-Type: `boolean`
-Default: `false`
-Enable GFM [line breaks][breaks].
-This option requires the `gfm` option to be true.
-### pedantic
-Type: `boolean`
-Default: `false`
-Conform to obscure parts of `markdown.pl` as much as possible. Don't fix any of
-the original markdown bugs or poor behavior.
-### sanitize
-Type: `boolean`
-Default: `false`
-Sanitize the output. Ignore any HTML that has been input.
-### smartLists
-Type: `boolean`
-Default: `true`
-Use smarter list behavior than the original markdown. May eventually be
-default with the old behavior moved into `pedantic`.
-### smartypants
-Type: `boolean`
-Default: `false`
-Use "smart" typographic punctuation for things like quotes and dashes.
-### xhtml
-Type: `boolean`
-Default: `false`
-Self-close the tags for void elements (&lt;br/&gt;, &lt;img/&gt;, etc.) with a "/" as required by XHTML.
-## Access to lexer and parser
-You also have direct access to the lexer and parser if you so desire.
-``` js
-var tokens = marked.lexer(text, options);
-console.log(marked.parser(tokens));
-```
-``` js
-var lexer = new marked.Lexer(options);
-var tokens = lexer.lex(text);
-console.log(tokens);
-console.log(lexer.rules);
-```
-## CLI
-``` bash
-$ marked -o hello.html
-hello world
-^D
-$ cat hello.html
-<p>hello world</p>
-```
-## Philosophy behind marked
-The point of marked was to create a markdown compiler where it was possible to
-frequently parse huge chunks of markdown without having to worry about
-caching the compiled output somehow...or blocking for an unnecessarily long time.
-marked is very concise and still implements all markdown features. It is also
-now fully compatible with the client-side.
-marked more or less passes the official markdown test suite in its
-entirety. This is important because a surprising number of markdown compilers
-cannot pass more than a few tests. It was very difficult to get marked as
-compliant as it is. It could have cut corners in several areas for the sake
-of performance, but did not in order to be exactly what you expect in terms
-of a markdown rendering. In fact, this is why marked could be considered at a
-disadvantage in the benchmarks.
-Along with implementing every markdown feature, marked also implements [GFM
-features][gfmf].
-## Benchmarks
-node v8.9.4
-``` bash
-$ npm run bench
-marked completed in 3408ms.
-marked (gfm) completed in 3465ms.
-marked (pedantic) completed in 3032ms.
-showdown (reuse converter) completed in 21444ms.
-showdown (new converter) completed in 23058ms.
-markdown-it completed in 3364ms.
-markdown.js completed in 12090ms.
-```
-### Pro level
-You also have direct access to the lexer and parser if you so desire.
+Marked offers [advanced configurations](https://github.com/markedjs/marked/blob/master/USAGE_ADVANCED.md) and [extensibility](https://github.com/markedjs/marked/blob/master/USAGE_EXTENSIBILITY.md) as well.
-``` js
-var tokens = marked.lexer(text, options);
-console.log(marked.parser(tokens));
-```
+<h2 id="specifications">Supported Markdown specifications</h2>
-``` js
-var lexer = new marked.Lexer(options);
-var tokens = lexer.lex(text);
-console.log(tokens);
-console.log(lexer.rules);
-```
+We actively support the features of the following [Markdown flavors](https://github.com/commonmark/CommonMark/wiki/Markdown-Flavors).
-``` bash
-$ node
-> require('marked').lexer('> i am using marked.')
-[ { type: 'blockquote_start' },
-  { type: 'paragraph',
-    text: 'i am using marked.' },
-  { type: 'blockquote_end' },
-  links: {} ]
-```
+|Flavor                                                     |Version    |
+|:----------------------------------------------------------|:----------|
+|The original markdown.pl                                   |--         |
+|[CommonMark](http://spec.commonmark.org/0.28/)             |0.28       |
+|[GitHub Flavored Markdown](https://github.github.com/gfm/) |0.28       |
-## Running Tests & Contributing
+By supporting the above Markdown flavors, it's possible that Marked can help you use other flavors as well; however, these are not actively supported by the community.
-If you want to submit a pull request, make sure your changes pass the test
-suite. If you're adding a new feature, be sure to add your own test.
+<h2 id="security">Security</h2>
-The marked test suite is set up slightly strangely: `test/new` is for all tests
-that are not part of the original markdown.pl test suite (this is where your
-test should go if you make one). `test/original` is only for the original
-markdown.pl tests.
+The only completely secure system is the one that doesn't exist in the first place. Having said that, we take the security of Marked very seriously; however, none of us are necessarily security experts, so to speak. Therefore, if you find something, [say something](https://github.com/markedjs/marked/issues), or, better yet, fix the thing! :)
-In other words, if you have a test to add, add it to `test/new/`. If your test
-uses a certain feature, for example, maybe it assumes GFM is *not* enabled, you
-can add [front-matter](https://www.npmjs.com/package/front-matter) to the top of
-your `.md` file
+<h2 id="contributing">Contributing</h2>
-``` yml
----
-gfm: false
----
-```
+The marked community enjoys a spirit of collaboration and contribution from all comers. Whether you're just getting started with Markdown, JavaScript, and Marked or you're a veteran with it all figured out, we're here to help each other improve as professionals while helping Marked improve technically. Please see our [contributing documentation](https://github.com/markedjs/marked/blob/master/CONTRIBUTING.md) for more details.
-To run the tests:
-``` bash
-npm run test
-```
+For our Contribution License Agreement, see our [license](https://github.com/markedjs/marked/blob/master/LICENSE.md).
-### Contribution and License Agreement
+<h2 id="authors">Authors</h2>
-If you contribute code to this project, you are implicitly allowing your code
-to be distributed under the MIT license. You are also implicitly verifying that
-all code is your original work. `</legalese>`
+For list of credited authors and contributors, please see our [authors page](https://github.com/markedjs/marked/blob/master/AUTHORS.md).
-## License
+<h2 id="license">License</h2>
 Copyright (c) 2011-2018, Christopher Jeffrey. (MIT License)
-See LICENSE for more info.
+See [license](https://github.com/markedjs/marked/blob/master/LICENSE.md) for more details.
-[gfm]: https://help.github.com/articles/github-flavored-markdown
-[gfmf]: http://github.github.com/github-flavored-markdown/
-[pygmentize]: https://github.com/rvagg/node-pygmentize-bundled
-[highlight]: https://github.com/isagalaev/highlight.js
-[badge]: http://badge.fury.io/js/marked
-[tables]: https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#wiki-tables
-[breaks]: https://help.github.com/articles/github-flavored-markdown#newlines

package/RELEASE.md ADDED Viewed

@@ -0,0 +1,24 @@
+# Releasing Marked
+- [ ] See [contributing](https://github.com/markedjs/marked/blob/master/CONTRIBUTING.md)
+- [ ] Create release branch from `master` (`release-x.y.z`)
+- [ ] Submit PR with minimal name: Release x.y.z
+- [ ] Complete PR checklists
+## Overall strategy
+**Master is always shippable:** We try to merge PRs in such a way that `master` is the only branch to really be concerned about *and* `master` can always be released. This allows smoother flow between new fetures, bug fixes, and so on. (Almost a continuous deployment setup, without automation.)
+## Versioning
+We follow [semantic versioning](https://semver.org) where the following sequence is true `[major].[minor].[patch]`; therefore, consider the following implications of the release you are preparing:
+1. **Major:** There is at least one change not deemed backward compatible.
+2. **Minor:** There is at least one new feature added to the release.
+3. **Patch:** No breaking changes, no new features.
+What to expect while Marked is a zero-major (0.x.y):
+1. The major will remain at zero; thereby, alerting consumers to the potentially volatile nature of the package.
+2. The minor will tend to be more analagous to a `major` release. For example, we plan to release `0.4.0` once we have fixed most, if not all, known issues related to the CommonMark and GFM specifications because the architecture changes planned during `0.4.0` will most likely introduce breaking changes.
+3. The patch will tend to be more analagous to a `minor` release.

package/USAGE_ADVANCED.md ADDED Viewed

@@ -0,0 +1,71 @@
+## The `marked` function
+```js
+marked(markdownString [,options] [,callback])
+```
+|Argument              |Type         |Notes                                                                                                |
+|:---------------------|:------------|:----------------------------------------------------------------------------------------------------|
+|markdownString        |`string`     |String of markdown source to be compiled.                                                            |
+|<a href="#options">options</a>|`object`|Hash of options. Can also use `marked.setOptions`.                                                |
+|callback              |`function`   |Called when `markdownString` has been parsed. Can be used as second argument if no `options` present.|
+### Alternative using reference
+```js
+// Create reference instance
+var myMarked = require('marked');
+// Set options
+// `highlight` example uses `highlight.js`
+myMarked.setOptions({
+  renderer: new marked.Renderer(),
+  highlight: function(code) {
+  	return require('highlight.js').highlightAuto(code).value;
+  },
+  pedantic: false,
+  gfm: true,
+  tables: true,
+  breaks: false,
+  sanitize: false,
+  smartLists: true,
+  smartypants: false,
+  xhtml: false
+});
+// Compile
+console.log(myMarked('I am using __markdown__.'));
+```
+<h2 id="options">Options</h2>
+|Member     |Type      |Notes                                                                                                                        |
+|:----------|:---------|:----------------------------------------------------------------------------------------------------------------------------|
+|highlight  |`function`|A function to highlight code blocks. See also: <a href="#highlight">Asynchronous highlighting</a>.                           |
+|renderer   |`object`  |An object containing functions to render tokens to HTML. See [extensibility](https://github.com/markedjs/marked/blob/master/USAGE_EXTENSIBILITY.md) for more details. Default: `new Renderer()`|
+|pedantic   |`boolean` |Conform to obscure parts of `markdown.pl` as much as possible. Don't fix original markdown bugs or behavior. Default: `false`|
+|gfm        |`boolean` |Use approved [GitHub Flavored Markdown (GFM) specification](https://github.github.com/gfm/).                                 |
+|tables     |`boolean` |Use [GFM Tables extension](https://github.github.com/gfm/#tables-extension-). Requires `gfm` be `true`.                      |
+|breaks     |`boolean` |Use GFM [hard](https://github.github.com/gfm/#hard-line-breaks) and [soft](https://github.github.com/gfm/#soft-line-breaks) line breaks. Requires `gfm` be `true`. Default: `false`|
+|sanitize   |`boolean` |Ignore HTML passed into `markdownString` (sanitize the input). Default: `false`                                              |
+|smartlists |`boolean` |Use smarter list behavior than those found in `markdown.pl`. Default: `true`                                                 |
+|smartypants|`boolean` |Use "smart" typographic punctuation for things like quotes and dashes.                                                       |
+|xhtml      |`boolean` |Self-close the tags for void elements (&lt;br/&gt;, &lt;img/&gt;, etc.) with a "/" as required by XHTML. Default: `false`    |
+<h2 id="highlight">Asynchronous highlighting</h2>
+Unlike `highlight.js` the `pygmatize.js` library uses asynchronous highlighting. This example demonstrates that marked is agnostic when it comes to the highlighter you use.
+```js
+myMarked.setOptions({
+  highlight: function(code, lang, callback) {
+    require('pygmentize-bundled') ({ lang: lang, format: 'html' }, code, function (err, result) {
+      callback(err, result.toString());
+    });
+  }
+});
+console.log(myMarked(markdownString));
+```
+In both examples, `code` is a `string` representing the section of code to pass to the highlighter. In this example, `lang` is a `string` informing the highlighter what programming lnaguage to use for the `code` and `callback` is the `function` the asynchronous highlighter will call once complete.

package/USAGE_EXTENSIBILITY.md ADDED Viewed

@@ -0,0 +1,136 @@
+## Extending Marked
+To champion the single-reponsibility and open/closed prinicples, we have tried to make it relatively painless to extend marked. If you are looking to add custom functionality, this is the place to start.
+<ul>
+	<li><a href="#renderer">The renderer</a></li>
+	<li><a href="#lexer">The lexer</a></li>
+	<li><a href="#parser">The parser</a></li>
+</ul>
+<h2 id="renderer">The renderer</h2>
+The renderer is...
+**Example:** Overriding default heading token by adding an embedded anchor tag like on GitHub.
+```js
+// Create reference instance
+var myMarked = require('marked');
+// Get reference
+var renderer = new myMarked.Renderer();
+// Override function
+renderer.heading = function (text, level) {
+  var escapedText = text.toLowerCase().replace(/[^\w]+/g, '-');
+  return `<h${level}>
+            <a name="'${escapedText}'" class="anchor" href="#${escapedText}">
+              <span class="header-link"></span>
+            </a>
+            ${text}
+          </h${level}>`;
+};
+// Run marked
+console.log(marked('# heading+', { renderer: renderer }));
+```
+**Output:**
+```html
+<h1>
+  <a name="heading-" class="anchor" href="#heading-">
+    <span class="header-link"></span>
+  </a>
+  heading+
+</h1>
+```
+### Block level renderer methods
+- code(*string* code, *string* language)
+- blockquote(*string* quote)
+- html(*string* html)
+- heading(*string* text, *number*  level)
+- hr()
+- list(*string* body, *boolean* ordered)
+- listitem(*string*  text)
+- paragraph(*string* text)
+- table(*string* header, *string* body)
+- tablerow(*string* content)
+- tablecell(*string* content, *object* flags)
+`flags` has the following properties:
+```js
+{
+    header: true || false,
+    align: 'center' || 'left' || 'right'
+}
+```
+### Inline level renderer methods
+- strong(*string* text)
+- em(*string* text)
+- codespan(*string* code)
+- br()
+- del(*string* text)
+- link(*string* href, *string* title, *string* text)
+- image(*string* href, *string* title, *string* text)
+- text(*string* text)
+<h2 id="lexer">The lexer</h2>
+The lexer is...
+<h2 id="parser">The parser</h2>
+The parser is...
+***
+<h2 id="extend">Access to lexer and parser</h2>
+You also have direct access to the lexer and parser if you so desire.
+``` js
+var tokens = marked.lexer(text, options);
+console.log(marked.parser(tokens));
+```
+``` js
+var lexer = new marked.Lexer(options);
+var tokens = lexer.lex(text);
+console.log(tokens);
+console.log(lexer.rules);
+```
+### Pro level
+You also have direct access to the lexer and parser if you so desire.
+``` js
+var tokens = marked.lexer(text, options);
+console.log(marked.parser(tokens));
+```
+``` js
+var lexer = new marked.Lexer(options);
+var tokens = lexer.lex(text);
+console.log(tokens);
+console.log(lexer.rules);
+```
+``` bash
+$ node
+> require('marked').lexer('> i am using marked.')
+[ { type: 'blockquote_start' },
+  { type: 'paragraph',
+    text: 'i am using marked.' },
+  { type: 'blockquote_end' },
+  links: {} ]
+```