parse, inspect, transform, and serialize content through syntax trees. 

parse, inspect, transform, and serialize content through syntax trees

wooorm

unified

import {CallableInstance} from './callable-instance.js'

 * @template {Node | undefined} [ParseTree=undefined]

 * @template {Node | undefined} [HeadTree=undefined]

 * @template {Node | undefined} [TailTree=undefined]

 * @template {Node | undefined} [CompileTree=undefined]

 * @template {CompileResults | undefined} [CompileResult=undefined]

 * @extends {CallableInstance<[], Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>>}

export class Processor<ParseTree extends import("unist").Node | undefined = undefined, HeadTree extends import("unist").Node | undefined = undefined, TailTree extends import("unist").Node | undefined = undefined, CompileTree extends import("unist").Node | undefined = undefined, CompileResult extends CompileResults | undefined = undefined> extends CallableInstance<[], Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>> {

     *     CompileTree extends undefined ? Node : CompileTree,

     *     CompileResult extends undefined ? CompileResults : CompileResult

    Compiler: (Compiler<CompileTree extends undefined ? Node : CompileTree, CompileResult extends undefined ? CompileResults : CompileResult> | undefined);

     *   Parser<ParseTree extends undefined ? Node : ParseTree> |

    Parser: (Parser<ParseTree extends undefined ? Node : ParseTree> | undefined);

     * Internal list of configured plugins.

     *   This is a private internal property and should not be used.

     * @type {Array<PluginTuple<Array<unknown>>>}

    attachers: Array<[plugin: Plugin<unknown[], undefined, undefined>, ...parameters: unknown[]]>;

    compiler: (Compiler<CompileTree extends undefined ? Node : CompileTree, CompileResult extends undefined ? CompileResults : CompileResult> | undefined);

     * Internal state to track where we are while freezing.

     * Internal state to track whether we’re frozen.

    parser: (Parser<ParseTree extends undefined ? Node : ParseTree> | undefined);

     * Internal list of configured transformers.

export type Data = import('../index.js').Data;

export type Settings = import('../index.js').Settings;

 * To register custom results, add them to

 * {@link CompileResultMap `CompileResultMap`}.

export type CompileResults = CompileResultMap[keyof CompileResultMap];

 * A **compiler** handles the compiling of a syntax tree to something else

 * (in most cases, text) (TypeScript type).

 * It is used in the stringify phase and called with a {@link Node `Node`}

 * and {@link VFile `VFile`} representation of the document to compile.

