sern/website
1
0
Fork 0
mirror of https://github.com/sern-handler/website synced 2026-06-16 21:02:22 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

feat: migrate to starlight

Browse Source
This commit is contained in:
DuroCodes
2024-05-06 17:15:30 -04:00
parent 767acedea7
commit bb190f2d81
15140 changed files with 2828326 additions and 35408 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
node_modules/retext-stringify/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,6 @@
// This wrapper exists because JS in TS can’t export a `@type` of a function.
import type {Root} from 'nlcst'
import type {Plugin} from 'unified'
declare const retextStringify: Plugin<void[], Root, string>
export default retextStringify

3
node_modules/retext-stringify/index.js generated vendored Normal file
View File

@@ -0,0 +1,3 @@
import retextStringify from './lib/index.js'
export default retextStringify

3
node_modules/retext-stringify/lib/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
/** @type {import('unified').Plugin<void[], Root, string>} */
export default function retextStringify(): void
export type Root = import('nlcst').Root

15
node_modules/retext-stringify/lib/index.js generated vendored Normal file
View File

@@ -0,0 +1,15 @@
/**
* @typedef {import('nlcst').Root} Root
*/
import {toString} from 'nlcst-to-string'
/** @type {import('unified').Plugin<void[], Root, string>} */
export default function retextStringify() {
Object.assign(this, {Compiler})
}
/** @type {import('unified').CompilerFunction<Root, string>} */
function Compiler(tree) {
return toString(tree)
}

863
node_modules/retext-stringify/node_modules/unified/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,863 @@
// TypeScript Version: 4.0
// Note: this is a `.d.ts` file because it is not possible to have default type
// parameters in JSDoc-based TypeScript, which is a feature we use to type that:
//
// ```js
// .use(somePlugin, theOptions)
// ```
//
// `theOptions` matches the options that `somePlugin` expects and thus is very
// important for making unified usable in TypeScript.
//
// Furthermore, this is places in the root of the project because types that
// accept type parameters cannot be re-exported as such easily.
import {Node} from 'unist'
import {VFile, VFileCompatible} from 'vfile'
/* eslint-disable @typescript-eslint/naming-convention */
type VFileWithOutput<Result> = Result extends Uint8Array // Buffer.
? VFile
: Result extends object // Custom result type
? VFile & {result: Result}
: VFile
// Get the right most non-void thing.
type Specific<Left = void, Right = void> = Right extends void ? Left : Right
// Create a processor based on the input/output of a plugin.
type UsePlugin<
ParseTree extends Node | void = void,
CurrentTree extends Node | void = void,
CompileTree extends Node | void = void,
CompileResult = void,
Input = void,
Output = void
> = Output extends Node
? Input extends string
? // If `Input` is `string` and `Output` is `Node`, then this plugin
// defines a parser, so set `ParseTree`.
Processor<
Output,
Specific<Output, CurrentTree>,
Specific<Output, CompileTree>,
CompileResult
>
: Input extends Node
? // If `Input` is `Node` and `Output` is `Node`, then this plugin defines a
// transformer, its output defines the input of the next, so set
// `CurrentTree`.
Processor<
Specific<Input, ParseTree>,
Output,
Specific<CompileTree, Output>,
CompileResult
>
: // Else, `Input` is something else and `Output` is `Node`:
never
: Input extends Node
? // If `Input` is `Node` and `Output` is not a `Node`, then this plugin
// defines a compiler, so set `CompileTree` and `CompileResult`
Processor<
Specific<Input, ParseTree>,
Specific<Input, CurrentTree>,
Input,
Output
>
: // Else, `Input` is not a `Node` and `Output` is not a `Node`.
// Maybe it’s untyped, or the plugin throws an error (`never`), so lets
// just keep it as it was.
Processor<ParseTree, CurrentTree, CompileTree, CompileResult>
/* eslint-enable @typescript-eslint/naming-convention */
/**
* Processor allows plugins to be chained together to transform content.
* The chain of plugins defines how content flows through it.
*
* @typeParam ParseTree
* The node that the parser yields (and `run` receives).
* @typeParam CurrentTree
* The node that the last attached plugin yields.
* @typeParam CompileTree
* The node that the compiler receives (and `run` yields).
* @typeParam CompileResult
* The thing that the compiler yields.
*/
export interface Processor<
ParseTree extends Node | void = void,
CurrentTree extends Node | void = void,
CompileTree extends Node | void = void,
CompileResult = void
> extends FrozenProcessor<ParseTree, CurrentTree, CompileTree, CompileResult> {
/**
* Configure the processor to use a plugin.
*
* @typeParam PluginParameters
* Plugin settings.
* @typeParam Input
* Value that is accepted by the plugin.
*
* * If the plugin returns a transformer, then this should be the node
* type that the transformer expects.
* * If the plugin sets a parser, then this should be `string`.
* * If the plugin sets a compiler, then this should be the node type that
* the compiler expects.
* @typeParam Output
* Value that the plugin yields.
*
* * If the plugin returns a transformer, then this should be the node
* type that the transformer yields, and defaults to `Input`.
* * If the plugin sets a parser, then this should be the node type that
* the parser yields.
* * If the plugin sets a compiler, then this should be the result that
* the compiler yields (`string`, `Buffer`, or something else).
* @param plugin
* Plugin (function) to use.
* Plugins are deduped based on identity: passing a function in twice will
* cause it to run only once.
* @param settings
* Configuration for plugin, optional.
* Plugins typically receive one options object, but could receive other and
* more values.
* It’s also possible to pass a boolean instead of settings: `true` (to turn
* a plugin on) or `false` (to turn a plugin off).
* @returns
* Current processor.
*/
use<
PluginParameters extends any[] = any[],
Input = Specific<Node, CurrentTree>,
Output = Input
>(
plugin: Plugin<PluginParameters, Input, Output>,
...settings: PluginParameters | [boolean]
): UsePlugin<
ParseTree,
CurrentTree,
CompileTree,
CompileResult,
Input,
Output
>
/**
* Configure the processor with a tuple of a plugin and setting(s).
*
* @typeParam PluginParameters
* Plugin settings.
* @typeParam Input
* Value that is accepted by the plugin.
*
* * If the plugin returns a transformer, then this should be the node
* type that the transformer expects.
* * If the plugin sets a parser, then this should be `string`.
* * If the plugin sets a compiler, then this should be the node type that
* the compiler expects.
* @typeParam Output
* Value that the plugin yields.
*
* * If the plugin returns a transformer, then this should be the node
* type that the transformer yields, and defaults to `Input`.
* * If the plugin sets a parser, then this should be the node type that
* the parser yields.
* * If the plugin sets a compiler, then this should be the result that
* the compiler yields (`string`, `Buffer`, or something else).
* @param tuple
* A tuple where the first item is a plugin (function) to use and other
* items are options.
* Plugins are deduped based on identity: passing a function in twice will
* cause it to run only once.
* It’s also possible to pass a boolean instead of settings: `true` (to turn
* a plugin on) or `false` (to turn a plugin off).
* @returns
* Current processor.
*/
use<
PluginParameters extends any[] = any[],
Input = Specific<Node, CurrentTree>,
Output = Input
>(
tuple:
| PluginTuple<PluginParameters, Input, Output>
| [Plugin<PluginParameters, Input, Output>, boolean]
): UsePlugin<
ParseTree,
CurrentTree,
CompileTree,
CompileResult,
Input,
Output
>
/**
* Configure the processor with a preset or list of plugins and presets.
*
* @param presetOrList
* Either a list of plugins, presets, and tuples, or a single preset: an
* object with a `plugins` (list) and/or `settings`
* (`Record<string, unknown>`).
* @returns
* Current processor.
*/
use(
presetOrList: Preset | PluggableList
): Processor<ParseTree, CurrentTree, CompileTree, CompileResult>
}
/**
* A frozen processor is just like a regular processor, except no additional
* plugins can be added.
* A frozen processor can be created by calling `.freeze()` on a processor.
* An unfrozen processor can be created by calling a processor.
*/
export interface FrozenProcessor<
ParseTree extends Node | void = void,
CurrentTree extends Node | void = void,
CompileTree extends Node | void = void,
CompileResult = void
> {
/**
* Clone current processor
*
* @returns
* New unfrozen processor that is configured to function the same as its
* ancestor.
* But when the descendant processor is configured it does not affect the
* ancestral processor.
*/
(): Processor<ParseTree, CurrentTree, CompileTree, CompileResult>
/**
* Internal list of configured plugins.
*
* @private
*/
attachers: Array<[Plugin, ...unknown[]]>
Parser?: Parser<Specific<Node, ParseTree>> | undefined
Compiler?:
| Compiler<Specific<Node, CompileTree>, Specific<unknown, CompileResult>>
| undefined
/**
* Parse a file.
*
* @param file
* File to parse.
* `VFile` or anything that can be given to `new VFile()`, optional.
* @returns
* Resulting tree.
*/
parse(file?: VFileCompatible | undefined): Specific<Node, ParseTree>
/**
* Compile a file.
*
* @param node
* Node to compile.
* @param file
* `VFile` or anything that can be given to `new VFile()`, optional.
* @returns
* New content: compiled text (`string` or `Buffer`) or something else.
* This depends on which plugins you use: typically text, but could for
* example be a React node.
*/
stringify(
node: Specific<Node, CompileTree>,
file?: VFileCompatible | undefined
): CompileTree extends Node ? CompileResult : unknown
/**
* Run transforms on the given tree.
*
* @param node
* Tree to transform.
* @param callback
* Callback called with an error or the resulting node.
* @returns
* Nothing.
*/
run(
node: Specific<Node, ParseTree>,
callback: RunCallback<Specific<Node, CompileTree>>
): void
/**
* Run transforms on the given node.
*
* @param node
* Tree to transform.
* @param file
* File associated with `node`.
* `VFile` or anything that can be given to `new VFile()`.
* @param callback
* Callback called with an error or the resulting node.
* @returns
* Nothing.
*/
run(
node: Specific<Node, ParseTree>,
file: VFileCompatible | undefined,
callback: RunCallback<Specific<Node, CompileTree>>
): void
/**
* Run transforms on the given node.
*
* @param node
* Tree to transform.
* @param file
* File associated with `node`.
* `VFile` or anything that can be given to `new VFile()`.
* @returns
* Promise that resolves to the resulting tree.
*/
run(
node: Specific<Node, ParseTree>,
file?: VFileCompatible | undefined
): Promise<Specific<Node, CompileTree>>
/**
* Run transforms on the given node, synchronously.
* Throws when asynchronous transforms are configured.
*
* @param node
* Tree to transform.
* @param file
* File associated with `node`.
* `VFile` or anything that can be given to `new VFile()`, optional.
* @returns
* Resulting tree.
*/
runSync(
node: Specific<Node, ParseTree>,
file?: VFileCompatible | undefined
): Specific<Node, CompileTree>
/**
* Process a file.
*
* This performs all phases of the processor:
*
* 1. Parse a file into a unist node using the configured `Parser`
* 2. Run transforms on that node
* 3. Compile the resulting node using the `Compiler`
*
* The result from the compiler is stored on the file.
* What the result is depends on which plugins you use.
* The result is typically text (`string` or `Buffer`), which can be retrieved
* with `file.toString()` (or `String(file)`).
* In some cases, such as when using `rehypeReact` to create a React node,
* the result is stored on `file.result`.
*
* @param file
* `VFile` or anything that can be given to `new VFile()`.
* @param callback
* Callback called with an error or the resulting file.
* @returns
* Nothing.
*/
process(
file: VFileCompatible | undefined,
callback: ProcessCallback<VFileWithOutput<CompileResult>>
): void
/**
* Process a file.
*
* This performs all phases of the processor:
*
* 1. Parse a file into a unist node using the configured `Parser`
* 2. Run transforms on that node
* 3. Compile the resulting node using the `Compiler`
*
* The result from the compiler is stored on the file.
* What the result is depends on which plugins you use.
* The result is typically text (`string` or `Buffer`), which can be retrieved
* with `file.toString()` (or `String(file)`).
* In some cases, such as when using `rehypeReact` to create a React node,
* the result is stored on `file.result`.
*
* @param file
* `VFile` or anything that can be given to `new VFile()`.
* @returns
* Promise that resolves to the resulting `VFile`.
*/
process(file: VFileCompatible): Promise<VFileWithOutput<CompileResult>>
/**
* Process a file, synchronously.
* Throws when asynchronous transforms are configured.
*
* This performs all phases of the processor:
*
* 1. Parse a file into a unist node using the configured `Parser`
* 2. Run transforms on that node
* 3. Compile the resulting node using the `Compiler`
*
* The result from the compiler is stored on the file.
* What the result is depends on which plugins you use.
* The result is typically text (`string` or `Buffer`), which can be retrieved
* with `file.toString()` (or `String(file)`).
* In some cases, such as when using `rehypeReact` to create a React node,
* the result is stored on `file.result`.
*
* @param file
* `VFile` or anything that can be given to `new VFile()`, optional.
* @returns
* Resulting file.
*/
processSync(
file?: VFileCompatible | undefined
): VFileWithOutput<CompileResult>
/**
* Get an in-memory key-value store accessible to all phases of the process.
*
* @returns
* Key-value store.
*/
data(): Record<string, unknown>
/**
* Set an in-memory key-value store accessible to all phases of the process.
*
* @param data
* Key-value store.
* @returns
* Current processor.
*/
data(
data: Record<string, unknown>
): Processor<ParseTree, CurrentTree, CompileTree, CompileResult>
/**
* Get an in-memory value by key.
*
* @param key
* Key to get.
* @returns
* The value at `key`.
*/
data(key: string): unknown
/**
* Set an in-memory value by key.
*
* @param key
* Key to set.
* @param value
* Value to set.
* @returns
* Current processor.
*/
data(
key: string,
value: unknown
): Processor<ParseTree, CurrentTree, CompileTree, CompileResult>
/**
* Freeze a processor.
* Frozen processors are meant to be extended and not to be configured or
* processed directly.
*
* Once a processor is frozen it cannot be unfrozen.
* New processors working just like it can be created by calling the
* processor.
*
* It’s possible to freeze processors explicitly, by calling `.freeze()`, but
* `.parse()`, `.run()`, `.stringify()`, and `.process()` call `.freeze()` to
* freeze a processor too.
*
* @returns
* Frozen processor.
*/
freeze(): FrozenProcessor<ParseTree, CurrentTree, CompileTree, CompileResult>
}
/**
* A plugin is a function.
* It configures the processor and in turn can receive options.
* Plugins can configure processors by interacting with parsers and compilers
* (at `this.Parser` or `this.Compiler`) or by specifying how the syntax tree
* is handled (by returning a `Transformer`).
*
* @typeParam PluginParameters
* Plugin settings.
* @typeParam Input
* Value that is accepted by the plugin.
*
* * If the plugin returns a transformer, then this should be the node
* type that the transformer expects.
* * If the plugin sets a parser, then this should be `string`.
* * If the plugin sets a compiler, then this should be the node type that
* the compiler expects.
* @typeParam Output
* Value that the plugin yields.
*
* * If the plugin returns a transformer, then this should be the node
* type that the transformer yields, and defaults to `Input`.
* * If the plugin sets a parser, then this should be the node type that
* the parser yields.
* * If the plugin sets a compiler, then this should be the result that
* the compiler yields (`string`, `Buffer`, or something else).
* @this
* The current processor.
* Plugins can configure the processor by interacting with `this.Parser` or
* `this.Compiler`, or by accessing the data associated with the whole process
* (`this.data`).
* @param settings
* Configuration for plugin.
* Plugins typically receive one options object, but could receive other and
* more values.
* Users can also pass a boolean instead of settings: `true` (to turn
* a plugin on) or `false` (to turn a plugin off).
* When a plugin is turned off, it won’t be called.
*
* When creating your own plugins, please accept only a single object!
* It allows plugins to be reconfigured and it helps users to know that every
* plugin accepts one options object.
* @returns
* Plugins can return a `Transformer` to specify how the syntax tree is
* handled.
*/
export type Plugin<
PluginParameters extends any[] = any[],
Input = Node,
Output = Input
> = (
this: Input extends Node
? Output extends Node
? // This is a transform, so define `Input` as the current tree.
Processor<void, Input>
: // Compiler.
Processor<void, Input, Input, Output>
: Output extends Node
? // Parser.
Processor<Output, Output>
: // No clue.
Processor,
...settings: PluginParameters
) => // If both `Input` and `Output` are `Node`, expect an optional `Transformer`.
Input extends Node
? Output extends Node
? Transformer<Input, Output> | void
: void
: void
/**
* Presets provide a sharable way to configure processors with multiple plugins
* and/or settings.
*/
export interface Preset {
plugins?: PluggableList
settings?: Record<string, unknown>
}
/**
* A tuple of a plugin and its setting(s).
* The first item is a plugin (function) to use and other items are options.
* Plugins are deduped based on identity: passing a function in twice will
* cause it to run only once.
*
* @typeParam PluginParameters
* Plugin settings.
* @typeParam Input
* Value that is accepted by the plugin.
*
* * If the plugin returns a transformer, then this should be the node
* type that the transformer expects.
* * If the plugin sets a parser, then this should be `string`.
* * If the plugin sets a compiler, then this should be the node type that
* the compiler expects.
* @typeParam Output
* Value that the plugin yields.
*
* * If the plugin returns a transformer, then this should be the node
* type that the transformer yields, and defaults to `Input`.
* * If the plugin sets a parser, then this should be the node type that
* the parser yields.
* * If the plugin sets a compiler, then this should be the result that
* the compiler yields (`string`, `Buffer`, or something else).
*/
export type PluginTuple<
PluginParameters extends any[] = any[],
Input = Node,
Output = Input
> = [Plugin<PluginParameters, Input, Output>, ...PluginParameters]
/**
* A union of the different ways to add plugins and settings.
*
* @typeParam PluginParameters
* Plugin settings.
*/
export type Pluggable<PluginParameters extends any[] = any[]> =
| PluginTuple<PluginParameters, any, any>
| Plugin<PluginParameters, any, any>
| Preset
/**
* A list of plugins and presets.
*/
export type PluggableList = Pluggable[]
/**
* @deprecated
* Please use `Plugin`.
*/
export type Attacher<
PluginParameters extends any[] = any[],
Input = Node,
Output = Input
> = Plugin<PluginParameters, Input, Output>
/**
* Transformers modify the syntax tree or metadata of a file.
* A transformer is a function that is called each time a file is passed
* through the transform phase.
* If an error occurs (either because it’s thrown, returned, rejected, or passed
* to `next`), the process stops.
*
* @typeParam Input
* Node type that the transformer expects.
* @typeParam Output
* Node type that the transformer yields.
* @param node
* Tree to be transformed.
* @param file
* File associated with node.
* @param next
* Callback that you must call when done.
* Note: this is given if you accept three parameters in your transformer.
* If you accept up to two parameters, it’s not given, and you can return
* a promise.
* @returns
* Any of the following:
*
* * `void` — If nothing is returned, the next transformer keeps using same
* tree.
* * `Error` — Can be returned to stop the process.
* * `Node` — Can be returned and results in further transformations and
* `stringify`s to be performed on the new tree.
* * `Promise` — If a promise is returned, the function is asynchronous, and
* must be resolved (optionally with a `Node`) or rejected (optionally with
* an `Error`).
*
* If you accept a `next` callback, nothing should be returned.
*/
export type Transformer<
Input extends Node = Node,
Output extends Node = Input
> = (
node: Input,
file: VFile,
next: TransformCallback<Output>
) => Promise<Output | undefined | void> | Output | Error | undefined | void
/**
* Callback you must call when a transformer is done.
*
* @typeParam Tree
* Node that the plugin yields.
* @param error
* Pass an error to stop the process.
* @param node
* Pass a tree to continue transformations (and `stringify`) on the new tree.
* @param file
* Pass a file to continue transformations (and `stringify`) on the new file.
* @returns
* Nothing.
*/
export type TransformCallback<Tree extends Node = Node> = (
error?: Error | null | undefined,
node?: Tree | undefined,
file?: VFile | undefined
) => void
/**
* Function handling the parsing of text to a syntax tree.
* Used in the parse phase in the process and called with a `string` and
* `VFile` representation of the document to parse.
*
* `Parser` can be a normal function, in which case it must return a `Node`:
* the syntax tree representation of the given file.
*
* `Parser` can also be a constructor function (a function with keys in its
* `prototype`), in which case it’s called with `new`.
* Instances must have a parse method that is called without arguments and
* must return a `Node`.
*
* @typeParam Tree
* The node that the parser yields (and `run` receives).
*/
export type Parser<Tree extends Node = Node> =
| ParserClass<Tree>
| ParserFunction<Tree>
/**
* A class to parse files.
*
* @typeParam Tree
* The node that the parser yields.
*/
export class ParserClass<Tree extends Node = Node> {
prototype: {
/**
* Parse a file.
*
* @returns
* Parsed tree.
*/
parse(): Tree
}
/**
* Constructor.
*
* @param document
* Document to parse.
* @param file
* File associated with `document`.
* @returns
* Instance.
*/
constructor(document: string, file: VFile)
}
/**
* Normal function to parse a file.
*
* @typeParam Tree
* The node that the parser yields.
* @param document
* Document to parse.
* @param file
* File associated with `document`.
* @returns
* Node representing the given file.
*/
export type ParserFunction<Tree extends Node = Node> = (
document: string,
file: VFile
) => Tree
/**
* Function handling the compilation of syntax tree to a text.
* Used in the stringify phase in the process and called with a `Node` and
* `VFile` representation of the document to stringify.
*
* `Compiler` can be a normal function, in which case it must return a
* `string`: the text representation of the given syntax tree.
*
* `Compiler` can also be a constructor function (a function with keys in its
* `prototype`), in which case it’s called with `new`.
* Instances must have a `compile` method that is called without arguments
* and must return a `string`.
*
* @typeParam Tree
* The node that the compiler receives.
* @typeParam Result
* The thing that the compiler yields.
*/
export type Compiler<Tree extends Node = Node, Result = unknown> =
| CompilerClass<Tree, Result>
| CompilerFunction<Tree, Result>
/**
* A class to compile trees.
*
* @typeParam Tree
* The node that the compiler receives.
* @typeParam Result
* The thing that the compiler yields.
*/
export class CompilerClass<Tree extends Node = Node, Result = unknown> {
prototype: {
/**
* Compile a tree.
*
* @returns
* New content: compiled text (`string` or `Buffer`, for `file.value`) or
* something else (for `file.result`).
*/
compile(): Result
}
/**
* Constructor.
*
* @param tree
* Tree to compile.
* @param file
* File associated with `tree`.
* @returns
* Instance.
*/
constructor(tree: Tree, file: VFile)
}
/**
* Normal function to compile a tree.
*
* @typeParam Tree
* The node that the compiler receives.
* @typeParam Result
* The thing that the compiler yields.
* @param tree
* Tree to compile.
* @param file
* File associated with `tree`.
* @returns
* New content: compiled text (`string` or `Buffer`, for `file.value`) or
* something else (for `file.result`).
*/
export type CompilerFunction<Tree extends Node = Node, Result = unknown> = (
tree: Tree,
file: VFile
) => Result
/**
* Callback called when a done running.
*
* @typeParam Tree
* The tree that the callback receives.
* @param error
* Error passed when unsuccessful.
* @param node
* Tree to transform.
* @param file
* File passed when successful.
* @returns
* Nothing.
*/
export type RunCallback<Tree extends Node = Node> = (
error?: Error | null | undefined,
node?: Tree | undefined,
file?: VFile | undefined
) => void
/**
* Callback called when a done processing.
*
* @typeParam File
* The file that the callback receives.
* @param error
* Error passed when unsuccessful.
* @param file
* File passed when successful.
* @returns
* Nothing.
*/
export type ProcessCallback<File extends VFile = VFile> = (
error?: Error | null | undefined,
file?: File | undefined
) => void
/**
* A frozen processor.
*/
export function unified(): Processor

