Need example of basic parsing

[simonh1000]

The examples on the remark website seem to be about linting. What is the simplest possible code to get the json we see in the AST explorer:

I've tried

import {remark} from 'remark'
import {unified} from 'unified'
import remarkParse from 'remark-parse'

const md = '*emphasis* and _importance_'

unified()
    .use(remarkParse)
    .process(md)
    .then((file) => {
        console.log(file)
    }).catch(err => console.log({err}))
// throw new TypeError('Cannot `' + name + '` without `Compiler`')


remark()
    .process(md)
    .then((file) => {
        console.log(file)
    }).catch(err => console.log({err}))
// VFile {data: {},messages: [],history: [],cwd: '/web-components',value: '*emphasis* and *importance*\n'} 
// - i.e. it has not parsed it yet

[Murderlon]

• If you just want the markdown AST, you can use mdast-util-from-markdown
• If you just want to go from markdown to HTML, use micromark
• If you want to easily add plugins, use remark

[ChristianMurphy]

To add on.

The result of your (@simonh1000's) code example is explained by https://github.com/unifiedjs/unified#description

| ........................ process ........................... |
| .......... parse ... | ... run ... | ... stringify ..........|

          +--------+                     +----------+
Input ->- | Parser | ->- Syntax Tree ->- | Compiler | ->- Output
          +--------+          |          +----------+
                              X
                              |
                       +--------------+
                       | Transformers |
                       +--------------+

process will parse content to an AST, run transforms/plugins, and stringify content back to text.
If you only want the AST from unified or remark call, unified().use(remarkParse).parse(md) or remark().parse(md) respectively.

[simonh1000]

Thanks. I think I'm going to remain confused about the differences between

• the unified way
• the remark way; and
• then mdast-util-from-markdown way

I can see that they are all closely related, but therein lies the complexity

[ChristianMurphy]

mdast-util-* is the low level way.
unified wraps utils to allow for an easier transformation pipeline (it supports several languages).
remark is unified configured specifically for markdown.

https://unifiedjs.com/learn/ provides some good documentation and additional context.

[simonh1000]

Is there any documentation of the extensions (enter, exit, ...). I've followed the example, and add some notes of what I could grasp, but understanding the full API would be good

// is name here deliberately the same as the first effects.enter?
const remixConstruct = {name: 'remix', tokenize: remixTokenize}

// extension name is 'remix'
// text construct for a '{' (123)
export const remix = {text: {123: remixConstruct}}

function remixTokenize(effects, ok, nok) {
    return start

    function start(code) {
        effects.enter('remix')
        effects.enter('remixMarker')
        effects.consume(code)
        effects.exit('remixMarker')
        effects.enter('remixString')
        // next line essential, but not sure why
        effects.enter('chunkString', {contentType: 'string'})
        return begin
    }

    // if the first character we find is '}', then we must abandon
    function begin(code) {
        return code === 125 ? nok(code) : inside(code)
    }

    // we know the first character is NOT '}'
    // we continue consuming until we get to '}'
    function inside(code) {
        // 'abandon' if we find these ones
        if (code === -5 || code === -4 || code === -3 || code === null) {
            return nok(code)
        }

        // found the '}'
        if (code === 125) {
            effects.exit('chunkString')
            effects.exit('remixString')
            effects.enter('remixMarker')
            effects.consume(code)
            effects.exit('remixMarker')
            effects.exit('remix')
            return ok
        }

        effects.consume(code)
        return inside
    }
}

// mdastExtensions - is this the compile stage?
// do something with the content collected by effects.enter('remixString') ... effects.exit('remixString')
// see how the keys to enter, and exit
export function remixMdast() {
    return {
        enter: {'remixString': enterRemixString},
        exit: {'remixString': exitRemixString},
    }

    function enterRemixString(token) {
        this.enter({type: 'inline', children: []}, token)
    }

    function exitRemixString(token) {
        this.exit(token)
    }
}

[wooorm]

This sounds like a bit of a different question than what you started with. Could you perhaps open a new thread in the proper place, with all the details needed to answer your question (e.g., what you want to do, what you tried, what didn’t work, what you read, etc?)