600 lines
14 KiB
Plaintext
600 lines
14 KiB
Plaintext
|
/**
|
|||
|
|
* @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)
|
|||
|
|
}
|