1
node_modules/retext-stringify/node_modules/unified/index.js generated vendored Normal file
View File

@@ -0,0 +1 @@
export {unified} from './lib/index.js'

19
node_modules/retext-stringify/node_modules/unified/lib/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,19 @@
export const unified: import('..').FrozenProcessor<void, void, void, void>
export type Node = import('unist').Node
export type VFileCompatible = import('vfile').VFileCompatible
export type VFileValue = import('vfile').VFileValue
export type Processor = import('..').Processor
export type Plugin = import('..').Plugin
export type Preset = import('..').Preset
export type Pluggable = import('..').Pluggable
export type PluggableList = import('..').PluggableList
export type Transformer = import('..').Transformer
export type Parser = import('..').Parser
export type Compiler = import('..').Compiler
export type RunCallback = import('..').RunCallback
export type ProcessCallback = import('..').ProcessCallback
export type Context = {
tree: Node
file: VFile
}
import {VFile} from 'vfile'

599
node_modules/retext-stringify/node_modules/unified/lib/index.js generated vendored Normal file
View File

@@ -0,0 +1,599 @@
/**
* @typedef {import('unist').Node} Node
* @typedef {import('vfile').VFileCompatible} VFileCompatible
* @typedef {import('vfile').VFileValue} VFileValue
* @typedef {import('..').Processor} Processor
* @typedef {import('..').Plugin} Plugin
* @typedef {import('..').Preset} Preset
* @typedef {import('..').Pluggable} Pluggable
* @typedef {import('..').PluggableList} PluggableList
* @typedef {import('..').Transformer} Transformer
* @typedef {import('..').Parser} Parser
* @typedef {import('..').Compiler} Compiler
* @typedef {import('..').RunCallback} RunCallback
* @typedef {import('..').ProcessCallback} ProcessCallback
*
* @typedef Context
* @property {Node} tree
* @property {VFile} file
*/
import {bail} from 'bail'
import isBuffer from 'is-buffer'
import extend from 'extend'
import isPlainObj from 'is-plain-obj'
import {trough} from 'trough'
import {VFile} from 'vfile'
// Expose a frozen processor.
export const unified = base().freeze()
const own = {}.hasOwnProperty
// Function to create the first processor.
/**
* @returns {Processor}
*/
function base() {
const transformers = trough()
/** @type {Processor['attachers']} */
const attachers = []
/** @type {Record<string, unknown>} */
let namespace = {}
/** @type {boolean|undefined} */
let frozen
let freezeIndex = -1
// Data management.
// @ts-expect-error: overloads are handled.
processor.data = data
processor.Parser = undefined
processor.Compiler = undefined
// Lock.
processor.freeze = freeze
// Plugins.
processor.attachers = attachers
// @ts-expect-error: overloads are handled.
processor.use = use
// API.
processor.parse = parse
processor.stringify = stringify
// @ts-expect-error: overloads are handled.
processor.run = run
processor.runSync = runSync
// @ts-expect-error: overloads are handled.
processor.process = process
processor.processSync = processSync
// Expose.
return processor
// Create a new processor based on the processor in the current scope.
/** @type {Processor} */
function processor() {
const destination = base()
let index = -1
while (++index < attachers.length) {
destination.use(...attachers[index])
}
destination.data(extend(true, {}, namespace))
return destination
}
/**
* @param {string|Record<string, unknown>} [key]
* @param {unknown} [value]
* @returns {unknown}
*/
function data(key, value) {
if (typeof key === 'string') {
// Set `key`.
if (arguments.length === 2) {
assertUnfrozen('data', frozen)
namespace[key] = value
return processor
}
// Get `key`.
return (own.call(namespace, key) && namespace[key]) || null
}
// Set space.
if (key) {
assertUnfrozen('data', frozen)
namespace = key
return processor
}
// Get space.
return namespace
}
/** @type {Processor['freeze']} */
function freeze() {
if (frozen) {
return processor
}
while (++freezeIndex < attachers.length) {
const [attacher, ...options] = attachers[freezeIndex]
if (options[0] === false) {
continue
}
if (options[0] === true) {
options[0] = undefined
}
/** @type {Transformer|void} */
const transformer = attacher.call(processor, ...options)
if (typeof transformer === 'function') {
transformers.use(transformer)
}
}
frozen = true
freezeIndex = Number.POSITIVE_INFINITY
return processor
}
/**
* @param {Pluggable|null|undefined} [value]
* @param {...unknown} options
* @returns {Processor}
*/
function use(value, ...options) {
/** @type {Record<string, unknown>|undefined} */
let settings
assertUnfrozen('use', frozen)
if (value === null || value === undefined) {
// Empty.
} else if (typeof value === 'function') {
addPlugin(value, ...options)
} else if (typeof value === 'object') {
if (Array.isArray(value)) {
addList(value)
} else {
addPreset(value)
}
} else {
throw new TypeError('Expected usable value, not `' + value + '`')
}
if (settings) {
namespace.settings = Object.assign(namespace.settings || {}, settings)
}
return processor
/**
* @param {import('..').Pluggable<unknown[]>} value
* @returns {void}
*/
function add(value) {
if (typeof value === 'function') {
addPlugin(value)
} else if (typeof value === 'object') {
if (Array.isArray(value)) {
const [plugin, ...options] = value
addPlugin(plugin, ...options)
} else {
addPreset(value)
}
} else {
throw new TypeError('Expected usable value, not `' + value + '`')
}
}
/**
* @param {Preset} result
* @returns {void}
*/
function addPreset(result) {
addList(result.plugins)
if (result.settings) {
settings = Object.assign(settings || {}, result.settings)
}
}
/**
* @param {PluggableList|null|undefined} [plugins]
* @returns {void}
*/
function addList(plugins) {
let index = -1
if (plugins === null || plugins === undefined) {
// Empty.
} else if (Array.isArray(plugins)) {
while (++index < plugins.length) {
const thing = plugins[index]
add(thing)
}
} else {
throw new TypeError('Expected a list of plugins, not `' + plugins + '`')
}
}
/**
* @param {Plugin} plugin
* @param {...unknown} [value]
* @returns {void}
*/
function addPlugin(plugin, value) {
let index = -1
/** @type {Processor['attachers'][number]|undefined} */
let entry
while (++index < attachers.length) {
if (attachers[index][0] === plugin) {
entry = attachers[index]
break
}
}
if (entry) {
if (isPlainObj(entry[1]) && isPlainObj(value)) {
value = extend(true, entry[1], value)
}
entry[1] = value
} else {
// @ts-expect-error: fine.
attachers.push([...arguments])
}
}
}
/** @type {Processor['parse']} */
function parse(doc) {
processor.freeze()
const file = vfile(doc)
const Parser = processor.Parser
assertParser('parse', Parser)
if (newable(Parser, 'parse')) {
// @ts-expect-error: `newable` checks this.
return new Parser(String(file), file).parse()
}
// @ts-expect-error: `newable` checks this.
return Parser(String(file), file) // eslint-disable-line new-cap
}
/** @type {Processor['stringify']} */
function stringify(node, doc) {
processor.freeze()
const file = vfile(doc)
const Compiler = processor.Compiler
assertCompiler('stringify', Compiler)
assertNode(node)
if (newable(Compiler, 'compile')) {
// @ts-expect-error: `newable` checks this.
return new Compiler(node, file).compile()
}
// @ts-expect-error: `newable` checks this.
return Compiler(node, file) // eslint-disable-line new-cap
}
/**
* @param {Node} node
* @param {VFileCompatible|RunCallback} [doc]
* @param {RunCallback} [callback]
* @returns {Promise<Node>|void}
*/
function run(node, doc, callback) {
assertNode(node)
processor.freeze()
if (!callback && typeof doc === 'function') {
callback = doc
doc = undefined
}
if (!callback) {
return new Promise(executor)
}
executor(null, callback)
/**
* @param {null|((node: Node) => void)} resolve
* @param {(error: Error) => void} reject
* @returns {void}
*/
function executor(resolve, reject) {
// @ts-expect-error: `doc` can’t be a callback anymore, we checked.
transformers.run(node, vfile(doc), done)
/**
* @param {Error|null} error
* @param {Node} tree
* @param {VFile} file
* @returns {void}
*/
function done(error, tree, file) {
tree = tree || node
if (error) {
reject(error)
} else if (resolve) {
resolve(tree)
} else {
// @ts-expect-error: `callback` is defined if `resolve` is not.
callback(null, tree, file)
}
}
}
}
/** @type {Processor['runSync']} */
function runSync(node, file) {
/** @type {Node|undefined} */
let result
/** @type {boolean|undefined} */
let complete
processor.run(node, file, done)
assertDone('runSync', 'run', complete)
// @ts-expect-error: we either bailed on an error or have a tree.
return result
/**
* @param {Error|null} [error]
* @param {Node} [tree]
* @returns {void}
*/
function done(error, tree) {
bail(error)
result = tree
complete = true
}
}
/**
* @param {VFileCompatible} doc
* @param {ProcessCallback} [callback]
* @returns {Promise<VFile>|undefined}
*/
function process(doc, callback) {
processor.freeze()
assertParser('process', processor.Parser)
assertCompiler('process', processor.Compiler)
if (!callback) {
return new Promise(executor)
}
executor(null, callback)
/**
* @param {null|((file: VFile) => void)} resolve
* @param {(error?: Error|null|undefined) => void} reject
* @returns {void}
*/
function executor(resolve, reject) {
const file = vfile(doc)
processor.run(processor.parse(file), file, (error, tree, file) => {
if (error || !tree || !file) {
done(error)
} else {
/** @type {unknown} */
const result = processor.stringify(tree, file)
if (result === undefined || result === null) {
// Empty.
} else if (looksLikeAVFileValue(result)) {
file.value = result
} else {
file.result = result
}
done(error, file)
}
})
/**
* @param {Error|null|undefined} [error]
* @param {VFile|undefined} [file]
* @returns {void}
*/
function done(error, file) {
if (error || !file) {
reject(error)
} else if (resolve) {
resolve(file)
} else {
// @ts-expect-error: `callback` is defined if `resolve` is not.
callback(null, file)
}
}
}
}
/** @type {Processor['processSync']} */
function processSync(doc) {
/** @type {boolean|undefined} */
let complete
processor.freeze()
assertParser('processSync', processor.Parser)
assertCompiler('processSync', processor.Compiler)
const file = vfile(doc)
processor.process(file, done)
assertDone('processSync', 'process', complete)
return file
/**
* @param {Error|null|undefined} [error]
* @returns {void}
*/
function done(error) {
complete = true
bail(error)
}
}
}
/**
* Check if `value` is a constructor.
*
* @param {unknown} value
* @param {string} name
* @returns {boolean}
*/
function newable(value, name) {
return (
typeof value === 'function' &&
// Prototypes do exist.
// type-coverage:ignore-next-line
value.prototype &&
// A function with keys in its prototype is probably a constructor.
// Classes’ prototype methods are not enumerable, so we check if some value
// exists in the prototype.
// type-coverage:ignore-next-line
(keys(value.prototype) || name in value.prototype)
)
}
/**
* Check if `value` is an object with keys.
*
* @param {Record<string, unknown>} value
* @returns {boolean}
*/
function keys(value) {
/** @type {string} */
let key
for (key in value) {
if (own.call(value, key)) {
return true
}
}
return false
}
/**
* Assert a parser is available.
*
* @param {string} name
* @param {unknown} value
* @returns {asserts value is Parser}
*/
function assertParser(name, value) {
if (typeof value !== 'function') {
throw new TypeError('Cannot `' + name + '` without `Parser`')
}
}
/**
* Assert a compiler is available.
*
* @param {string} name
* @param {unknown} value
* @returns {asserts value is Compiler}
*/
function assertCompiler(name, value) {
if (typeof value !== 'function') {
throw new TypeError('Cannot `' + name + '` without `Compiler`')
}
}
/**
* Assert the processor is not frozen.
*
* @param {string} name
* @param {unknown} frozen
* @returns {asserts frozen is false}
*/
function assertUnfrozen(name, frozen) {
if (frozen) {
throw new Error(
'Cannot call `' +
name +
'` on a frozen processor.\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.'
)
}
}
/**
* Assert `node` is a unist node.
*
* @param {unknown} node
* @returns {asserts node is Node}
*/
function assertNode(node) {
// `isPlainObj` unfortunately uses `any` instead of `unknown`.
// type-coverage:ignore-next-line
if (!isPlainObj(node) || typeof node.type !== 'string') {
throw new TypeError('Expected node, got `' + node + '`')
// Fine.
}
}
/**
* Assert that `complete` is `true`.
*
* @param {string} name
* @param {string} asyncName
* @param {unknown} complete
* @returns {asserts complete is true}
*/
function assertDone(name, asyncName, complete) {
if (!complete) {
throw new Error(
'`' + name + '` finished async. Use `' + asyncName + '` instead'
)
}
}
/**
* @param {VFileCompatible} [value]
* @returns {VFile}
*/
function vfile(value) {
return looksLikeAVFile(value) ? value : new VFile(value)
}
/**
* @param {VFileCompatible} [value]
* @returns {value is VFile}
*/
function looksLikeAVFile(value) {
return Boolean(
value &&
typeof value === 'object' &&
'message' in value &&
'messages' in value
)
}
/**
* @param {unknown} [value]
* @returns {value is VFileValue}
*/
function looksLikeAVFileValue(value) {
return typeof value === 'string' || isBuffer(value)
}

