
Security News
Vite Releases Technical Preview of Rolldown-Vite, a Rust-Based Bundler
Vite releases Rolldown-Vite, a Rust-based bundler preview offering faster builds and lower memory usage as a drop-in replacement for Vite.
@diplodoc/directive
Advanced tools
This is a pluggable parser for directive syntax for markdown markup. With it you can easily add implementation for a new block in you markdown project.
Add new MarkdownIt-plugin or transformer extension, that plug-in a directive parser and register handler for new block
directive:
import type MarkdownIt from 'markdown-it';
import {directiveParser, registerContainerDirective} from '@diplodoc/directive';
export function simpleBlockPlugin(): MarkdownIt.PluginSimple {
return (md) => {
md.use(directiveParser());
// register container directive using handler
registerContainerDirective(md, 'block', (state, params) => {
if (!params.content) return false;
let token = state.push('simple_block_open', 'div', 1);
token.attrSet('class', 'simple-block');
tokenizeBlockContent(state, params.content);
token = state.push('simple_block_close', 'div', -1);
return true;
});
// or using config-object
registerContainerDirective(md, {
name: 'block',
match(_params, state) {
// here you can add something to state.env
return true;
},
container: {
tag: 'div',
token: 'simple_block',
attrs: {
class: 'simple-block',
},
},
});
};
}
Then attach this plugin/extension to transformer or markdown-it instance:
import transform from '@diplodoc/transform';
const markup = `
::: block
### Heading 3 inside a simple block
:::
`;
const {result: {html}} = await transform(markup, plugins: [
simpleBlockPlugin(),
]);
// or
import MarkdownIt from 'markdown-it';
const md = new MarkdownIt().use(simpleBlockPlugin());
const html = md.render(markup);
html
variable will have the value:
<div class="simple-block">
<h3>Heading 3 inside a simple block</h3>
</div>
Supported inline and block directive syntax. Inline directives are found in the text and start with :
. Block directive is may be leaf block (without content, start with ::
) and container block (with content, start with :::
).
:name [content] (identifier) {key=value}
::name [inline content] (identifier) {key=value}
:::name [inline content] (identifier) {key=value}
content
:::
All of parameters groups – []
, ()
, {}
– are optional, but their order is fixed.
[]
– used for something like inline-content;()
– used for something like required identifier (id, url, etc.);{}
– used to pass optional named arguments / attributes / key=value
pairs.enableInlineDirectives(md: MarkdownIt): void
– enable parsing of inline directives;
disableInlineDirectives(md: MarkdownIt): void
– disable parsing of inline directives;
enableBlockDirectives(md: MarkdownIt): void
– enable parsing of leaf and container blocks directives;
disableBlockDirectives(md: MarkdownIt): void
– disable parsing of leaf and container blocks directives.
registerInlineDirective()
– register handler for new inline directive. Name of directive used in markdown markup after :
, for example: :dir
.
function registerInlineDirective(
md: MarkdownIt,
name: string,
handler: InlineDirectiveHandler,
): void;
registerLeafBlockDirective()
– register handler for new leaf block directive.
function registerLeafBlockDirective(md: MarkdownIt, config: LeafBlockDirectiveConfig): void;
function registerLeafBlockDirective(
md: MarkdownIt,
name: string,
handler: LeafBlockDirectiveHandler,
): void;
registerContainerDirective()
– register handler for new container block or configure it using config-object.
function registerContainerDirective(
md: MarkdownIt,
config: ContainerDirectiveConfig | CodeContainerDirectiveConfig,
): void;
function registerContainerDirective(
md: MarkdownIt,
name: string,
handler: ContainerDirectiveHandler,
): void;
tokenizeInlineContent()
– can be used inside inline directive handler for parse and tokenize content of []
-section.
function tokenizeInlineContent(
state: MarkdownIt['inline']['State'],
content: InlineContent,
): void;
tokenizeBlockContent()
– can be used inside block directive handler for parse and tokenize content between opening :::name
and closing :::
markup of container block directive.
function tokenizeBlockContent(state: MarkdownIt['block']['State'], content: BlockContent): void;
createBlockInlineToken()
– can be used inside block directive handler for creating token with inline content of []
-section.
function createBlockInlineToken(
state: MarkdownIt['block']['State'],
params: BlockDirectiveParams,
): MarkdownIt.Token;
FAQs
Directive syntax for Diplodoc platform
The npm package @diplodoc/directive receives a total of 1,892 weekly downloads. As such, @diplodoc/directive popularity was classified as popular.
We found that @diplodoc/directive demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 10 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Vite releases Rolldown-Vite, a Rust-based bundler preview offering faster builds and lower memory usage as a drop-in replacement for Vite.
Research
Security News
A malicious npm typosquat uses remote commands to silently delete entire project directories after a single mistyped install.
Research
Security News
Malicious PyPI package semantic-types steals Solana private keys via transitive dependency installs using monkey patching and blockchain exfiltration.