 * It should return the textual representation of the given tree (typically

 * > 👉 **Note**: unified typically compiles by serializing: most compilers

 * > Some compilers, such as the one configured with

 * > [`rehype-react`][rehype-react], return other values (in this case, a

 * > If you’re using a compiler that doesn’t serialize, expect different

 * > To register custom results in TypeScript, add them to

 * > {@link CompileResultMap `CompileResultMap`}.

 * [rehype-react]: https://github.com/rehypejs/rehype-react

export type Compiler<Tree extends import("unist").Node = import("unist").Node, Result extends CompileResults = CompileResults> = (tree: Tree, file: VFile) => Result;

 * A **parser** handles the parsing of text to a syntax tree.

 * It is used in the parse phase and is called with a `string` and

 * {@link VFile `VFile`} of the document to parse.

 * It must return the syntax tree representation of the given file

export type Parser<Tree extends import("unist").Node = import("unist").Node> = (document: string, file: VFile) => Tree;

 * Union of the different ways to add plugins and settings.

export type Pluggable = (Plugin<Array<any>, any, any> | PluginTuple<Array<any>, any, any> | Preset);

export type PluggableList = Array<Pluggable>;

 * Plugins configure the processors they are applied on in the following

 * *   they change the processor, such as the parser, the compiler, or by

 * *   they specify how to handle trees and files

 * In practice, they are functions that can receive options and configure the

 * > 👉 **Note**: plugins are called when the processor is *frozen*, not when

export type Plugin<PluginParameters extends unknown[] = [], Input extends string | import("unist").Node | undefined = import("unist").Node, Output = Input> = (this: Processor, ...parameters: PluginParameters) => Input extends string ? Output extends Node | undefined ? undefined | void : never : Output extends CompileResults ? Input extends Node | undefined ? undefined | void : never : Transformer<Input extends Node ? Input : Node, Output extends Node ? Output : Node> | undefined | void;

 * Tuple of a plugin and its configuration.

 * The first item is a plugin, the rest are its parameters.

export type PluginTuple<TupleParameters extends unknown[] = [], Input extends string | import("unist").Node | undefined = undefined, Output = undefined> = ([

    plugin: Plugin<TupleParameters, Input, Output>,

 * They can contain plugins and settings.

     * List of plugins and presets (optional).

     * Shared settings for parsers and compilers (optional).

 * Callback called when the process is done.

 * Called with either an error or a result.

export type ProcessCallback<File extends VFile = VFile> = (error?: Error | undefined, file?: File | undefined) => undefined;

 * Callback called when transformers are done.

 * Called with either an error or results.

export type RunCallback<Tree extends import("unist").Node = import("unist").Node> = (error?: Error | undefined, tree?: Tree | undefined, file?: VFile | undefined) => undefined;

 * If the signature of a `transformer` accepts a third argument, the

 * transformer may perform asynchronous operations, and must call it.

export type TransformCallback<Output extends import("unist").Node = import("unist").Node> = (error?: Error | undefined, tree?: Output | undefined, file?: VFile | undefined) => undefined;

 * Transformers handle syntax trees and files.

 * They are functions that are called each time a syntax tree and file are

 * When an error occurs in them (either because it’s thrown, returned,

 * rejected, or passed to `next`), the process stops.

 * The run phase is handled by [`trough`][trough], see its documentation for

 * the exact semantics of these functions.

 * > 👉 **Note**: you should likely ignore `next`: don’t accept it.

 * > it supports callback-style async work.

 * > But promises are likely easier to reason about.

 * [trough]: https://github.com/wooorm/trough#function-fninput-next

export type Transformer<Input extends import("unist").Node = import("unist").Node, Output extends import("unist").Node = Input> = (tree: Input, file: VFile, next: TransformCallback<Output>) => (Promise<Output | undefined | void> | Promise<never> | // For some reason this is needed separately.

 * Create a processor based on the input/output of a {@link Plugin plugin}.

export type UsePlugin<ParseTree extends import("unist").Node | undefined, HeadTree extends import("unist").Node | undefined, TailTree extends import("unist").Node | undefined, CompileTree extends import("unist").Node | undefined, CompileResult extends CompileResults | undefined, Input extends string | import("unist").Node | undefined, Output> = (Input extends string ? Output extends Node | undefined ? Processor<Output extends undefined ? ParseTree : Output, HeadTree, TailTree, CompileTree, CompileResult> : Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult> : Output extends CompileResults ? Input extends Node | undefined ? Processor<ParseTree, HeadTree, TailTree, Input extends undefined ? CompileTree : Input, Output extends undefined ? CompileResult : Output> : Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult> : Input extends Node | undefined ? Output extends Node | undefined ? Processor<ParseTree, HeadTree extends undefined ? Input : HeadTree, Output extends undefined ? TailTree : Output, CompileTree, CompileResult> : Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult> : Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>);

 * Type to generate a {@link VFile `VFile`} corresponding to a compiler result.

 * If a result that is not acceptable on a `VFile` is used, that will

 * be stored on the `result` field of {@link VFile `VFile`}.

export type VFileWithOutput<Result extends CompileResults | undefined> = (Result extends Value | undefined ? VFile : VFile & {

 * @typedef {import('trough').Pipeline} Pipeline

 * @typedef {import('vfile').Compatible} Compatible

 * @typedef {import('vfile').Value} Value

 * @typedef {import('../index.js').CompileResultMap} CompileResultMap

 * @typedef {import('../index.js').Data} Data

 * @typedef {import('../index.js').Settings} Settings

 * @typedef {CompileResultMap[keyof CompileResultMap]} CompileResults

 *   To register custom results, add them to

 *   {@link CompileResultMap `CompileResultMap`}.

 *   The node that the compiler receives (default: `Node`).

 * @template {CompileResults} [Result=CompileResults]

 *   The thing that the compiler yields (default: `CompileResults`).

 *   A **compiler** handles the compiling of a syntax tree to something else

 *   (in most cases, text) (TypeScript type).

 *   It is used in the stringify phase and called with a {@link Node `Node`}

 *   and {@link VFile `VFile`} representation of the document to compile.

 *   It should return the textual representation of the given tree (typically

 *   > 👉 **Note**: unified typically compiles by serializing: most compilers

 *   > return `string` (or `Uint8Array`).

 *   > Some compilers, such as the one configured with

 *   > [`rehype-react`][rehype-react], return other values (in this case, a

 *   > If you’re using a compiler that doesn’t serialize, expect different

 *   > To register custom results in TypeScript, add them to

 *   > {@link CompileResultMap `CompileResultMap`}.

 *   [rehype-react]: https://github.com/rehypejs/rehype-react

 *   New content: compiled text (`string` or `Uint8Array`, for `file.value`) or

 *   The node that the parser yields (default: `Node`)

 *   A **parser** handles the parsing of text to a syntax tree.

 *   It is used in the parse phase and is called with a `string` and

 *   {@link VFile `VFile`} of the document to parse.

 *   It must return the syntax tree representation of the given file

 *   Union of the different ways to add plugins and settings.

 * @typedef {Array<Pluggable>} PluggableList

// Note: we can’t use `callback` yet as it messes up `this`:

//  <https://github.com/microsoft/TypeScript/issues/55197>.

 * @template {Array<unknown>} [PluginParameters=[]]

 *   Arguments passed to the plugin (default: `[]`, the empty tuple).

 * @template {Node | string | undefined} [Input=Node]

 *   Value that is expected as input (default: `Node`).

 *   *   If the plugin returns a {@link Transformer `Transformer`}, this

 *   *   If the plugin sets a {@link Parser `Parser`}, this should be

 *   *   If the plugin sets a {@link Compiler `Compiler`}, this should be the

 *   Value that is yielded as output (default: `Input`).

 *       should be the node that that yields.

 *   *   If the plugin sets a {@link Parser `Parser`}, this should be the

 *   *   If the plugin sets a {@link Compiler `Compiler`}, this should be

 *   List of plugins and presets (optional).

 * @property {Data | undefined} [settings]

 * @property {Settings | undefined} [settings]

 *   Shared settings for parsers and compilers (optional).

 *   The file that the callback receives (default: `VFile`).

 *   Callback called when the process is done.

 *   Called with either an error or a result.

 *   The tree that the callback receives (default: `Node`).

 *   Callback called when transformers are done.

 *   Called with either an error or results.

 *   Node type that the transformer yields (default: `Node`).

 *   If the signature of a `transformer` accepts a third argument, the

 *   transformer may perform asynchronous operations, and must call it.

 *   Fatal error to stop the process (optional).

 *   Node type that the transformer expects (default: `Node`).

 *   Node type that the transformer yields (default: `Input`).

 *   Transformers handle syntax trees and files.

 *   They are functions that are called each time a syntax tree and file are

 *   When an error occurs in them (either because it’s thrown, returned,

 *   rejected, or passed to `next`), the process stops.

 *   The run phase is handled by [`trough`][trough], see its documentation for

 *   the exact semantics of these functions.

 *   > 👉 **Note**: you should likely ignore `next`: don’t accept it.

 *   > it supports callback-style async work.

 *   > But promises are likely easier to reason about.

 *   [trough]: https://github.com/wooorm/trough#function-fninput-next

 * @param {TransformCallback<Output>} next

 *   Promise<Output | undefined | void> |

 *   Promise<never> | // For some reason this is needed separately.

 *   *   `Error` — fatal error to stop the process

 *   *   `Promise<undefined>` or `undefined` — the next transformer keeps using

 *   *   `Promise<Node>` or `Node` — new, changed, tree

 * @template {Node | undefined} ParseTree

  "description": "parse, inspect, transform, and serialize content through syntax trees",

  "bugs": "https://github.com/unifiedjs/unified/issues",

    "url": "https://opencollective.com/unified"

  "author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",

    "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",

    "Junyoung Choi <fluke8259@gmail.com>",

    "Hernan Rajchert <hrajchert@gmail.com>",

    "Christian Murphy <christian.murphy.42@gmail.com>",

    "Vse Mozhet Byt <vsemozhetbyt@gmail.com>",

    "Richard Littauer <richard.littauer@gmail.com>"

    "@types/ungap__structured-clone": "^0.3.0",

    "build": "tsc --build --clean && tsc --build && node script/fix-types.js && type-coverage && tsd",

    "format": "remark . --frail --output --quiet && prettier . --log-level warn --write && xo --fix",

    "prepack": "npm run build && npm run format",

    "test": "npm run build && npm run format && npm run test-coverage",

    "test-api": "node --conditions development test/index.js",

    "test-coverage": "c8 --100 --check-coverage --reporter lcov npm run test-api"

		@@ -277,2 +277,3 @@ import {CallableInstance} from './callable-instance.js'
		export type Data = import('../index.js').Data;
		export type Settings = import('../index.js').Settings;
		/**
		@@ -364,3 +365,3 @@ * Acceptable results from compilers.
		*/
		settings?: Data \| undefined;
		settings?: Settings \| undefined;
		};
		@@ -367,0 +368,0 @@ /**

		{
		"name": "unified",
		"version": "11.0.0",
		"version": "11.0.1",
		"description": "parse, inspect, transform, and serialize content through syntax trees",
		@@ -5,0 +5,0 @@ "license": "MIT",

Fixed alerts

Improved metrics

		@@ -11,2 +11,3 @@ /**
		* @typedef {import('../index.js').Data} Data
		* @typedef {import('../index.js').Settings} Settings
		*/
		@@ -179,3 +180,3 @@
		* List of plugins and presets (optional).
		* @property {Data \| undefined} [settings]
		* @property {Settings \| undefined} [settings]
		* Shared settings for parsers and compilers (optional).
		@@ -182,0 +183,0 @@ */