21
node_modules/retext-stringify/node_modules/unified/license generated vendored Normal file
View File

@@ -0,0 +1,21 @@
(The MIT License)
Copyright (c) 2015 Titus Wormer <tituswormer@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

21
node_modules/retext-stringify/node_modules/unified/node_modules/@types/unist/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) Microsoft Corporation.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE

122
node_modules/retext-stringify/node_modules/unified/node_modules/@types/unist/README.md generated vendored Normal file
View File

@@ -0,0 +1,122 @@
# Installation
> `npm install --save @types/unist`
# Summary
This package contains type definitions for unist (https://github.com/syntax-tree/unist).
# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/unist/v2.
## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/unist/v2/index.d.ts)
````ts
/**
* Syntactic units in unist syntax trees are called nodes.
*
* @typeParam TData Information from the ecosystem. Useful for more specific {@link Node.data}.
*/
export interface Node<TData extends object = Data> {
/**
* The variant of a node.
*/
type: string;
/**
* Information from the ecosystem.
*/
data?: TData | undefined;
/**
* Location of a node in a source document.
* Must not be present if a node is generated.
*/
position?: Position | undefined;
}
/**
* Information associated by the ecosystem with the node.
* Space is guaranteed to never be specified by unist or specifications
* implementing unist.
*/
export interface Data {
[key: string]: unknown;
}
/**
* Location of a node in a source file.
*/
export interface Position {
/**
* Place of the first character of the parsed source region.
*/
start: Point;
/**
* Place of the first character after the parsed source region.
*/
end: Point;
/**
* Start column at each index (plus start line) in the source region,
* for elements that span multiple lines.
*/
indent?: number[] | undefined;
}
/**
* One place in a source file.
*/
export interface Point {
/**
* Line in a source file (1-indexed integer).
*/
line: number;
/**
* Column in a source file (1-indexed integer).
*/
column: number;
/**
* Character in a source file (0-indexed integer).
*/
offset?: number | undefined;
}
/**
* Util for extracting type of {@link Node.data}
*
* @typeParam TNode Specific node type such as {@link Node} with {@link Data}, {@link Literal}, etc.
*
* @example `NodeData<Node<{ key: string }>>` -> `{ key: string }`
*/
export type NodeData<TNode extends Node<object>> = TNode extends Node<infer TData> ? TData : never;
/**
* Nodes containing other nodes.
*
* @typeParam ChildNode Node item of {@link Parent.children}
*/
export interface Parent<ChildNode extends Node<object> = Node, TData extends object = NodeData<ChildNode>>
extends Node<TData>
{
/**
* List representing the children of a node.
*/
children: ChildNode[];
}
/**
* Nodes containing a value.
*
* @typeParam Value Specific value type of {@link Literal.value} such as `string` for `Text` node
*/
export interface Literal<Value = unknown, TData extends object = Data> extends Node<TData> {
value: Value;
}
````
### Additional Details
* Last updated: Tue, 07 Nov 2023 20:08:00 GMT
* Dependencies: none
# Credits
These definitions were written by [bizen241](https://github.com/bizen241), [Jun Lu](https://github.com/lujun2), [Hernan Rajchert](https://github.com/hrajchert), [Titus Wormer](https://github.com/wooorm), [Junyoung Choi](https://github.com/rokt33r), [Ben Moon](https://github.com/GuiltyDolphin), and [JounQin](https://github.com/JounQin).

103
node_modules/retext-stringify/node_modules/unified/node_modules/@types/unist/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,103 @@
/**
* Syntactic units in unist syntax trees are called nodes.
*
* @typeParam TData Information from the ecosystem. Useful for more specific {@link Node.data}.
*/
export interface Node<TData extends object = Data> {
/**
* The variant of a node.
*/
type: string;
/**
* Information from the ecosystem.
*/
data?: TData | undefined;
/**
* Location of a node in a source document.
* Must not be present if a node is generated.
*/
position?: Position | undefined;
}
/**
* Information associated by the ecosystem with the node.
* Space is guaranteed to never be specified by unist or specifications
* implementing unist.
*/
export interface Data {
[key: string]: unknown;
}
/**
* Location of a node in a source file.
*/
export interface Position {
/**
* Place of the first character of the parsed source region.
*/
start: Point;
/**
* Place of the first character after the parsed source region.
*/
end: Point;
/**
* Start column at each index (plus start line) in the source region,
* for elements that span multiple lines.
*/
indent?: number[] | undefined;
}
/**
* One place in a source file.
*/
export interface Point {
/**
* Line in a source file (1-indexed integer).
*/
line: number;
/**
* Column in a source file (1-indexed integer).
*/
column: number;
/**
* Character in a source file (0-indexed integer).
*/
offset?: number | undefined;
}
/**
* Util for extracting type of {@link Node.data}
*
* @typeParam TNode Specific node type such as {@link Node} with {@link Data}, {@link Literal}, etc.
*
* @example `NodeData<Node<{ key: string }>>` -> `{ key: string }`
*/
export type NodeData<TNode extends Node<object>> = TNode extends Node<infer TData> ? TData : never;
/**
* Nodes containing other nodes.
*
* @typeParam ChildNode Node item of {@link Parent.children}
*/
export interface Parent<ChildNode extends Node<object> = Node, TData extends object = NodeData<ChildNode>>
extends Node<TData>
{
/**
* List representing the children of a node.
*/
children: ChildNode[];
}
/**
* Nodes containing a value.
*
* @typeParam Value Specific value type of {@link Literal.value} such as `string` for `Text` node
*/
export interface Literal<Value = unknown, TData extends object = Data> extends Node<TData> {
value: Value;
}

56
node_modules/retext-stringify/node_modules/unified/node_modules/@types/unist/package.json generated vendored Normal file
View File

@@ -0,0 +1,56 @@
{
"name": "@types/unist",
"version": "2.0.10",
"description": "TypeScript definitions for unist",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/unist",
"license": "MIT",
"contributors": [
{
"name": "bizen241",
"githubUsername": "bizen241",
"url": "https://github.com/bizen241"
},
{
"name": "Jun Lu",
"githubUsername": "lujun2",
"url": "https://github.com/lujun2"
},
{
"name": "Hernan Rajchert",
"githubUsername": "hrajchert",
"url": "https://github.com/hrajchert"
},
{
"name": "Titus Wormer",
"githubUsername": "wooorm",
"url": "https://github.com/wooorm"
},
{
"name": "Junyoung Choi",
"githubUsername": "rokt33r",
"url": "https://github.com/rokt33r"
},
{
"name": "Ben Moon",
"githubUsername": "GuiltyDolphin",
"url": "https://github.com/GuiltyDolphin"
},
{
"name": "JounQin",
"githubUsername": "JounQin",
"url": "https://github.com/JounQin"
}
],
"main": "",
"types": "index.d.ts",
"repository": {
"type": "git",
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
"directory": "types/unist"
},
"scripts": {},
"dependencies": {},
"typesPublisherContentHash": "65c419f7bf5fb4a8b58da16b61b8cfc2629fb81d70dff861467e0292b2ed70ea",
"typeScriptVersion": "4.5",
"nonNpm": true
}

64
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,64 @@
import type {Reporter} from './lib/index.js'
/**
* This is the same as `Buffer` if node types are included, `never` otherwise.
*/
// eslint-disable-next-line @typescript-eslint/ban-ts-comment, @typescript-eslint/prefer-ts-expect-error
// @ts-ignore It’s important to preserve this ignore statement. This makes sure
// it works both with and without node types.
// eslint-disable-next-line n/prefer-global/buffer
type MaybeBuffer = any extends Buffer ? never : Buffer
/**
* Contents of the file.
*
* Can either be text or a `Buffer` structure.
*/
// Note: this does not directly use type `Buffer`, because it can also be used
// in a browser context.
// Instead this leverages `Uint8Array` which is the base type for `Buffer`,
// and a native JavaScript construct.
export type Value = string | MaybeBuffer
/**
* This map registers the type of the `data` key of a `VFile`.
*
* This type can be augmented to register custom `data` types.
*
* @example
* declare module 'vfile' {
* interface DataMap {
* // `file.data.name` is typed as `string`
* name: string
* }
* }
*/
// eslint-disable-next-line @typescript-eslint/consistent-type-definitions, @typescript-eslint/no-empty-interface
export interface DataMap {}
/**
* Custom information.
*
* Known attributes can be added to @see {@link DataMap}
*/
export type Data = Record<string, unknown> & Partial<DataMap>
// Deprecated names (w/ prefix):
export type {Data as VFileData, DataMap as VFileDataMap, Value as VFileValue}
export {VFile} from './lib/index.js'
export type {
BufferEncoding,
Map,
Compatible,
Options,
Reporter,
ReporterSettings,
// Deprecated names (w/ prefix):
Compatible as VFileCompatible,
Options as VFileOptions,
Reporter as VFileReporter,
ReporterSettings as VFileReporterSettings
} from './lib/index.js'

1
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/index.js generated vendored Normal file
View File

@@ -0,0 +1 @@
export {VFile} from './lib/index.js'

355
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/lib/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,355 @@
export class VFile {
/**
* Create a new virtual file.
*
* `options` is treated as:
*
* * `string` or `Buffer` — `{value: options}`
* * `URL` — `{path: options}`
* * `VFile` — shallow copies its data over to the new file
* * `object` — all fields are shallow copied over to the new file
*
* Path related fields are set in the following order (least specific to
* most specific): `history`, `path`, `basename`, `stem`, `extname`,
* `dirname`.
*
* You cannot set `dirname` or `extname` without setting either `history`,
* `path`, `basename`, or `stem` too.
*
* @param {Compatible | null | undefined} [value]
* File value.
* @returns
* New instance.
*/
constructor(value?: Compatible | null | undefined)
/**
* Place to store custom information (default: `{}`).
*
* It’s OK to store custom data directly on the file but moving it to
* `data` is recommended.
*
* @type {Data}
*/
data: Data
/**
* List of messages associated with the file.
*
* @type {Array<VFileMessage>}
*/
messages: Array<VFileMessage>
/**
* List of filepaths the file moved between.
*
* The first is the original path and the last is the current path.
*
* @type {Array<string>}
*/
history: Array<string>
/**
* Base of `path` (default: `process.cwd()` or `'/'` in browsers).
*
* @type {string}
*/
cwd: string
/**
* Raw value.
*
* @type {Value}
*/
value: Value
/**
* Whether a file was saved to disk.
*
* This is used by vfile reporters.
*
* @type {boolean}
*/
stored: boolean
/**
* Custom, non-string, compiled, representation.
*
* This is used by unified to store non-string results.
* One example is when turning markdown into React nodes.
*
* @type {unknown}
*/
result: unknown
/**
* Source map.
*
* This type is equivalent to the `RawSourceMap` type from the `source-map`
* module.
*
* @type {Map | null | undefined}
*/
map: Map | null | undefined
/**
* Set the full path (example: `'~/index.min.js'`).
*
* Cannot be nullified.
* You can set a file URL (a `URL` object with a `file:` protocol) which will
* be turned into a path with `url.fileURLToPath`.
*
* @param {string | URL} path
*/
set path(arg: string)
/**
* Get the full path (example: `'~/index.min.js'`).
*
* @returns {string}
*/
get path(): string
/**
* Set the parent path (example: `'~'`).
*
* Cannot be set if there’s no `path` yet.
*/
set dirname(arg: string | undefined)
/**
* Get the parent path (example: `'~'`).
*/
get dirname(): string | undefined
/**
* Set basename (including extname) (`'index.min.js'`).
*
* Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
* on windows).
* Cannot be nullified (use `file.path = file.dirname` instead).
*/
set basename(arg: string | undefined)
/**
* Get the basename (including extname) (example: `'index.min.js'`).
*/
get basename(): string | undefined
/**
* Set the extname (including dot) (example: `'.js'`).
*
* Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
* on windows).
* Cannot be set if there’s no `path` yet.
*/
set extname(arg: string | undefined)
/**
* Get the extname (including dot) (example: `'.js'`).
*/
get extname(): string | undefined
/**
* Set the stem (basename w/o extname) (example: `'index.min'`).
*
* Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
* on windows).
* Cannot be nullified (use `file.path = file.dirname` instead).
*/
set stem(arg: string | undefined)
/**
* Get the stem (basename w/o extname) (example: `'index.min'`).
*/
get stem(): string | undefined
/**
* Serialize the file.
*
* @param {BufferEncoding | null | undefined} [encoding='utf8']
* Character encoding to understand `value` as when it’s a `Buffer`
* (default: `'utf8'`).
* @returns {string}
* Serialized file.
*/
toString(encoding?: BufferEncoding | null | undefined): string
/**
* Create a warning message associated with the file.
*
* Its `fatal` is set to `false` and `file` is set to the current file path.
* Its added to `file.messages`.
*
* @param {string | Error | VFileMessage} reason
* Reason for message, uses the stack and message of the error if given.
* @param {Node | NodeLike | Position | Point | null | undefined} [place]
* Place in file where the message occurred.
* @param {string | null | undefined} [origin]
* Place in code where the message originates (example:
* `'my-package:my-rule'` or `'my-rule'`).
* @returns {VFileMessage}
* Message.
*/
message(
reason: string | Error | VFileMessage,
place?: Node | NodeLike | Position | Point | null | undefined,
origin?: string | null | undefined
): VFileMessage
/**
* Create an info message associated with the file.
*
* Its `fatal` is set to `null` and `file` is set to the current file path.
* Its added to `file.messages`.
*
* @param {string | Error | VFileMessage} reason
* Reason for message, uses the stack and message of the error if given.
* @param {Node | NodeLike | Position | Point | null | undefined} [place]
* Place in file where the message occurred.
* @param {string | null | undefined} [origin]
* Place in code where the message originates (example:
* `'my-package:my-rule'` or `'my-rule'`).
* @returns {VFileMessage}
* Message.
*/
info(
reason: string | Error | VFileMessage,
place?: Node | NodeLike | Position | Point | null | undefined,
origin?: string | null | undefined
): VFileMessage
/**
* Create a fatal error associated with the file.
*
* Its `fatal` is set to `true` and `file` is set to the current file path.
* Its added to `file.messages`.
*
* > 👉 **Note**: a fatal error means that a file is no longer processable.
*
* @param {string | Error | VFileMessage} reason
* Reason for message, uses the stack and message of the error if given.
* @param {Node | NodeLike | Position | Point | null | undefined} [place]
* Place in file where the message occurred.
* @param {string | null | undefined} [origin]
* Place in code where the message originates (example:
* `'my-package:my-rule'` or `'my-rule'`).
* @returns {never}
* Message.
* @throws {VFileMessage}
* Message.
*/
fail(
reason: string | Error | VFileMessage,
place?: Node | NodeLike | Position | Point | null | undefined,
origin?: string | null | undefined
): never
}
export type Node = import('unist').Node
export type Position = import('unist').Position
export type Point = import('unist').Point
export type URL = import('./minurl.shared.js').URL
export type Data = import('../index.js').Data
export type Value = import('../index.js').Value
export type NodeLike = Record<string, unknown> & {
type: string
position?: Position | undefined
}
/**
* Encodings supported by the buffer class.
*
* This is a copy of the types from Node, copied to prevent Node globals from
* being needed.
* Copied from: <https://github.com/DefinitelyTyped/DefinitelyTyped/blob/90a4ec8/types/node/buffer.d.ts#L170>
*/
export type BufferEncoding =
| 'ascii'
| 'utf8'
| 'utf-8'
| 'utf16le'
| 'ucs2'
| 'ucs-2'
| 'base64'
| 'base64url'
| 'latin1'
| 'binary'
| 'hex'
/**
* Things that can be passed to the constructor.
*/
export type Compatible = Options | URL | Value | VFile
/**
* Set multiple values.
*/
export type VFileCoreOptions = {
/**
* Set `value`.
*/
value?: Value | null | undefined
/**
* Set `cwd`.
*/
cwd?: string | null | undefined
/**
* Set `history`.
*/
history?: Array<string> | null | undefined
/**
* Set `path`.
*/
path?: URL | string | null | undefined
/**
* Set `basename`.
*/
basename?: string | null | undefined
/**
* Set `stem`.
*/
stem?: string | null | undefined
/**
* Set `extname`.
*/
extname?: string | null | undefined
/**
* Set `dirname`.
*/
dirname?: string | null | undefined
/**
* Set `data`.
*/
data?: Data | null | undefined
}
/**
* Raw source map.
*
* See:
* <https://github.com/mozilla/source-map/blob/58819f0/source-map.d.ts#L15-L23>.
*/
export type Map = {
/**
* Which version of the source map spec this map is following.
*/
version: number
/**
* An array of URLs to the original source files.
*/
sources: Array<string>
/**
* An array of identifiers which can be referenced by individual mappings.
*/
names: Array<string>
/**
* The URL root from which all sources are relative.
*/
sourceRoot?: string | undefined
/**
* An array of contents of the original source files.
*/
sourcesContent?: Array<string> | undefined
/**
* A string of base64 VLQs which contain the actual mappings.
*/
mappings: string
/**
* The generated file this source map is associated with.
*/
file: string
}
/**
* Configuration.
*
* A bunch of keys that will be shallow copied over to the new file.
*/
export type Options = {
[key: string]: unknown
} & VFileCoreOptions
/**
* Configuration for reporters.
*/
export type ReporterSettings = Record<string, unknown>
/**
* Type for a reporter.
*/
export type Reporter<Settings extends ReporterSettings> = (
files: Array<VFile>,
options: Settings
) => string
import {VFileMessage} from 'vfile-message'

520
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/lib/index.js generated vendored Normal file
View File

@@ -0,0 +1,520 @@
/**
* @typedef {import('unist').Node} Node
* @typedef {import('unist').Position} Position
* @typedef {import('unist').Point} Point
* @typedef {import('./minurl.shared.js').URL} URL
* @typedef {import('../index.js').Data} Data
* @typedef {import('../index.js').Value} Value
*/
/**
* @typedef {Record<string, unknown> & {type: string, position?: Position | undefined}} NodeLike
*
* @typedef {'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex'} BufferEncoding
* Encodings supported by the buffer class.
*
* This is a copy of the types from Node, copied to prevent Node globals from
* being needed.
* Copied from: <https://github.com/DefinitelyTyped/DefinitelyTyped/blob/90a4ec8/types/node/buffer.d.ts#L170>
*
* @typedef {Options | URL | Value | VFile} Compatible
* Things that can be passed to the constructor.
*
* @typedef VFileCoreOptions
* Set multiple values.
* @property {Value | null | undefined} [value]
* Set `value`.
* @property {string | null | undefined} [cwd]
* Set `cwd`.
* @property {Array<string> | null | undefined} [history]
* Set `history`.
* @property {URL | string | null | undefined} [path]
* Set `path`.
* @property {string | null | undefined} [basename]
* Set `basename`.
* @property {string | null | undefined} [stem]
* Set `stem`.
* @property {string | null | undefined} [extname]
* Set `extname`.
* @property {string | null | undefined} [dirname]
* Set `dirname`.
* @property {Data | null | undefined} [data]
* Set `data`.
*
* @typedef Map
* Raw source map.
*
* See:
* <https://github.com/mozilla/source-map/blob/58819f0/source-map.d.ts#L15-L23>.
* @property {number} version
* Which version of the source map spec this map is following.
* @property {Array<string>} sources
* An array of URLs to the original source files.
* @property {Array<string>} names
* An array of identifiers which can be referenced by individual mappings.
* @property {string | undefined} [sourceRoot]
* The URL root from which all sources are relative.
* @property {Array<string> | undefined} [sourcesContent]
* An array of contents of the original source files.
* @property {string} mappings
* A string of base64 VLQs which contain the actual mappings.
* @property {string} file
* The generated file this source map is associated with.
*
* @typedef {{[key: string]: unknown} & VFileCoreOptions} Options
* Configuration.
*
* A bunch of keys that will be shallow copied over to the new file.
*
* @typedef {Record<string, unknown>} ReporterSettings
* Configuration for reporters.
*/
/**
* @template {ReporterSettings} Settings
* Options type.
* @callback Reporter
* Type for a reporter.
* @param {Array<VFile>} files
* Files to report.
* @param {Settings} options
* Configuration.
* @returns {string}
* Report.
*/
import bufferLike from 'is-buffer'
import {VFileMessage} from 'vfile-message'
import {path} from './minpath.js'
import {proc} from './minproc.js'
import {urlToPath, isUrl} from './minurl.js'
/**
* Order of setting (least specific to most), we need this because otherwise
* `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a
* stem can be set.
*
* @type {Array<'basename' | 'dirname' | 'extname' | 'history' | 'path' | 'stem'>}
*/
const order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname']
export class VFile {
/**
* Create a new virtual file.
*
* `options` is treated as:
*
* * `string` or `Buffer` — `{value: options}`
* * `URL` — `{path: options}`
* * `VFile` — shallow copies its data over to the new file
* * `object` — all fields are shallow copied over to the new file
*
* Path related fields are set in the following order (least specific to
* most specific): `history`, `path`, `basename`, `stem`, `extname`,
* `dirname`.
*
* You cannot set `dirname` or `extname` without setting either `history`,
* `path`, `basename`, or `stem` too.
*
* @param {Compatible | null | undefined} [value]
* File value.
* @returns
* New instance.
*/
constructor(value) {
/** @type {Options | VFile} */
let options
if (!value) {
options = {}
} else if (typeof value === 'string' || buffer(value)) {
options = {value}
} else if (isUrl(value)) {
options = {path: value}
} else {
options = value
}
/**
* Place to store custom information (default: `{}`).
*
* It’s OK to store custom data directly on the file but moving it to
* `data` is recommended.
*
* @type {Data}
*/
this.data = {}
/**
* List of messages associated with the file.
*
* @type {Array<VFileMessage>}
*/
this.messages = []
/**
* List of filepaths the file moved between.
*
* The first is the original path and the last is the current path.
*
* @type {Array<string>}
*/
this.history = []
/**
* Base of `path` (default: `process.cwd()` or `'/'` in browsers).
*
* @type {string}
*/
this.cwd = proc.cwd()
/* eslint-disable no-unused-expressions */
/**
* Raw value.
*
* @type {Value}
*/
this.value
// The below are non-standard, they are “well-known”.
// As in, used in several tools.
/**
* Whether a file was saved to disk.
*
* This is used by vfile reporters.
*
* @type {boolean}
*/
this.stored
/**
* Custom, non-string, compiled, representation.
*
* This is used by unified to store non-string results.
* One example is when turning markdown into React nodes.
*
* @type {unknown}
*/
this.result
/**
* Source map.
*
* This type is equivalent to the `RawSourceMap` type from the `source-map`
* module.
*
* @type {Map | null | undefined}
*/
this.map
/* eslint-enable no-unused-expressions */
// Set path related properties in the correct order.
let index = -1
while (++index < order.length) {
const prop = order[index]
// Note: we specifically use `in` instead of `hasOwnProperty` to accept
// `vfile`s too.
if (
prop in options &&
options[prop] !== undefined &&
options[prop] !== null
) {
// @ts-expect-error: TS doesn’t understand basic reality.
this[prop] = prop === 'history' ? [...options[prop]] : options[prop]
}
}
/** @type {string} */
let prop
// Set non-path related properties.
for (prop in options) {
// @ts-expect-error: fine to set other things.
if (!order.includes(prop)) {
// @ts-expect-error: fine to set other things.
this[prop] = options[prop]
}
}
}
/**
* Get the full path (example: `'~/index.min.js'`).
*
* @returns {string}
*/
get path() {
return this.history[this.history.length - 1]
}
/**
* Set the full path (example: `'~/index.min.js'`).
*
* Cannot be nullified.
* You can set a file URL (a `URL` object with a `file:` protocol) which will
* be turned into a path with `url.fileURLToPath`.
*
* @param {string | URL} path
*/
set path(path) {
if (isUrl(path)) {
path = urlToPath(path)
}
assertNonEmpty(path, 'path')
if (this.path !== path) {
this.history.push(path)
}
}
/**
* Get the parent path (example: `'~'`).
*/
get dirname() {
return typeof this.path === 'string' ? path.dirname(this.path) : undefined
}
/**
* Set the parent path (example: `'~'`).
*
* Cannot be set if there’s no `path` yet.
*/
set dirname(dirname) {
assertPath(this.basename, 'dirname')
this.path = path.join(dirname || '', this.basename)
}
/**
* Get the basename (including extname) (example: `'index.min.js'`).
*/
get basename() {
return typeof this.path === 'string' ? path.basename(this.path) : undefined
}
/**
* Set basename (including extname) (`'index.min.js'`).
*
* Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
* on windows).
* Cannot be nullified (use `file.path = file.dirname` instead).
*/
set basename(basename) {
assertNonEmpty(basename, 'basename')
assertPart(basename, 'basename')
this.path = path.join(this.dirname || '', basename)
}
/**
* Get the extname (including dot) (example: `'.js'`).
*/
get extname() {
return typeof this.path === 'string' ? path.extname(this.path) : undefined
}
/**
* Set the extname (including dot) (example: `'.js'`).
*
* Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
* on windows).
* Cannot be set if there’s no `path` yet.
*/
set extname(extname) {
assertPart(extname, 'extname')
assertPath(this.dirname, 'extname')
if (extname) {
if (extname.charCodeAt(0) !== 46 /* `.` */) {
throw new Error('`extname` must start with `.`')
}
if (extname.includes('.', 1)) {
throw new Error('`extname` cannot contain multiple dots')
}
}
this.path = path.join(this.dirname, this.stem + (extname || ''))
}
/**
* Get the stem (basename w/o extname) (example: `'index.min'`).
*/
get stem() {
return typeof this.path === 'string'
? path.basename(this.path, this.extname)
: undefined
}
/**
* Set the stem (basename w/o extname) (example: `'index.min'`).
*
* Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
* on windows).
* Cannot be nullified (use `file.path = file.dirname` instead).
*/
set stem(stem) {
assertNonEmpty(stem, 'stem')
assertPart(stem, 'stem')
this.path = path.join(this.dirname || '', stem + (this.extname || ''))
}
/**
* Serialize the file.
*
* @param {BufferEncoding | null | undefined} [encoding='utf8']
* Character encoding to understand `value` as when it’s a `Buffer`
* (default: `'utf8'`).
* @returns {string}
* Serialized file.
*/
toString(encoding) {
return (this.value || '').toString(encoding || undefined)
}
/**
* Create a warning message associated with the file.
*
* Its `fatal` is set to `false` and `file` is set to the current file path.
* Its added to `file.messages`.
*
* @param {string | Error | VFileMessage} reason
* Reason for message, uses the stack and message of the error if given.
* @param {Node | NodeLike | Position | Point | null | undefined} [place]
* Place in file where the message occurred.
* @param {string | null | undefined} [origin]
* Place in code where the message originates (example:
* `'my-package:my-rule'` or `'my-rule'`).
* @returns {VFileMessage}
* Message.
*/
message(reason, place, origin) {
const message = new VFileMessage(reason, place, origin)
if (this.path) {
message.name = this.path + ':' + message.name
message.file = this.path
}
message.fatal = false
this.messages.push(message)
return message
}
/**
* Create an info message associated with the file.
*
* Its `fatal` is set to `null` and `file` is set to the current file path.
* Its added to `file.messages`.
*
* @param {string | Error | VFileMessage} reason
* Reason for message, uses the stack and message of the error if given.
* @param {Node | NodeLike | Position | Point | null | undefined} [place]
* Place in file where the message occurred.
* @param {string | null | undefined} [origin]
* Place in code where the message originates (example:
* `'my-package:my-rule'` or `'my-rule'`).
* @returns {VFileMessage}
* Message.
*/
info(reason, place, origin) {
const message = this.message(reason, place, origin)
message.fatal = null
return message
}
/**
* Create a fatal error associated with the file.
*
* Its `fatal` is set to `true` and `file` is set to the current file path.
* Its added to `file.messages`.
*
* > 👉 **Note**: a fatal error means that a file is no longer processable.
*
* @param {string | Error | VFileMessage} reason
* Reason for message, uses the stack and message of the error if given.
* @param {Node | NodeLike | Position | Point | null | undefined} [place]
* Place in file where the message occurred.
* @param {string | null | undefined} [origin]
* Place in code where the message originates (example:
* `'my-package:my-rule'` or `'my-rule'`).
* @returns {never}
* Message.
* @throws {VFileMessage}
* Message.
*/
fail(reason, place, origin) {
const message = this.message(reason, place, origin)
message.fatal = true
throw message
}
}
/**
* Assert that `part` is not a path (as in, does not contain `path.sep`).
*
* @param {string | null | undefined} part
* File path part.
* @param {string} name
* Part name.
* @returns {void}
* Nothing.
*/
function assertPart(part, name) {
if (part && part.includes(path.sep)) {
throw new Error(
'`' + name + '` cannot be a path: did not expect `' + path.sep + '`'
)
}
}
/**
* Assert that `part` is not empty.
*
* @param {string | undefined} part
* Thing.
* @param {string} name
* Part name.
* @returns {asserts part is string}
* Nothing.
*/
function assertNonEmpty(part, name) {
if (!part) {
throw new Error('`' + name + '` cannot be empty')
}
}
/**
* Assert `path` exists.
*
* @param {string | undefined} path
* Path.
* @param {string} name
* Dependency name.
* @returns {asserts path is string}
* Nothing.
*/
function assertPath(path, name) {
if (!path) {
throw new Error('Setting `' + name + '` requires `path` to be set too')
}
}
/**
* Assert `value` is a buffer.
*
* @param {unknown} value
* thing.
* @returns {value is Buffer}
* Whether `value` is a Node.js buffer.
*/
function buffer(value) {
return bufferLike(value)
}

46
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/lib/minpath.browser.d.ts generated vendored Normal file
View File

@@ -0,0 +1,46 @@
export namespace path {
export {basename}
export {dirname}
export {extname}
export {join}
export const sep: string
}
/**
* Get the basename from a path.
*
* @param {string} path
* File path.
* @param {string | undefined} [ext]
* Extension to strip.
* @returns {string}
* Stem or basename.
*/
declare function basename(path: string, ext?: string | undefined): string
/**
* Get the dirname from a path.
*
* @param {string} path
* File path.
* @returns {string}
* File path.
*/
declare function dirname(path: string): string
/**
* Get an extname from a path.
*
* @param {string} path
* File path.
* @returns {string}
* Extname.
*/
declare function extname(path: string): string
/**
* Join segments from a path.
*
* @param {Array<string>} segments
* Path segments.
* @returns {string}
* File path.
*/
declare function join(...segments: Array<string>): string
export {}

422
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/lib/minpath.browser.js generated vendored Normal file
View File

@@ -0,0 +1,422 @@
// A derivative work based on:
// <https://github.com/browserify/path-browserify>.
// Which is licensed:
//
// MIT License
//
// Copyright (c) 2013 James Halliday
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// A derivative work based on:
//
// Parts of that are extracted from Node’s internal `path` module:
// <https://github.com/nodejs/node/blob/master/lib/path.js>.
// Which is licensed:
//
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
export const path = {basename, dirname, extname, join, sep: '/'}
/* eslint-disable max-depth, complexity */
/**
* Get the basename from a path.
*
* @param {string} path
* File path.
* @param {string | undefined} [ext]
* Extension to strip.
* @returns {string}
* Stem or basename.
*/
function basename(path, ext) {
if (ext !== undefined && typeof ext !== 'string') {
throw new TypeError('"ext" argument must be a string')
}
assertPath(path)
let start = 0
let end = -1
let index = path.length
/** @type {boolean | undefined} */
let seenNonSlash
if (ext === undefined || ext.length === 0 || ext.length > path.length) {
while (index--) {
if (path.charCodeAt(index) === 47 /* `/` */) {
// If we reached a path separator that was not part of a set of path
// separators at the end of the string, stop now.
if (seenNonSlash) {
start = index + 1
break
}
} else if (end < 0) {
// We saw the first non-path separator, mark this as the end of our
// path component.
seenNonSlash = true
end = index + 1
}
}
return end < 0 ? '' : path.slice(start, end)
}
if (ext === path) {
return ''
}
let firstNonSlashEnd = -1
let extIndex = ext.length - 1
while (index--) {
if (path.charCodeAt(index) === 47 /* `/` */) {
// If we reached a path separator that was not part of a set of path
// separators at the end of the string, stop now.
if (seenNonSlash) {
start = index + 1
break
}
} else {
if (firstNonSlashEnd < 0) {
// We saw the first non-path separator, remember this index in case
// we need it if the extension ends up not matching.
seenNonSlash = true
firstNonSlashEnd = index + 1
}
if (extIndex > -1) {
// Try to match the explicit extension.
if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {
if (extIndex < 0) {
// We matched the extension, so mark this as the end of our path
// component
end = index
}
} else {
// Extension does not match, so our result is the entire path
// component
extIndex = -1
end = firstNonSlashEnd
}
}
}
}
if (start === end) {
end = firstNonSlashEnd
} else if (end < 0) {
end = path.length
}
return path.slice(start, end)
}
/**
* Get the dirname from a path.
*
* @param {string} path
* File path.
* @returns {string}
* File path.
*/
function dirname(path) {
assertPath(path)
if (path.length === 0) {
return '.'
}
let end = -1
let index = path.length
/** @type {boolean | undefined} */
let unmatchedSlash
// Prefix `--` is important to not run on `0`.
while (--index) {
if (path.charCodeAt(index) === 47 /* `/` */) {
if (unmatchedSlash) {
end = index
break
}
} else if (!unmatchedSlash) {
// We saw the first non-path separator
unmatchedSlash = true
}
}
return end < 0
? path.charCodeAt(0) === 47 /* `/` */
? '/'
: '.'
: end === 1 && path.charCodeAt(0) === 47 /* `/` */
? '//'
: path.slice(0, end)
}
/**
* Get an extname from a path.
*
* @param {string} path
* File path.
* @returns {string}
* Extname.
*/
function extname(path) {
assertPath(path)
let index = path.length
let end = -1
let startPart = 0
let startDot = -1
// Track the state of characters (if any) we see before our first dot and
// after any path separator we find.
let preDotState = 0
/** @type {boolean | undefined} */
let unmatchedSlash
while (index--) {
const code = path.charCodeAt(index)
if (code === 47 /* `/` */) {
// If we reached a path separator that was not part of a set of path
// separators at the end of the string, stop now.
if (unmatchedSlash) {
startPart = index + 1
break
}
continue
}
if (end < 0) {
// We saw the first non-path separator, mark this as the end of our
// extension.
unmatchedSlash = true
end = index + 1
}
if (code === 46 /* `.` */) {
// If this is our first dot, mark it as the start of our extension.
if (startDot < 0) {
startDot = index
} else if (preDotState !== 1) {
preDotState = 1
}
} else if (startDot > -1) {
// We saw a non-dot and non-path separator before our dot, so we should
// have a good chance at having a non-empty extension.
preDotState = -1
}
}
if (
startDot < 0 ||
end < 0 ||
// We saw a non-dot character immediately before the dot.
preDotState === 0 ||
// The (right-most) trimmed path component is exactly `..`.
(preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
) {
return ''
}
return path.slice(startDot, end)
}
/**
* Join segments from a path.
*
* @param {Array<string>} segments
* Path segments.
* @returns {string}
* File path.
*/
function join(...segments) {
let index = -1
/** @type {string | undefined} */
let joined
while (++index < segments.length) {
assertPath(segments[index])
if (segments[index]) {
joined =
joined === undefined ? segments[index] : joined + '/' + segments[index]
}
}
return joined === undefined ? '.' : normalize(joined)
}
/**
* Normalize a basic file path.
*
* @param {string} path
* File path.
* @returns {string}
* File path.
*/
// Note: `normalize` is not exposed as `path.normalize`, so some code is
// manually removed from it.
function normalize(path) {
assertPath(path)
const absolute = path.charCodeAt(0) === 47 /* `/` */
// Normalize the path according to POSIX rules.
let value = normalizeString(path, !absolute)
if (value.length === 0 && !absolute) {
value = '.'
}
if (value.length > 0 && path.charCodeAt(path.length - 1) === 47 /* / */) {
value += '/'
}
return absolute ? '/' + value : value
}
/**
* Resolve `.` and `..` elements in a path with directory names.
*
* @param {string} path
* File path.
* @param {boolean} allowAboveRoot
* Whether `..` can move above root.
* @returns {string}
* File path.
*/
function normalizeString(path, allowAboveRoot) {
let result = ''
let lastSegmentLength = 0
let lastSlash = -1
let dots = 0
let index = -1
/** @type {number | undefined} */
let code
/** @type {number} */
let lastSlashIndex
while (++index <= path.length) {
if (index < path.length) {
code = path.charCodeAt(index)
} else if (code === 47 /* `/` */) {
break
} else {
code = 47 /* `/` */
}
if (code === 47 /* `/` */) {
if (lastSlash === index - 1 || dots === 1) {
// Empty.
} else if (lastSlash !== index - 1 && dots === 2) {
if (
result.length < 2 ||
lastSegmentLength !== 2 ||
result.charCodeAt(result.length - 1) !== 46 /* `.` */ ||
result.charCodeAt(result.length - 2) !== 46 /* `.` */
) {
if (result.length > 2) {
lastSlashIndex = result.lastIndexOf('/')
if (lastSlashIndex !== result.length - 1) {
if (lastSlashIndex < 0) {
result = ''
lastSegmentLength = 0
} else {
result = result.slice(0, lastSlashIndex)
lastSegmentLength = result.length - 1 - result.lastIndexOf('/')
}
lastSlash = index
dots = 0
continue
}
} else if (result.length > 0) {
result = ''
lastSegmentLength = 0
lastSlash = index
dots = 0
continue
}
}
if (allowAboveRoot) {
result = result.length > 0 ? result + '/..' : '..'
lastSegmentLength = 2
}
} else {
if (result.length > 0) {
result += '/' + path.slice(lastSlash + 1, index)
} else {
result = path.slice(lastSlash + 1, index)
}
lastSegmentLength = index - lastSlash - 1
}
lastSlash = index
dots = 0
} else if (code === 46 /* `.` */ && dots > -1) {
dots++
} else {
dots = -1
}
}
return result
}
/**
* Make sure `path` is a string.
*
* @param {string} path
* File path.
* @returns {asserts path is string}
* Nothing.
*/
function assertPath(path) {
if (typeof path !== 'string') {
throw new TypeError(
'Path must be a string. Received ' + JSON.stringify(path)
)
}
}
/* eslint-enable max-depth, complexity */

1
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/lib/minpath.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export {default as path} from 'path'

1
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/lib/minpath.js generated vendored Normal file
View File

@@ -0,0 +1 @@
export {default as path} from 'path'

5
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/lib/minproc.browser.d.ts generated vendored Normal file
View File

@@ -0,0 +1,5 @@
export namespace proc {
export {cwd}
}
declare function cwd(): string
export {}

8
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/lib/minproc.browser.js generated vendored Normal file
View File

@@ -0,0 +1,8 @@
// Somewhat based on:
// <https://github.com/defunctzombie/node-process/blob/master/browser.js>.
// But I don’t think one tiny line of code can be copyrighted. 😅
export const proc = {cwd}
function cwd() {
return '/'
}

1
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/lib/minproc.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export {default as proc} from 'process'

1
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/lib/minproc.js generated vendored Normal file
View File

@@ -0,0 +1 @@
export {default as proc} from 'process'

9
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/lib/minurl.browser.d.ts generated vendored Normal file
View File

@@ -0,0 +1,9 @@
/// <reference lib="dom" />
/**
* @param {string | URL} path
* File URL.
* @returns {string}
* File URL.
*/
export function urlToPath(path: string | URL): string
export {isUrl} from './minurl.shared.js'

78
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/lib/minurl.browser.js generated vendored Normal file
View File

@@ -0,0 +1,78 @@
/// <reference lib="dom" />
import {isUrl} from './minurl.shared.js'
// See: <https://github.com/nodejs/node/blob/fcf8ba4/lib/internal/url.js>
/**
* @param {string | URL} path
* File URL.
* @returns {string}
* File URL.
*/
export function urlToPath(path) {
if (typeof path === 'string') {
path = new URL(path)
} else if (!isUrl(path)) {
/** @type {NodeJS.ErrnoException} */
const error = new TypeError(
'The "path" argument must be of type string or an instance of URL. Received `' +
path +
'`'
)
error.code = 'ERR_INVALID_ARG_TYPE'
throw error
}
if (path.protocol !== 'file:') {
/** @type {NodeJS.ErrnoException} */
const error = new TypeError('The URL must be of scheme file')
error.code = 'ERR_INVALID_URL_SCHEME'
throw error
}
return getPathFromURLPosix(path)
}
/**
* Get a path from a POSIX URL.
*
* @param {URL} url
* URL.
* @returns {string}
* File path.
*/
function getPathFromURLPosix(url) {
if (url.hostname !== '') {
/** @type {NodeJS.ErrnoException} */
const error = new TypeError(
'File URL host must be "localhost" or empty on darwin'
)
error.code = 'ERR_INVALID_FILE_URL_HOST'
throw error
}
const pathname = url.pathname
let index = -1
while (++index < pathname.length) {
if (
pathname.charCodeAt(index) === 37 /* `%` */ &&
pathname.charCodeAt(index + 1) === 50 /* `2` */
) {
const third = pathname.charCodeAt(index + 2)
if (third === 70 /* `F` */ || third === 102 /* `f` */) {
/** @type {NodeJS.ErrnoException} */
const error = new TypeError(
'File URL path must not include encoded / characters'
)
error.code = 'ERR_INVALID_FILE_URL_PATH'
throw error
}
}
}
return decodeURIComponent(pathname)
}
export {isUrl} from './minurl.shared.js'

2
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/lib/minurl.d.ts generated vendored Normal file
View File

@@ -0,0 +1,2 @@
export {fileURLToPath as urlToPath} from 'url'
export {isUrl} from './minurl.shared.js'

2
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/lib/minurl.js generated vendored Normal file
View File

@@ -0,0 +1,2 @@
export {fileURLToPath as urlToPath} from 'url'
export {isUrl} from './minurl.shared.js'

42
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/lib/minurl.shared.d.ts generated vendored Normal file
View File

@@ -0,0 +1,42 @@
/**
* @typedef URL
* @property {string} hash
* @property {string} host
* @property {string} hostname
* @property {string} href
* @property {string} origin
* @property {string} password
* @property {string} pathname
* @property {string} port
* @property {string} protocol
* @property {string} search
* @property {any} searchParams
* @property {string} username
* @property {() => string} toString
* @property {() => string} toJSON
*/
/**
* Check if `fileUrlOrPath` looks like a URL.
*
* @param {unknown} fileUrlOrPath
* File path or URL.
* @returns {fileUrlOrPath is URL}
* Whether it’s a URL.
*/
export function isUrl(fileUrlOrPath: unknown): fileUrlOrPath is URL
export type URL = {
hash: string
host: string
hostname: string
href: string
origin: string
password: string
pathname: string
port: string
protocol: string
search: string
searchParams: any
username: string
toString: () => string
toJSON: () => string
}

37
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/lib/minurl.shared.js generated vendored Normal file
View File

@@ -0,0 +1,37 @@
/**
* @typedef URL
* @property {string} hash
* @property {string} host
* @property {string} hostname
* @property {string} href
* @property {string} origin
* @property {string} password
* @property {string} pathname
* @property {string} port
* @property {string} protocol
* @property {string} search
* @property {any} searchParams
* @property {string} username
* @property {() => string} toString
* @property {() => string} toJSON
*/
/**
* Check if `fileUrlOrPath` looks like a URL.
*
* @param {unknown} fileUrlOrPath
* File path or URL.
* @returns {fileUrlOrPath is URL}
* Whether it’s a URL.
*/
// From: <https://github.com/nodejs/node/blob/fcf8ba4/lib/internal/url.js#L1501>
export function isUrl(fileUrlOrPath) {
return (
fileUrlOrPath !== null &&
typeof fileUrlOrPath === 'object' &&
// @ts-expect-error: indexable.
fileUrlOrPath.href &&
// @ts-expect-error: indexable.
fileUrlOrPath.origin
)
}

21
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/license generated vendored Normal file
View File

@@ -0,0 +1,21 @@
(The MIT License)
Copyright (c) 2015 Titus Wormer <tituswormer@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

1
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/node_modules/unist-util-stringify-position/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export {stringifyPosition} from './lib/index.js'

1
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/node_modules/unist-util-stringify-position/index.js generated vendored Normal file
View File

@@ -0,0 +1 @@
export {stringifyPosition} from './lib/index.js'

61
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/node_modules/unist-util-stringify-position/lib/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,61 @@
/**
* @typedef {import('unist').Node} Node
* @typedef {import('unist').Point} Point
* @typedef {import('unist').Position} Position
*/
/**
* @typedef NodeLike
* @property {string} type
* @property {PositionLike | null | undefined} [position]
*
* @typedef PositionLike
* @property {PointLike | null | undefined} [start]
* @property {PointLike | null | undefined} [end]
*
* @typedef PointLike
* @property {number | null | undefined} [line]
* @property {number | null | undefined} [column]
* @property {number | null | undefined} [offset]
*/
/**
* Serialize the positional info of a point, position (start and end points),
* or node.
*
* @param {Node | NodeLike | Position | PositionLike | Point | PointLike | null | undefined} [value]
* Node, position, or point.
* @returns {string}
* Pretty printed positional info of a node (`string`).
*
* In the format of a range `ls:cs-le:ce` (when given `node` or `position`)
* or a point `l:c` (when given `point`), where `l` stands for line, `c` for
* column, `s` for `start`, and `e` for end.
* An empty string (`''`) is returned if the given value is neither `node`,
* `position`, nor `point`.
*/
export function stringifyPosition(
value?:
| Node
| NodeLike
| Position
| PositionLike
| Point
| PointLike
| null
| undefined
): string
export type Node = import('unist').Node
export type Point = import('unist').Point
export type Position = import('unist').Position
export type NodeLike = {
type: string
position?: PositionLike | null | undefined
}
export type PositionLike = {
start?: PointLike | null | undefined
end?: PointLike | null | undefined
}
export type PointLike = {
line?: number | null | undefined
column?: number | null | undefined
offset?: number | null | undefined
}

84
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/node_modules/unist-util-stringify-position/lib/index.js generated vendored Normal file
View File

@@ -0,0 +1,84 @@
/**
* @typedef {import('unist').Node} Node
* @typedef {import('unist').Point} Point
* @typedef {import('unist').Position} Position
*/
/**
* @typedef NodeLike
* @property {string} type
* @property {PositionLike | null | undefined} [position]
*
* @typedef PositionLike
* @property {PointLike | null | undefined} [start]
* @property {PointLike | null | undefined} [end]
*
* @typedef PointLike
* @property {number | null | undefined} [line]
* @property {number | null | undefined} [column]
* @property {number | null | undefined} [offset]
*/
/**
* Serialize the positional info of a point, position (start and end points),
* or node.
*
* @param {Node | NodeLike | Position | PositionLike | Point | PointLike | null | undefined} [value]
* Node, position, or point.
* @returns {string}
* Pretty printed positional info of a node (`string`).
*
* In the format of a range `ls:cs-le:ce` (when given `node` or `position`)
* or a point `l:c` (when given `point`), where `l` stands for line, `c` for
* column, `s` for `start`, and `e` for end.
* An empty string (`''`) is returned if the given value is neither `node`,
* `position`, nor `point`.
*/
export function stringifyPosition(value) {
// Nothing.
if (!value || typeof value !== 'object') {
return ''
}
// Node.
if ('position' in value || 'type' in value) {
return position(value.position)
}
// Position.
if ('start' in value || 'end' in value) {
return position(value)
}
// Point.
if ('line' in value || 'column' in value) {
return point(value)
}
// ?
return ''
}
/**
* @param {Point | PointLike | null | undefined} point
* @returns {string}
*/
function point(point) {
return index(point && point.line) + ':' + index(point && point.column)
}
/**
* @param {Position | PositionLike | null | undefined} pos
* @returns {string}
*/
function position(pos) {
return point(pos && pos.start) + '-' + point(pos && pos.end)
}
/**
* @param {number | null | undefined} value
* @returns {number}
*/
function index(value) {
return value && typeof value === 'number' ? value : 1
}

22
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/node_modules/unist-util-stringify-position/license generated vendored Normal file
View File

@@ -0,0 +1,22 @@
(The MIT License)
Copyright (c) 2016 Titus Wormer <tituswormer@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
'Software'), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

80
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/node_modules/unist-util-stringify-position/package.json generated vendored Normal file
View File

@@ -0,0 +1,80 @@
{
"name": "unist-util-stringify-position",
"version": "3.0.3",
"description": "unist utility to serialize a node, position, or point as a human readable location",
"license": "MIT",
"keywords": [
"unist",
"unist-util",
"util",
"utility",
"position",
"location",
"point",
"node",
"stringify",
"tostring"
],
"repository": "syntax-tree/unist-util-stringify-position",
"bugs": "https://github.com/syntax-tree/unist-util-stringify-position/issues",
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
},
"author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
"contributors": [
"Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
],
"sideEffects": false,
"type": "module",
"main": "index.js",
"types": "index.d.ts",
"files": [
"lib/",
"index.d.ts",
"index.js"
],
"dependencies": {
"@types/unist": "^2.0.0"
},
"devDependencies": {
"@types/mdast": "^3.0.0",
"@types/node": "^18.0.0",
"c8": "^7.0.0",
"prettier": "^2.0.0",
"remark-cli": "^11.0.0",
"remark-preset-wooorm": "^9.0.0",
"type-coverage": "^2.0.0",
"typescript": "^4.0.0",
"xo": "^0.53.0"
},
"scripts": {
"prepack": "npm run build && npm run format",
"build": "tsc --build --clean && tsc --build && type-coverage",
"format": "remark . -qfo && prettier . -w --loglevel warn && xo --fix",
"test-api": "node --conditions development test.js",
"test-coverage": "c8 --check-coverage --100 --reporter lcov npm run test-api",
"test": "npm run build && npm run format && npm run test-coverage"
},
"prettier": {
"tabWidth": 2,
"useTabs": false,
"singleQuote": true,
"bracketSpacing": false,
"semi": false,
"trailingComma": "none"
},
"xo": {
"prettier": true
},
"remarkConfig": {
"plugins": [
"preset-wooorm"
]
},
"typeCoverage": {
"atLeast": 100,
"detail": true,
"strict": true
}
}

203
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/node_modules/unist-util-stringify-position/readme.md generated vendored Normal file
View File

@@ -0,0 +1,203 @@
# unist-util-stringify-position
[![Build][build-badge]][build]
[![Coverage][coverage-badge]][coverage]
[![Downloads][downloads-badge]][downloads]
[![Size][size-badge]][size]
[![Sponsors][sponsors-badge]][collective]
[![Backers][backers-badge]][collective]
[![Chat][chat-badge]][chat]
[unist][] utility to pretty print the positional info of a node.
## Contents
* [What is this?](#what-is-this)
* [When should I use this?](#when-should-i-use-this)
* [Install](#install)
* [Use](#use)
* [API](#api)
* [`stringifyPosition(node|position|point)`](#stringifypositionnodepositionpoint)
* [Types](#types)
* [Compatibility](#compatibility)
* [Security](#security)
* [Related](#related)
* [Contribute](#contribute)
* [License](#license)
## What is this?
This package is a utility that takes any [unist][] (whether mdast, hast, etc)
node, position, or point, and serializes its positional info.
## When should I use this?
This utility is useful to display where something occurred in the original
document, in one standard way, for humans.
For example, when throwing errors or warning messages about something.
## Install
This package is [ESM only][esm].
In Node.js (version 14.14+ and 16.0+), install with [npm][]:
```sh
npm install unist-util-stringify-position
```
In Deno with [`esm.sh`][esmsh]:
```js
import {stringifyPosition} from 'https://esm.sh/unist-util-stringify-position@3'
```
In browsers with [`esm.sh`][esmsh]:
```html
<script type="module">
import {stringifyPosition} from 'https://esm.sh/unist-util-stringify-position@3?bundle'
</script>
```
## Use
```js
import {stringifyPosition} from 'unist-util-stringify-position'
stringifyPosition({line: 2, column: 3}) // => '2:3' (point)
stringifyPosition({start: {line: 2}, end: {line: 3}}) // => '2:1-3:1' (position)
stringifyPosition({
type: 'text',
value: '!',
position: {
start: {line: 5, column: 11},
end: {line: 5, column: 12}
}
}) // => '5:11-5:12' (node)
```
## API
This package exports the identifier [`stringifyPosition`][stringifyposition].
There is no default export.
### `stringifyPosition(node|position|point)`
Serialize the positional info of a point, position (start and end points), or
node.
###### Parameters
* `node` ([`Node`][node])
— node whose `position` fields to serialize
* `position` ([`Position`][position])
— position whose `start` and `end` points to serialize
* `point` ([`Point`][point])
— point whose `line` and `column` fields to serialize
###### Returns
Pretty printed positional info of a node (`string`).
In the format of a range `ls:cs-le:ce` (when given `node` or `position`) or a
point `l:c` (when given `point`), where `l` stands for line, `c` for column, `s`
for `start`, and `e` for end.
An empty string (`''`) is returned if the given value is neither `node`,
`position`, nor `point`.
## Types
This package is fully typed with [TypeScript][].
It exports no additional types.
## Compatibility
Projects maintained by the unified collective are compatible with all maintained
versions of Node.js.
As of now, that is Node.js 14.14+ and 16.0+.
Our projects sometimes work with older versions, but this is not guaranteed.
## Security
This project is safe.
## Related
* [`unist-util-generated`](https://github.com/syntax-tree/unist-util-generated)
— check if a node is generated
* [`unist-util-position`](https://github.com/syntax-tree/unist-util-position)
— get positional info of nodes
* [`unist-util-remove-position`](https://github.com/syntax-tree/unist-util-remove-position)
— remove positional info from trees
* [`unist-util-source`](https://github.com/syntax-tree/unist-util-source)
— get the source of a value (node or position) in a file
## Contribute
See [`contributing.md` in `syntax-tree/.github`][contributing] for ways to get
started.
See [`support.md`][support] for ways to get help.
This project has a [code of conduct][coc].
By interacting with this repository, organization, or community you agree to
abide by its terms.
## License
[MIT][license] © [Titus Wormer][author]
<!-- Definition -->
[build-badge]: https://github.com/syntax-tree/unist-util-stringify-position/workflows/main/badge.svg
[build]: https://github.com/syntax-tree/unist-util-stringify-position/actions
[coverage-badge]: https://img.shields.io/codecov/c/github/syntax-tree/unist-util-stringify-position.svg
[coverage]: https://codecov.io/github/syntax-tree/unist-util-stringify-position
[downloads-badge]: https://img.shields.io/npm/dm/unist-util-stringify-position.svg
[downloads]: https://www.npmjs.com/package/unist-util-stringify-position
[size-badge]: https://img.shields.io/bundlephobia/minzip/unist-util-stringify-position.svg
[size]: https://bundlephobia.com/result?p=unist-util-stringify-position
[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
[backers-badge]: https://opencollective.com/unified/backers/badge.svg
[collective]: https://opencollective.com/unified
[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
[chat]: https://github.com/syntax-tree/unist/discussions
[npm]: https://docs.npmjs.com/cli/install
[license]: license
[author]: https://wooorm.com
[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
[esmsh]: https://esm.sh
[typescript]: https://www.typescriptlang.org
[contributing]: https://github.com/syntax-tree/.github/blob/HEAD/contributing.md
[support]: https://github.com/syntax-tree/.github/blob/HEAD/support.md
[coc]: https://github.com/syntax-tree/.github/blob/HEAD/code-of-conduct.md
[unist]: https://github.com/syntax-tree/unist
[node]: https://github.com/syntax-tree/unist#node
[position]: https://github.com/syntax-tree/unist#position
[point]: https://github.com/syntax-tree/unist#point
[stringifyposition]: #stringifypositionnodepositionpoint

1
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/node_modules/vfile-message/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export {VFileMessage} from './lib/index.js'

1
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/node_modules/vfile-message/index.js generated vendored Normal file
View File

@@ -0,0 +1 @@
export {VFileMessage} from './lib/index.js'

125
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/node_modules/vfile-message/lib/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,125 @@
/**
* Message.
*/
export class VFileMessage extends Error {
/**
* Create a message for `reason` at `place` from `origin`.
*
* When an error is passed in as `reason`, the `stack` is copied.
*
* @param {string | Error | VFileMessage} reason
* Reason for message, uses the stack and message of the error if given.
*
* > 👉 **Note**: you should use markdown.
* @param {Node | NodeLike | Position | Point | null | undefined} [place]
* Place in file where the message occurred.
* @param {string | null | undefined} [origin]
* Place in code where the message originates (example:
* `'my-package:my-rule'` or `'my-rule'`).
* @returns
* Instance of `VFileMessage`.
*/
constructor(
reason: string | Error | VFileMessage,
place?: Node | NodeLike | Position | Point | null | undefined,
origin?: string | null | undefined
)
/**
* Stack of message.
*
* This is used by normal errors to show where something happened in
* programming code, irrelevant for `VFile` messages,
*
* @type {string}
*/
stack: string
/**
* Reason for message.
*
* > 👉 **Note**: you should use markdown.
*
* @type {string}
*/
reason: string
/**
* State of problem.
*
* * `true` — marks associated file as no longer processable (error)
* * `false` — necessitates a (potential) change (warning)
* * `null | undefined` — for things that might not need changing (info)
*
* @type {boolean | null | undefined}
*/
fatal: boolean | null | undefined
/**
* Starting line of error.
*
* @type {number | null}
*/
line: number | null
/**
* Starting column of error.
*
* @type {number | null}
*/
column: number | null
/**
* Full unist position.
*
* @type {Position | null}
*/
position: Position | null
/**
* Namespace of message (example: `'my-package'`).
*
* @type {string | null}
*/
source: string | null
/**
* Category of message (example: `'my-rule'`).
*
* @type {string | null}
*/
ruleId: string | null
/**
* Path of a file (used throughout the `VFile` ecosystem).
*
* @type {string | null}
*/
file: string | null
/**
* Specify the source value that’s being reported, which is deemed
* incorrect.
*
* @type {string | null}
*/
actual: string | null
/**
* Suggest acceptable values that can be used instead of `actual`.
*
* @type {Array<string> | null}
*/
expected: Array<string> | null
/**
* Link to docs for the message.
*
* > 👉 **Note**: this must be an absolute URL that can be passed as `x`
* > to `new URL(x)`.
*
* @type {string | null}
*/
url: string | null
/**
* Long form description of the message (you should use markdown).
*
* @type {string | null}
*/
note: string | null
}
export type Node = import('unist').Node
export type Position = import('unist').Position
export type Point = import('unist').Point
export type NodeLike = object & {
type: string
position?: Position | undefined
}

225
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/node_modules/vfile-message/lib/index.js generated vendored Normal file
View File

@@ -0,0 +1,225 @@
/**
* @typedef {import('unist').Node} Node
* @typedef {import('unist').Position} Position
* @typedef {import('unist').Point} Point
* @typedef {object & {type: string, position?: Position | undefined}} NodeLike
*/
import {stringifyPosition} from 'unist-util-stringify-position'
/**
* Message.
*/
export class VFileMessage extends Error {
/**
* Create a message for `reason` at `place` from `origin`.
*
* When an error is passed in as `reason`, the `stack` is copied.
*
* @param {string | Error | VFileMessage} reason
* Reason for message, uses the stack and message of the error if given.
*
* > 👉 **Note**: you should use markdown.
* @param {Node | NodeLike | Position | Point | null | undefined} [place]
* Place in file where the message occurred.
* @param {string | null | undefined} [origin]
* Place in code where the message originates (example:
* `'my-package:my-rule'` or `'my-rule'`).
* @returns
* Instance of `VFileMessage`.
*/
// To do: next major: expose `undefined` everywhere instead of `null`.
constructor(reason, place, origin) {
/** @type {[string | null, string | null]} */
const parts = [null, null]
/** @type {Position} */
let position = {
// @ts-expect-error: we always follows the structure of `position`.
start: {line: null, column: null},
// @ts-expect-error: "
end: {line: null, column: null}
}
super()
if (typeof place === 'string') {
origin = place
place = undefined
}
if (typeof origin === 'string') {
const index = origin.indexOf(':')
if (index === -1) {
parts[1] = origin
} else {
parts[0] = origin.slice(0, index)
parts[1] = origin.slice(index + 1)
}
}
if (place) {
// Node.
if ('type' in place || 'position' in place) {
if (place.position) {
// To do: next major: deep clone.
// @ts-expect-error: looks like a position.
position = place.position
}
}
// Position.
else if ('start' in place || 'end' in place) {
// @ts-expect-error: looks like a position.
// To do: next major: deep clone.
position = place
}
// Point.
else if ('line' in place || 'column' in place) {
// To do: next major: deep clone.
position.start = place
}
}
// Fields from `Error`.
/**
* Serialized positional info of error.
*
* On normal errors, this would be something like `ParseError`, buit in
* `VFile` messages we use this space to show where an error happened.
*/
this.name = stringifyPosition(place) || '1:1'
/**
* Reason for message.
*
* @type {string}
*/
this.message = typeof reason === 'object' ? reason.message : reason
/**
* Stack of message.
*
* This is used by normal errors to show where something happened in
* programming code, irrelevant for `VFile` messages,
*
* @type {string}
*/
this.stack = ''
if (typeof reason === 'object' && reason.stack) {
this.stack = reason.stack
}
/**
* Reason for message.
*
* > 👉 **Note**: you should use markdown.
*
* @type {string}
*/
this.reason = this.message
/* eslint-disable no-unused-expressions */
/**
* State of problem.
*
* * `true` — marks associated file as no longer processable (error)
* * `false` — necessitates a (potential) change (warning)
* * `null | undefined` — for things that might not need changing (info)
*
* @type {boolean | null | undefined}
*/
this.fatal
/**
* Starting line of error.
*
* @type {number | null}
*/
this.line = position.start.line
/**
* Starting column of error.
*
* @type {number | null}
*/
this.column = position.start.column
/**
* Full unist position.
*
* @type {Position | null}
*/
this.position = position
/**
* Namespace of message (example: `'my-package'`).
*
* @type {string | null}
*/
this.source = parts[0]
/**
* Category of message (example: `'my-rule'`).
*
* @type {string | null}
*/
this.ruleId = parts[1]
/**
* Path of a file (used throughout the `VFile` ecosystem).
*
* @type {string | null}
*/
this.file
// The following fields are “well known”.
// Not standard.
// Feel free to add other non-standard fields to your messages.
/**
* Specify the source value that’s being reported, which is deemed
* incorrect.
*
* @type {string | null}
*/
this.actual
/**
* Suggest acceptable values that can be used instead of `actual`.
*
* @type {Array<string> | null}
*/
this.expected
/**
* Link to docs for the message.
*
* > 👉 **Note**: this must be an absolute URL that can be passed as `x`
* > to `new URL(x)`.
*
* @type {string | null}
*/
this.url
/**
* Long form description of the message (you should use markdown).
*
* @type {string | null}
*/
this.note
/* eslint-enable no-unused-expressions */
}
}
VFileMessage.prototype.file = ''
VFileMessage.prototype.name = ''
VFileMessage.prototype.reason = ''
VFileMessage.prototype.message = ''
VFileMessage.prototype.stack = ''
VFileMessage.prototype.fatal = null
VFileMessage.prototype.column = null
VFileMessage.prototype.line = null
VFileMessage.prototype.source = null
VFileMessage.prototype.ruleId = null
VFileMessage.prototype.position = null

22
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/node_modules/vfile-message/license generated vendored Normal file
View File

@@ -0,0 +1,22 @@
(The MIT License)
Copyright (c) 2017 Titus Wormer <tituswormer@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
'Software'), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

78
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/node_modules/vfile-message/package.json generated vendored Normal file
View File

@@ -0,0 +1,78 @@
{
"name": "vfile-message",
"version": "3.1.4",
"description": "vfile utility to create a virtual message",
"license": "MIT",
"keywords": [
"vfile",
"vfile-util",
"util",
"utility",
"virtual",
"file",
"message"
],
"repository": "vfile/vfile-message",
"bugs": "https://github.com/vfile/vfile-message/issues",
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
},
"author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
"contributors": [
"Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
],
"sideEffects": false,
"type": "module",
"main": "index.js",
"types": "index.d.ts",
"files": [
"lib/",
"index.d.ts",
"index.js"
],
"dependencies": {
"@types/unist": "^2.0.0",
"unist-util-stringify-position": "^3.0.0"
},
"devDependencies": {
"@types/node": "^18.0.0",
"c8": "^7.0.0",
"prettier": "^2.0.0",
"remark-cli": "^11.0.0",
"remark-preset-wooorm": "^9.0.0",
"type-coverage": "^2.0.0",
"typescript": "^4.0.0",
"xo": "^0.53.0"
},
"scripts": {
"prepack": "npm run build && npm run format",
"build": "tsc --build --clean && tsc --build && type-coverage",
"format": "remark . -qfo && prettier . -w --loglevel warn && xo --fix",
"test-api": "node --conditions development test.js",
"test-coverage": "c8 --check-coverage --100 --reporter lcov npm run test-api",
"test": "npm run build && npm run format && npm run test-coverage"
},
"prettier": {
"tabWidth": 2,
"useTabs": false,
"singleQuote": true,
"bracketSpacing": false,
"semi": false,
"trailingComma": "none"
},
"xo": {
"prettier": true
},
"remarkConfig": {
"plugins": [
"preset-wooorm"
]
},
"typeCoverage": {
"atLeast": 100,
"detail": true,
"strict": true,
"ignoreCatch": true
}
}

244
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/node_modules/vfile-message/readme.md generated vendored Normal file
View File

@@ -0,0 +1,244 @@
# vfile-message
[![Build][build-badge]][build]
[![Coverage][coverage-badge]][coverage]
[![Downloads][downloads-badge]][downloads]
[![Size][size-badge]][size]
[![Sponsors][sponsors-badge]][collective]
[![Backers][backers-badge]][collective]
[![Chat][chat-badge]][chat]
Create [vfile][] messages.
## Contents
* [What is this?](#what-is-this)
* [When should I use this?](#when-should-i-use-this)
* [Install](#install)
* [Use](#use)
* [API](#api)
* [`VFileMessage(reason[, place][, origin])`](#vfilemessagereason-place-origin)
* [Well-known](#well-known)
* [Types](#types)
* [Compatibility](#compatibility)
* [Contribute](#contribute)
* [License](#license)
## What is this?
This package provides a (lint) message format.
## When should I use this?
In most cases, you can use `file.message` from `VFile` itself, but in some
cases you might not have a file, and still want to emit warnings or errors,
in which case this can be used directly.
## Install
This package is [ESM only][esm].
In Node.js (version 14.14+ and 16.0+), install with [npm][]:
```sh
npm install vfile-message
```
In Deno with [`esm.sh`][esmsh]:
```js
import {VFileMessage} from 'https://esm.sh/vfile-message@3'
```
In browsers with [`esm.sh`][esmsh]:
```html
<script type="module">
import {VFileMessage} from 'https://esm.sh/vfile-message@3?bundle'
</script>
```
## Use
```js
import {VFileMessage} from 'vfile-message'
const message = new VFileMessage(
'Unexpected unknown word `braavo`, did you mean `bravo`?',
{line: 1, column: 8},
'spell:typo'
)
console.log(message)
```
Yields:
```txt
[1:8: Unexpected unknown word `braavo`, did you mean `bravo`?] {
reason: 'Unexpected unknown word `braavo`, did you mean `bravo`?',
line: 1,
column: 8,
source: 'spell',
ruleId: 'typo',
position: {start: {line: 1, column: 8}, end: {line: null, column: null}}
}
```
## API
This package exports the identifier [`VFileMessage`][api-vfile-message].
There is no default export.
### `VFileMessage(reason[, place][, origin])`
Create a message for `reason` at `place` from `origin`.
When an error is passed in as `reason`, the `stack` is copied.
###### Parameters
* `reason` (`string` or `Error`)
— reason for message, uses the stack and message of the error if given
* `place` ([`Node`][node], [`Position`][position], or [`Point`][point],
optional)
— place in file where the message occurred
* `origin` (`string`, optional)
— place in code where the message originates (example:
`'my-package:my-rule'` or `'my-rule'`)
###### Extends
[`Error`][error].
###### Returns
Instance of `VFileMessage`.
###### Fields
* `reason` (`string`)
— reason for message (you should use markdown)
* `fatal` (`boolean | null | undefined`)
— state of problem; `true` marks associated file as no longer processable
(error); `false` necessitates a (potential) change (warning);
`null | undefined` for things that might not need changing (info)
* `line` (`number | null`)
— starting line of error
* `column` (`number | null`)
— starting column of error
* `position` ([`Position | null`][position])
— full unist position
* `source` (`string | null`, example: `'my-package'`)
— namespace of message
* `ruleId` (`string | null`, example: `'my-rule'`)
— category of message
* `stack` (`string | null`)
— stack of message in code
* `file` (`string | null`)
— path of a file (used throughout the `VFile` ecosystem)
### Well-known
It’s OK to store custom data directly on the `VFileMessage`, some of those are
handled by [utilities][util].
The following fields are documented and typed here.
###### Fields
* `actual` (`string | null`)
— specify the source value that’s being reported, which is deemed incorrect
* `expected` (`Array<string> | null`)
— suggest acceptable values that can be used instead of `actual`
* `url` (`string | null`)
— link to docs for the message (this must be an absolute URL that can be
passed as `x` to `new URL(x)`)
* `note` (`string | null`)
— long form description of the message (you should use markdown)
## Types
This package is fully typed with [TypeScript][].
It exports no additional types.
## Compatibility
Projects maintained by the unified collective are compatible with all maintained
versions of Node.js.
As of now, that is Node.js 14.14+ and 16.0+.
Our projects sometimes work with older versions, but this is not guaranteed.
## Contribute
See [`contributing.md`][contributing] in [`vfile/.github`][health] for ways to
get started.
See [`support.md`][support] for ways to get help.
This project has a [code of conduct][coc].
By interacting with this repository, organization, or community you agree to
abide by its terms.
## License
[MIT][license] © [Titus Wormer][author]
<!-- Definitions -->
[build-badge]: https://github.com/vfile/vfile-message/workflows/main/badge.svg
[build]: https://github.com/vfile/vfile-message/actions
[coverage-badge]: https://img.shields.io/codecov/c/github/vfile/vfile-message.svg
[coverage]: https://codecov.io/github/vfile/vfile-message
[downloads-badge]: https://img.shields.io/npm/dm/vfile-message.svg
[downloads]: https://www.npmjs.com/package/vfile-message
[size-badge]: https://img.shields.io/bundlephobia/minzip/vfile-message.svg
[size]: https://bundlephobia.com/result?p=vfile-message
[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
[backers-badge]: https://opencollective.com/unified/backers/badge.svg
[collective]: https://opencollective.com/unified
[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
[chat]: https://github.com/vfile/vfile/discussions
[npm]: https://docs.npmjs.com/cli/install
[contributing]: https://github.com/vfile/.github/blob/main/contributing.md
[support]: https://github.com/vfile/.github/blob/main/support.md
[health]: https://github.com/vfile/.github
[coc]: https://github.com/vfile/.github/blob/main/code-of-conduct.md
[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
[esmsh]: https://esm.sh
[typescript]: https://www.typescriptlang.org
[license]: license
[author]: https://wooorm.com
[error]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
[node]: https://github.com/syntax-tree/unist#node
[position]: https://github.com/syntax-tree/unist#position
[point]: https://github.com/syntax-tree/unist#point
[vfile]: https://github.com/vfile/vfile
[util]: https://github.com/vfile/vfile#utilities
[api-vfile-message]: #vfilemessagereason-place-origin

111
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/package.json generated vendored Normal file
View File

@@ -0,0 +1,111 @@
{
"name": "vfile",
"version": "5.3.7",
"description": "Virtual file format for text processing",
"license": "MIT",
"keywords": [
"vfile",
"virtual",
"file",
"text",
"processing",
"message",
"warning",
"error",
"remark",
"retext",
"rehype"
],
"repository": "vfile/vfile",
"bugs": "https://github.com/vfile/vfile/issues",
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
},
"author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
"contributors": [
"Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
"Brendan Abbott <brendan.abbott@temando.com>",
"Denys Dovhan <email@denysdovhan.com>",
"Kyle Mathews <mathews.kyle@gmail.com>",
"Shinnosuke Watanabe <snnskwtnb@gmail.com>",
"Sindre Sorhus <sindresorhus@gmail.com>"
],
"sideEffects": false,
"type": "module",
"main": "index.js",
"types": "index.d.ts",
"browser": {
"./lib/minpath.js": "./lib/minpath.browser.js",
"./lib/minproc.js": "./lib/minproc.browser.js",
"./lib/minurl.js": "./lib/minurl.browser.js"
},
"react-native": {
"./lib/minpath.js": "./lib/minpath.browser.js",
"./lib/minproc.js": "./lib/minproc.browser.js",
"./lib/minurl.js": "./lib/minurl.browser.js"
},
"files": [
"lib/",
"index.d.ts",
"index.js"
],
"dependencies": {
"@types/unist": "^2.0.0",
"is-buffer": "^2.0.0",
"unist-util-stringify-position": "^3.0.0",
"vfile-message": "^3.0.0"
},
"devDependencies": {
"@types/node": "^18.0.0",
"c8": "^7.0.0",
"prettier": "^2.0.0",
"remark-cli": "^11.0.0",
"remark-preset-wooorm": "^9.0.0",
"type-coverage": "^2.0.0",
"typescript": "^4.0.0",
"xo": "^0.53.0"
},
"scripts": {
"prepack": "npm run build && npm run format",
"build": "tsc --build --clean && tsc --build && type-coverage",
"format": "remark . -qfo && prettier . -w --loglevel warn && xo --fix",
"test-api": "node --conditions development test.js",
"test-coverage": "c8 --check-coverage --100 --reporter lcov npm run test-api",
"test": "npm run build && npm run format && npm run test-coverage"
},
"prettier": {
"tabWidth": 2,
"useTabs": false,
"singleQuote": true,
"bracketSpacing": false,
"semi": false,
"trailingComma": "none"
},
"xo": {
"prettier": true,
"rules": {
"unicorn/prefer-code-point": "off",
"unicorn/prefer-node-protocol": "off"
}
},
"remarkConfig": {
"plugins": [
"preset-wooorm",
[
"lint-no-html",
false
]
]
},
"typeCoverage": {
"atLeast": 100,
"detail": true,
"strict": true,
"ignoreCatch": true,
"#": "needed `any`s",
"ignoreFiles": [
"lib/minurl.shared.d.ts"
]
}
}

786
node_modules/retext-stringify/node_modules/unified/node_modules/vfile/readme.md generated vendored Normal file
View File

@@ -0,0 +1,786 @@
<h1>
<img src="https://raw.githubusercontent.com/vfile/vfile/fc8164b/logo.svg?sanitize=true" alt="vfile" />
</h1>
[![Build][build-badge]][build]
[![Coverage][coverage-badge]][coverage]
[![Downloads][downloads-badge]][downloads]
[![Size][size-badge]][size]
[![Sponsors][sponsors-badge]][collective]
[![Backers][backers-badge]][collective]
[![Chat][chat-badge]][chat]
**vfile** is a small and browser friendly virtual file format that tracks
metadata about files (such as its `path` and `value`) and lint [messages][].
## Contents
* [unified](#unified)
* [What is this?](#what-is-this)
* [When should I use this?](#when-should-i-use-this)
* [Install](#install)
* [Use](#use)
* [API](#api)
* [`VFile(options?)`](#vfileoptions)
* [`file.value`](#filevalue)
* [`file.cwd`](#filecwd)
* [`file.path`](#filepath)
* [`file.dirname`](#filedirname)
* [`file.basename`](#filebasename)
* [`file.extname`](#fileextname)
* [`file.stem`](#filestem)
* [`file.history`](#filehistory)
* [`file.messages`](#filemessages)
* [`file.data`](#filedata)
* [`VFile#toString(encoding?)`](#vfiletostringencoding)
* [`VFile#message(reason[, position][, origin])`](#vfilemessagereason-position-origin)
* [`VFile#info(reason[, position][, origin])`](#vfileinforeason-position-origin)
* [`VFile#fail(reason[, position][, origin])`](#vfilefailreason-position-origin)
* [`BufferEncoding`](#bufferencoding)
* [`Compatible`](#compatible)
* [`Data`](#data)
* [`DataMap`](#datamap)
* [`Map`](#map)
* [`Options`](#options)
* [`Reporter`](#reporter)
* [`ReporterSettings`](#reportersettings)
* [`Value`](#value)
* [Well-known](#well-known)
* [List of utilities](#list-of-utilities)
* [Reporters](#reporters)
* [Types](#types)
* [Compatibility](#compatibility)
* [Contribute](#contribute)
* [Sponsor](#sponsor)
* [Acknowledgments](#acknowledgments)
* [License](#license)
## unified
**vfile** is part of the unified collective.
* for more about us, see [`unifiedjs.com`][site]
* for how the collective is governed, see [`unifiedjs/collective`][governance]
* for updates, see [@unifiedjs][twitter] on Twitter
## What is this?
This package provides a virtual file format.
It exposes an API to access the file value, path, metadata about the file, and
specifically supports attaching lint messages and errors to certain places in
these files.
## When should I use this?
The virtual file format is useful when dealing with the concept of files in
places where you might not be able to access the file system.
The message API is particularly useful when making things that check files (as
in, linting).
vfile is made for [unified][], which amongst other things checks files.
However, vfile can be used in other projects that deal with parsing,
transforming, and serializing data, to build linters, compilers, static site
generators, and other build tools.
This is different from the excellent [`vinyl`][vinyl] in that vfile has a
smaller API, a smaller size, and focuses on messages.
## Install
This package is [ESM only][esm].
In Node.js (version 14.14 and 16.0+), install with [npm][]:
```sh
npm install vfile
```
In Deno with [`esm.sh`][esmsh]:
```js
import {VFile} from 'https://esm.sh/vfile@5'
```
In browsers with [`esm.sh`][esmsh]:
```html
<script type="module">
import {VFile} from 'https://esm.sh/vfile@5?bundle'
</script>
```
## Use
```js
import {VFile} from 'vfile'
const file = new VFile({
path: '~/example.txt',
value: 'Alpha *braavo* charlie.'
})
console.log(file.path) // => '~/example.txt'
console.log(file.dirname) // => '~'
file.extname = '.md'
console.log(file.basename) // => 'example.md'
file.basename = 'index.text'
console.log(file.history) // => ['~/example.txt', '~/example.md', '~/index.text']
file.message('Unexpected unknown word `braavo`, did you mean `bravo`?', {
line: 1,
column: 8
})
console.log(file.messages)
```
Yields:
```txt
[
[~/index.text:1:8: Unexpected unknown word `braavo`, did you mean `bravo`?] {
reason: 'Unexpected unknown word `braavo`, did you mean `bravo`?',
line: 1,
column: 8,
source: null,
ruleId: null,
position: {start: [Object], end: [Object]},
file: '~/index.text',
fatal: false
}
]
```
## API
This package exports the identifier [`VFile`][api-vfile].
There is no default export.
### `VFile(options?)`
Create a new virtual file.
`options` is treated as:
* `string` or [`Buffer`][buffer] — `{value: options}`
* `URL` — `{path: options}`
* `VFile` — shallow copies its data over to the new file
* `object` — all fields are shallow copied over to the new file
Path related fields are set in the following order (least specific to
most specific): `history`, `path`, `basename`, `stem`, `extname`,
`dirname`.
You cannot set `dirname` or `extname` without setting either `history`,
`path`, `basename`, or `stem` too.
###### Parameters
* `options` ([`Compatible`][api-compatible], optional)
— file value
###### Returns
New instance (`VFile`).
###### Example
```js
new VFile()
new VFile('console.log("alpha");')
new VFile(Buffer.from('exit 1'))
new VFile({path: path.join('path', 'to', 'readme.md')})
new VFile({stem: 'readme', extname: '.md', dirname: path.join('path', 'to')})
new VFile({other: 'properties', are: 'copied', ov: {e: 'r'}})
```
### `file.value`
Raw value ([`Buffer`][buffer], `string`, `null`).
### `file.cwd`
Base of `path` (`string`, default: `process.cwd()` or `'/'` in browsers).
### `file.path`
Get or set the full path (`string?`, example: `'~/index.min.js'`).
Cannot be nullified.
You can set a file URL (a `URL` object with a `file:` protocol) which will be
turned into a path with [`url.fileURLToPath`][file-url-to-path].
### `file.dirname`
Get or set the parent path (`string?`, example: `'~'`).
Cannot be set if there’s no `path` yet.
### `file.basename`
Get or set the basename (including extname) (`string?`, example: `'index.min.js'`).
Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` on
windows).
Cannot be nullified (use `file.path = file.dirname` instead).
### `file.extname`
Get or set the extname (including dot) (`string?`, example: `'.js'`).
Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` on
windows).
Cannot be set if there’s no `path` yet.
### `file.stem`
Get or set the stem (basename w/o extname) (`string?`, example: `'index.min'`).
Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'` on
windows).
Cannot be nullified.
### `file.history`
List of filepaths the file moved between (`Array<string>`).
The first is the original path and the last is the current path.
### `file.messages`
List of messages associated with the file ([`Array<VFileMessage>`][message]).
### `file.data`
Place to store custom information (`Record<string, unknown>`, default: `{}`).
It’s OK to store custom data directly on the file but moving it to `data` is
recommended.
### `VFile#toString(encoding?)`
Serialize the file.
###### Parameters
* `encoding` ([`BufferEncoding`][api-buffer-encoding], default: `'utf8'`)
— character encoding to understand `value` as when it’s a
[`Buffer`][buffer]
###### Returns
Serialized file (`string`).
### `VFile#message(reason[, position][, origin])`
Create a warning message associated with the file.
Its `fatal` is set to `false` and `file` is set to the current file path.
Its added to `file.messages`.
###### Parameters
* `reason` (`string` or `Error`)
— reason for message, uses the stack and message of the error if given
* `place` (`Node`, `Position`, or `Point`, optional)
— place in file where the message occurred
* `origin` (`string?`, optional, example: `'my-package:my-rule'` or `'my-rule'`)
— place in code where the message originates
###### Returns
Message ([`VFileMessage`][vmessage]).
### `VFile#info(reason[, position][, origin])`
Create an info message associated with the file.
Its `fatal` is set to `null` and `file` is set to the current file path.
Its added to `file.messages`.
###### Parameters
* `reason` (`string` or `Error`)
— reason for message, uses the stack and message of the error if given
* `place` (`Node`, `Position`, or `Point`, optional)
— place in file where the message occurred
* `origin` (`string?`, optional, example: `'my-package:my-rule'` or `'my-rule'`)
— place in code where the message originates
###### Returns
Message ([`VFileMessage`][vmessage]).
### `VFile#fail(reason[, position][, origin])`
Create a fatal error associated with the file.
Its `fatal` is set to `true` and `file` is set to the current file path.
Its added to `file.messages`.
> 👉 **Note**: a fatal error means that a file is no longer processable.
###### Parameters
* `reason` (`string` or `Error`)
— reason for message, uses the stack and message of the error if given
* `place` (`Node`, `Position`, or `Point`, optional)
— place in file where the message occurred
* `origin` (`string?`, optional, example: `'my-package:my-rule'` or `'my-rule'`)
— place in code where the message originates
###### Returns
Nothing (`never`).
###### Throws
Message ([`VFileMessage`][vmessage]).
### `BufferEncoding`
[Encodings][encoding] supported by the [buffer][] class (TypeScript type).
This is a copy of the types from Node.
###### Type
```ts
type BufferEncoding =
| 'ascii'
| 'utf8'
| 'utf-8'
| 'utf16le'
| 'ucs2'
| 'ucs-2'
| 'base64'
| 'base64url'
| 'latin1'
| 'binary'
| 'hex'
```
### `Compatible`
Things that can be passed to the constructor (TypeScript type).
###### Type
```ts
type Compatible = Options | URL | Value | VFile
```
### `Data`
Custom information (TypeScript type).
Known attributes can be added to [`DataMap`][api-data-map].
###### Type
```ts
type Data = Record<string, unknown> & Partial<DataMap>
```
### `DataMap`
This map registers the type of the `data` key of a `VFile` (TypeScript type).
This type can be augmented to register custom `data` types.
###### Type
```ts
interface DataMap {}
```
###### Example
```ts
declare module 'vfile' {
interface DataMap {
// `file.data.name` is typed as `string`
name: string
}
}
```
### `Map`
Raw source map (TypeScript type).
See [`source-map`][source-map].
###### Fields
* `version` (`number`)
— which version of the source map spec this map is following
* `sources` (`Array<string>`)
— an array of URLs to the original source files
* `names` (`Array<string>`)
— an array of identifiers which can be referenced by individual mappings
* `sourceRoot` (`string`, optional)
— the URL root from which all sources are relative
* `sourcesContent` (`Array<string>`, optional)
— an array of contents of the original source files
* `mappings` (`string`)
— a string of base64 VLQs which contain the actual mappings
* `file` (`string`)
— the generated file this source map is associated with
### `Options`
An object with arbitrary fields and the following known fields (TypeScript
type).
###### Fields
* `value` ([`Value`][api-value], optional)
— set `value`
* `cwd` (`string`, optional)
— set `cwd`
* `history` (`Array<string>`, optional)
— set `history`
* `path` (`URL | string`, optional)
— set `path`
* `basename` (`string`, optional)
— set `basename`
* `stem` (`string`, optional)
— set `stem`
* `extname` (`string`, optional)
— set `extname`
* `dirname` (`string`, optional)
— set `dirname`
* `data` ([`Data`][api-data], optional)
— set `data`
### `Reporter`
Type for a reporter (TypeScript type).
###### Type
```ts
type Reporter<Settings extends ReporterSettings> = (
files: Array<VFile>,
options: Settings
) => string
```
### `ReporterSettings`
Configuration for reporters (TypeScript type).
###### Type
```ts
type ReporterSettings = Record<string, unknown>
```
### `Value`
Contents of the file (TypeScript type).
Can either be text or a `Buffer` structure.
###### Type
```ts
type Value = string | Buffer
```
### Well-known
The following fields are considered “non-standard”, but they are allowed, and
some utilities use them:
* `stored` (`boolean`)
— whether a file was saved to disk; this is used by vfile reporters
* `result` (`unknown`)
— custom, non-string, compiled, representation; this is used by unified to
store non-string results; one example is when turning markdown into React
nodes
* `map` ([`Map`][api-map])
— source map; this type is equivalent to the `RawSourceMap` type from the
`source-map` module
There are also well-known fields on messages, see
[them in a similar section of
`vfile-message`](https://github.com/vfile/vfile-message#well-known).
<a name="utilities"></a>
## List of utilities
* [`convert-vinyl-to-vfile`](https://github.com/dustinspecker/convert-vinyl-to-vfile)
— transform from [Vinyl][]
* [`to-vfile`](https://github.com/vfile/to-vfile)
— create a file from a filepath and read and write to the file system
* [`vfile-find-down`](https://github.com/vfile/vfile-find-down)
— find files by searching the file system downwards
* [`vfile-find-up`](https://github.com/vfile/vfile-find-up)
— find files by searching the file system upwards
* [`vfile-glob`](https://github.com/shinnn/vfile-glob)
— find files by glob patterns
* [`vfile-is`](https://github.com/vfile/vfile-is)
— check if a file passes a test
* [`vfile-location`](https://github.com/vfile/vfile-location)
— convert between positional and offset locations
* [`vfile-matter`](https://github.com/vfile/vfile-matter)
— parse the YAML front matter
* [`vfile-message`](https://github.com/vfile/vfile-message)
— create a file message
* [`vfile-messages-to-vscode-diagnostics`](https://github.com/shinnn/vfile-messages-to-vscode-diagnostics)
— transform file messages to VS Code diagnostics
* [`vfile-mkdirp`](https://github.com/vfile/vfile-mkdirp)
— make sure the directory of a file exists on the file system
* [`vfile-rename`](https://github.com/vfile/vfile-rename)
— rename the path parts of a file
* [`vfile-sort`](https://github.com/vfile/vfile-sort)
— sort messages by line/column
* [`vfile-statistics`](https://github.com/vfile/vfile-statistics)
— count messages per category: failures, warnings, etc
* [`vfile-to-eslint`](https://github.com/vfile/vfile-to-eslint)
— convert to ESLint formatter compatible output
> 👉 **Note**: see [unist][] for projects that work with nodes.
## Reporters
* [`vfile-reporter`][reporter]
— create a report
* [`vfile-reporter-json`](https://github.com/vfile/vfile-reporter-json)
— create a JSON report
* [`vfile-reporter-folder-json`](https://github.com/vfile/vfile-reporter-folder-json)
— create a JSON representation of vfiles
* [`vfile-reporter-pretty`](https://github.com/vfile/vfile-reporter-pretty)
— create a pretty report
* [`vfile-reporter-junit`](https://github.com/kellyselden/vfile-reporter-junit)
— create a jUnit report
* [`vfile-reporter-position`](https://github.com/Hocdoc/vfile-reporter-position)
— create a report with content excerpts
> 👉 **Note**: want to make your own reporter?
> Reporters *must* accept `Array<VFile>` as their first argument, and return
> `string`.
> Reporters *may* accept other values too, in which case it’s suggested to stick
> to `vfile-reporter`s interface.
## Types
This package is fully typed with [TypeScript][].
It exports the additional types
[`BufferEncoding`][api-buffer-encoding],
[`Compatible`][api-compatible],
[`Data`][api-data],
[`DataMap`][api-data-map],
[`Map`][api-map],
[`Options`][api-options],
[`Reporter`][api-reporter],
[`ReporterSettings`][api-reporter-settings], and
[`Value`][api-value].
## Compatibility
Projects maintained by the unified collective are compatible with all maintained
versions of Node.js.
As of now, that is Node.js 14.14+ and 16.0+.
Our projects sometimes work with older versions, but this is not guaranteed.
## Contribute
See [`contributing.md`][contributing] in [`vfile/.github`][health] for ways to
get started.
See [`support.md`][support] for ways to get help.
This project has a [code of conduct][coc].
By interacting with this repository, organization, or community you agree to
abide by its terms.
## Sponsor
Support this effort and give back by sponsoring on [OpenCollective][collective]!
<table>
<tr valign="middle">
<td width="20%" align="center" rowspan="2" colspan="2">
<a href="https://vercel.com">Vercel</a><br><br>
<a href="https://vercel.com"><img src="https://avatars1.githubusercontent.com/u/14985020?s=256&v=4" width="128"></a>
</td>
<td width="20%" align="center" rowspan="2" colspan="2">
<a href="https://motif.land">Motif</a><br><br>
<a href="https://motif.land"><img src="https://avatars1.githubusercontent.com/u/74457950?s=256&v=4" width="128"></a>
</td>
<td width="20%" align="center" rowspan="2" colspan="2">
<a href="https://www.hashicorp.com">HashiCorp</a><br><br>
<a href="https://www.hashicorp.com"><img src="https://avatars1.githubusercontent.com/u/761456?s=256&v=4" width="128"></a>
</td>
<td width="20%" align="center" rowspan="2" colspan="2">
<a href="https://www.gitbook.com">GitBook</a><br><br>
<a href="https://www.gitbook.com"><img src="https://avatars1.githubusercontent.com/u/7111340?s=256&v=4" width="128"></a>
</td>
<td width="20%" align="center" rowspan="2" colspan="2">
<a href="https://www.gatsbyjs.org">Gatsby</a><br><br>
<a href="https://www.gatsbyjs.org"><img src="https://avatars1.githubusercontent.com/u/12551863?s=256&v=4" width="128"></a>
</td>
</tr>
<tr valign="middle">
</tr>
<tr valign="middle">
<td width="20%" align="center" rowspan="2" colspan="2">
<a href="https://www.netlify.com">Netlify</a><br><br>
<!--OC has a sharper image-->
<a href="https://www.netlify.com"><img src="https://images.opencollective.com/netlify/4087de2/logo/256.png" width="128"></a>
</td>
<td width="10%" align="center">
<a href="https://www.coinbase.com">Coinbase</a><br><br>
<a href="https://www.coinbase.com"><img src="https://avatars1.githubusercontent.com/u/1885080?s=256&v=4" width="64"></a>
</td>
<td width="10%" align="center">
<a href="https://themeisle.com">ThemeIsle</a><br><br>
<a href="https://themeisle.com"><img src="https://avatars1.githubusercontent.com/u/58979018?s=128&v=4" width="64"></a>
</td>
<td width="10%" align="center">
<a href="https://expo.io">Expo</a><br><br>
<a href="https://expo.io"><img src="https://avatars1.githubusercontent.com/u/12504344?s=128&v=4" width="64"></a>
</td>
<td width="10%" align="center">
<a href="https://boostnote.io">Boost Note</a><br><br>
<a href="https://boostnote.io"><img src="https://images.opencollective.com/boosthub/6318083/logo/128.png" width="64"></a>
</td>
<td width="10%" align="center">
<a href="https://www.holloway.com">Holloway</a><br><br>
<a href="https://www.holloway.com"><img src="https://avatars1.githubusercontent.com/u/35904294?s=128&v=4" width="64"></a>
</td>
<td width="10%"></td>
<td width="10%"></td>
<td width="10%"></td>
</tr>
<tr valign="middle">
<td width="100%" align="center" colspan="8">
<br>
<a href="https://opencollective.com/unified"><strong>You?</strong></a>
<br><br>
</td>
</tr>
</table>
## Acknowledgments
The initial release of this project was authored by
[**@wooorm**](https://github.com/wooorm).
Thanks to [**@contra**](https://github.com/contra),
[**@phated**](https://github.com/phated), and others for their work on
[Vinyl][], which was a huge inspiration.
Thanks to
[**@brendo**](https://github.com/brendo),
[**@shinnn**](https://github.com/shinnn),
[**@KyleAMathews**](https://github.com/KyleAMathews),
[**@sindresorhus**](https://github.com/sindresorhus), and
[**@denysdovhan**](https://github.com/denysdovhan)
for contributing commits since!
## License
[MIT][license] © [Titus Wormer][author]
<!-- Definitions -->
[build-badge]: https://github.com/vfile/vfile/workflows/main/badge.svg
[build]: https://github.com/vfile/vfile/actions
[coverage-badge]: https://img.shields.io/codecov/c/github/vfile/vfile.svg
[coverage]: https://codecov.io/github/vfile/vfile
[downloads-badge]: https://img.shields.io/npm/dm/vfile.svg
[downloads]: https://www.npmjs.com/package/vfile
[size-badge]: https://img.shields.io/bundlephobia/minzip/vfile.svg
[size]: https://bundlephobia.com/result?p=vfile
[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
[backers-badge]: https://opencollective.com/unified/backers/badge.svg
[collective]: https://opencollective.com/unified
[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
[chat]: https://github.com/vfile/vfile/discussions
[npm]: https://docs.npmjs.com/cli/install
[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
[esmsh]: https://esm.sh
[typescript]: https://www.typescriptlang.org
[health]: https://github.com/vfile/.github
[contributing]: https://github.com/vfile/.github/blob/main/contributing.md
[support]: https://github.com/vfile/.github/blob/main/support.md
[coc]: https://github.com/vfile/.github/blob/main/code-of-conduct.md
[license]: license
[author]: https://wooorm.com
[unified]: https://github.com/unifiedjs/unified
[vinyl]: https://github.com/gulpjs/vinyl
[site]: https://unifiedjs.com
[twitter]: https://twitter.com/unifiedjs
[unist]: https://github.com/syntax-tree/unist#list-of-utilities
[reporter]: https://github.com/vfile/vfile-reporter
[vmessage]: https://github.com/vfile/vfile-message
[messages]: #filemessages
[message]: #vfilemessagereason-position-origin
[encoding]: https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings
[buffer]: https://nodejs.org/api/buffer.html
[source-map]: https://github.com/mozilla/source-map/blob/58819f0/source-map.d.ts#L15-L23
[file-url-to-path]: https://nodejs.org/api/url.html#url_url_fileurltopath_url
[governance]: https://github.com/unifiedjs/collective
[api-vfile]: #vfileoptions
[api-buffer-encoding]: #bufferencoding
[api-compatible]: #compatible
[api-data]: #data
[api-data-map]: #datamap
[api-map]: #map
[api-options]: #options
[api-reporter]: #reporter
[api-reporter-settings]: #reportersettings
[api-value]: #value

107
node_modules/retext-stringify/node_modules/unified/package.json generated vendored Normal file
View File

@@ -0,0 +1,107 @@
{
"name": "unified",
"version": "10.1.2",
"description": "Interface for parsing, inspecting, transforming, and serializing content through syntax trees",
"license": "MIT",
"keywords": [
"unified",
"process",
"parse",
"transform",
"compile",
"stringify",
"serialize",
"ast",
"cst",
"syntax",
"tree",
"content",
"rehype",
"retext",
"remark"
],
"homepage": "https://unifiedjs.com",
"repository": "unifiedjs/unified",
"bugs": "https://github.com/unifiedjs/unified/issues",
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
},
"author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
"contributors": [
"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>"
],
"sideEffects": false,
"type": "module",
"main": "index.js",
"types": "index.d.ts",
"files": [
"lib/",
"index.d.ts",
"index.js"
],
"dependencies": {
"@types/unist": "^2.0.0",
"bail": "^2.0.0",
"extend": "^3.0.0",
"is-buffer": "^2.0.0",
"is-plain-obj": "^4.0.0",
"trough": "^2.0.0",
"vfile": "^5.0.0"
},
"devDependencies": {
"@types/extend": "^3.0.0",
"@types/tape": "^4.0.0",
"c8": "^7.0.0",
"prettier": "^2.0.0",
"remark-cli": "^10.0.0",
"remark-preset-wooorm": "^9.0.0",
"rimraf": "^3.0.0",
"tape": "^5.0.0",
"tsd": "^0.19.0",
"type-coverage": "^2.0.0",
"typescript": "^4.0.0",
"xo": "^0.48.0"
},
"scripts": {
"build": "rimraf \"test/**/*.d.ts\" && tsc && tsd && type-coverage",
"format": "remark . -qfo && prettier . -w --loglevel warn && xo --fix",
"test-api": "node --unhandled-rejections=strict --conditions development test/index.js",
"test-coverage": "c8 --check-coverage --branches 100 --functions 100 --lines 100 --statements 100 --reporter lcov node --unhandled-rejections=strict --conditions development test/index.js",
"test": "npm run build && npm run format && npm run test-coverage"
},
"prettier": {
"tabWidth": 2,
"useTabs": false,
"singleQuote": true,
"bracketSpacing": false,
"semi": false,
"trailingComma": "none"
},
"xo": {
"prettier": true,
"rules": {
"@typescript-eslint/ban-types": "off",
"promise/param-names": "off"
},
"ignores": [
"types/"
]
},
"remarkConfig": {
"plugins": [
"preset-wooorm"
]
},
"typeCoverage": {
"atLeast": 100,
"detail": true,
"strict": true,
"ignoreCatch": true
}
}

1450
node_modules/retext-stringify/node_modules/unified/readme.md generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

57
node_modules/retext-stringify/package.json generated vendored Normal file
View File

@@ -0,0 +1,57 @@
{
"name": "retext-stringify",
"version": "3.1.0",
"description": "retext plugin to serialize prose",
"license": "MIT",
"keywords": [
"unified",
"retext",
"retext-plugin",
"plugin",
"natural",
"language",
"text",
"concrete",
"syntax",
"tree",
"cst",
"stringify",
"serialize",
"compile"
],
"homepage": "https://github.com/retextjs/retext",
"repository": "https://github.com/retextjs/retext/tree/main/packages/retext-stringify",
"bugs": "https://github.com/retextjs/retext/issues",
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/unified"
},
"author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
"contributors": [
"Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
],
"sideEffects": false,
"type": "module",
"main": "index.js",
"types": "index.d.ts",
"files": [
"lib/",
"index.d.ts",
"index.js"
],
"dependencies": {
"@types/nlcst": "^1.0.0",
"nlcst-to-string": "^3.0.0",
"unified": "^10.0.0"
},
"scripts": {
"build": "rimraf \"lib/**/*.d.ts\" && tsc && type-coverage"
},
"xo": false,
"typeCoverage": {
"atLeast": 100,
"detail": true,
"strict": true,
"ignoreCatch": true
}
}

170
node_modules/retext-stringify/readme.md generated vendored Normal file
View File

@@ -0,0 +1,170 @@
# retext-stringify
[![Build][build-badge]][build]
[![Coverage][coverage-badge]][coverage]
[![Downloads][downloads-badge]][downloads]
[![Size][size-badge]][size]
[![Sponsors][sponsors-badge]][collective]
[![Backers][backers-badge]][collective]
[![Chat][chat-badge]][chat]
[**retext**][retext] plugin to serialize natural language.
[Compiler][] for [**unified**][unified].
Serializes [**nlcst**][nlcst] syntax trees.
## Sponsors
Support this effort and give back by sponsoring on [OpenCollective][collective]!
<!--lint ignore no-html-->
<table>
<tr valign="middle">
<td width="20%" align="center" colspan="2">
<a href="https://www.gatsbyjs.org">Gatsby</a> 🥇<br><br>
<a href="https://www.gatsbyjs.org"><img src="https://avatars1.githubusercontent.com/u/12551863?s=256&v=4" width="128"></a>
</td>
<td width="20%" align="center" colspan="2">
<a href="https://vercel.com">Vercel</a> 🥇<br><br>
<a href="https://vercel.com"><img src="https://avatars1.githubusercontent.com/u/14985020?s=256&v=4" width="128"></a>
</td>
<td width="20%" align="center" colspan="2">
<a href="https://www.netlify.com">Netlify</a><br><br>
<!--OC has a sharper image-->
<a href="https://www.netlify.com"><img src="https://images.opencollective.com/netlify/4087de2/logo/256.png" width="128"></a>
</td>
<td width="10%" align="center">
<a href="https://www.holloway.com">Holloway</a><br><br>
<a href="https://www.holloway.com"><img src="https://avatars1.githubusercontent.com/u/35904294?s=128&v=4" width="64"></a>
</td>
<td width="10%" align="center">
<a href="https://themeisle.com">ThemeIsle</a><br><br>
<a href="https://themeisle.com"><img src="https://avatars1.githubusercontent.com/u/58979018?s=128&v=4" width="64"></a>
</td>
<td width="10%" align="center">
<a href="https://boosthub.io">Boost Hub</a><br><br>
<a href="https://boosthub.io"><img src="https://images.opencollective.com/boosthub/6318083/logo/128.png" width="64"></a>
</td>
<td width="10%" align="center">
<a href="https://expo.io">Expo</a><br><br>
<a href="https://expo.io"><img src="https://avatars1.githubusercontent.com/u/12504344?s=128&v=4" width="64"></a>
</td>
</tr>
<tr valign="middle">
<td width="100%" align="center" colspan="10">
<br>
<a href="https://opencollective.com/unified"><strong>You?</strong></a>
<br><br>
</td>
</tr>
</table>
## Install
This package is [ESM only](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c):
Node 12+ is needed to use it and it must be `import`ed instead of `require`d.
[npm][]:
```sh
npm install retext-stringify
```
## Use
```js
import {unified} from 'unified'
import {stream} from 'unified-stream'
import retextEnglish from 'retext-english'
import retextStringify from 'retext-stringify'
import retextEmoji from 'retext-emoji'
const processor = unified()
.use(retextEnglish)
.use(retextEmoji, {convert: 'encode'})
.use(retextStringify)
process.stdin.pipe(stream(processor)).pipe(process.stdout)
```
## API
This package exports no identifiers.
`retextStringify` is the default export.
### `unified().use(retextStringify)`
Serialize [**nlcst**][nlcst] syntax trees.
There is no configuration.
## Contribute
See [`contributing.md`][contributing] in [`retextjs/.github`][health] for ways
to get started.
See [`support.md`][support] for ways to get help.
Ideas for new plugins and tools can be posted in [`retextjs/ideas`][ideas].
A curated list of awesome retext resources can be found in [**awesome
retext**][awesome].
This project has a [code of conduct][coc].
By interacting with this repository, organization, or community you agree to
abide by its terms.
## License
[MIT][license] © [Titus Wormer][author]
<!-- Definitions -->
[build-badge]: https://github.com/retextjs/retext/workflows/main/badge.svg
[build]: https://github.com/retextjs/retext/actions
[coverage-badge]: https://img.shields.io/codecov/c/github/retextjs/retext.svg
[coverage]: https://codecov.io/github/retextjs/retext
[downloads-badge]: https://img.shields.io/npm/dm/retext-stringify.svg
[downloads]: https://www.npmjs.com/package/retext-stringify
[size-badge]: https://img.shields.io/bundlephobia/minzip/retext-stringify.svg
[size]: https://bundlephobia.com/result?p=retext-stringify
[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
[backers-badge]: https://opencollective.com/unified/backers/badge.svg
[collective]: https://opencollective.com/unified
[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
[chat]: https://github.com/retextjs/retext/discussions
[health]: https://github.com/retextjs/.github
[contributing]: https://github.com/retextjs/.github/blob/main/contributing.md
[support]: https://github.com/retextjs/.github/blob/main/support.md
[coc]: https://github.com/retextjs/.github/blob/main/code-of-conduct.md
[ideas]: https://github.com/retextjs/ideas
[awesome]: https://github.com/retextjs/awesome-retext
[license]: https://github.com/retextjs/retext/blob/main/license
[author]: https://wooorm.com
[npm]: https://docs.npmjs.com/cli/install
[unified]: https://github.com/unifiedjs/unified
[compiler]: https://github.com/unifiedjs/unified#processorcompiler
[retext]: https://github.com/retextjs/retext
[nlcst]: https://github.com/syntax-tree/nlcst