711 lines
20 KiB
Plaintext
711 lines
20 KiB
Plaintext
/**
|
||
* @typedef {import('hast').Comment} Comment
|
||
* @typedef {import('hast').Doctype} Doctype
|
||
* @typedef {import('hast').Element} Element
|
||
* @typedef {import('hast').Nodes} Nodes
|
||
* @typedef {import('hast').Root} Root
|
||
* @typedef {import('hast').RootContent} RootContent
|
||
* @typedef {import('hast').Text} Text
|
||
*
|
||
* @typedef {import('mdast-util-to-hast').Raw} Raw
|
||
*
|
||
* @typedef {import('parse5').DefaultTreeAdapterMap} DefaultTreeAdapterMap
|
||
* @typedef {import('parse5').ParserOptions<DefaultTreeAdapterMap>} ParserOptions
|
||
* @typedef {import('parse5').Token.CharacterToken} CharacterToken
|
||
* @typedef {import('parse5').Token.CommentToken} CommentToken
|
||
* @typedef {import('parse5').Token.DoctypeToken} DoctypeToken
|
||
* @typedef {import('parse5').Token.Location} Location
|
||
* @typedef {import('parse5').Token.TagToken} TagToken
|
||
*
|
||
* @typedef {import('unist').Point} Point
|
||
*
|
||
* @typedef {import('vfile').VFile} VFile
|
||
*/
|
||
|
||
/**
|
||
* @typedef Options
|
||
* Configuration.
|
||
* @property {VFile | null | undefined} [file]
|
||
* Corresponding virtual file representing the input document (optional).
|
||
* @property {Array<Nodes['type']> | null | undefined} [passThrough]
|
||
* List of custom hast node types to pass through (as in, keep) (optional).
|
||
*
|
||
* If the passed through nodes have children, those children are expected to
|
||
* be hast again and will be handled.
|
||
*
|
||
* @typedef State
|
||
* Info passed around about the current state.
|
||
* @property {(node: Nodes) => undefined} handle
|
||
* Add a hast node to the parser.
|
||
* @property {Options} options
|
||
* User configuration.
|
||
* @property {Parser<DefaultTreeAdapterMap>} parser
|
||
* Current parser.
|
||
* @property {boolean} stitches
|
||
* Whether there are stitches.
|
||
*
|
||
* @typedef {{type: 'comment', value: {stitch: Nodes}}} Stitch
|
||
* Custom comment-like value we pass through parse5, which contains a
|
||
* replacement node that we’ll swap back in afterwards.
|
||
*/
|
||
|
||
import structuredClone from '@ungap/structured-clone'
|
||
import {fromParse5} from 'hast-util-from-parse5'
|
||
import {toParse5} from 'hast-util-to-parse5'
|
||
import {htmlVoidElements} from 'html-void-elements'
|
||
import {Parser, Token, TokenizerMode, html} from 'parse5'
|
||
import {pointEnd, pointStart} from 'unist-util-position'
|
||
import {visit} from 'unist-util-visit'
|
||
import {webNamespaces} from 'web-namespaces'
|
||
import {zwitch} from 'zwitch'
|
||
|
||
// Node types associated with MDX.
|
||
// <https://github.com/mdx-js/mdx/blob/8a56312/packages/mdx/lib/node-types.js>
|
||
const knownMdxNames = new Set([
|
||
'mdxFlowExpression',
|
||
'mdxJsxFlowElement',
|
||
'mdxJsxTextElement',
|
||
'mdxTextExpression',
|
||
'mdxjsEsm'
|
||
])
|
||
|
||
/** @type {ParserOptions} */
|
||
const parseOptions = {sourceCodeLocationInfo: true, scriptingEnabled: false}
|
||
|
||
/**
|
||
* Pass a hast tree through an HTML parser, which will fix nesting, and turn
|
||
* raw nodes into actual nodes.
|
||
*
|
||
* @param {Nodes} tree
|
||
* Original hast tree to transform.
|
||
* @param {Options | null | undefined} [options]
|
||
* Configuration (optional).
|
||
* @returns {Nodes}
|
||
* Parsed again tree.
|
||
*/
|
||
export function raw(tree, options) {
|
||
const document = documentMode(tree)
|
||
/** @type {(node: Nodes, state: State) => undefined} */
|
||
const one = zwitch('type', {
|
||
handlers: {root, element, text, comment, doctype, raw: handleRaw},
|
||
unknown
|
||
})
|
||
|
||
/** @type {State} */
|
||
const state = {
|
||
parser: document
|
||
? new Parser(parseOptions)
|
||
: Parser.getFragmentParser(undefined, parseOptions),
|
||
handle(node) {
|
||
one(node, state)
|
||
},
|
||
stitches: false,
|
||
options: options || {}
|
||
}
|
||
|
||
one(tree, state)
|
||
resetTokenizer(state, pointStart())
|
||
|
||
const p5 = document ? state.parser.document : state.parser.getFragment()
|
||
const result = fromParse5(p5, {
|
||
// To do: support `space`?
|
||
file: state.options.file
|
||
})
|
||
|
||
if (state.stitches) {
|
||
visit(result, 'comment', function (node, index, parent) {
|
||
const stitch = /** @type {Stitch} */ (/** @type {unknown} */ (node))
|
||
if (stitch.value.stitch && parent && index !== undefined) {
|
||
/** @type {Array<RootContent>} */
|
||
const siblings = parent.children
|
||
// @ts-expect-error: assume the stitch is allowed.
|
||
siblings[index] = stitch.value.stitch
|
||
return index
|
||
}
|
||
})
|
||
}
|
||
|
||
// Unpack if possible and when not given a `root`.
|
||
if (
|
||
result.type === 'root' &&
|
||
result.children.length === 1 &&
|
||
result.children[0].type === tree.type
|
||
) {
|
||
return result.children[0]
|
||
}
|
||
|
||
return result
|
||
}
|
||
|
||
/**
|
||
* Transform all nodes
|
||
*
|
||
* @param {Array<RootContent>} nodes
|
||
* hast content.
|
||
* @param {State} state
|
||
* Info passed around about the current state.
|
||
* @returns {undefined}
|
||
* Nothing.
|
||
*/
|
||
function all(nodes, state) {
|
||
let index = -1
|
||
|
||
/* istanbul ignore else - invalid nodes, see rehypejs/rehype-raw#7. */
|
||
if (nodes) {
|
||
while (++index < nodes.length) {
|
||
state.handle(nodes[index])
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Transform a root.
|
||
*
|
||
* @param {Root} node
|
||
* hast root node.
|
||
* @param {State} state
|
||
* Info passed around about the current state.
|
||
* @returns {undefined}
|
||
* Nothing.
|
||
*/
|
||
function root(node, state) {
|
||
all(node.children, state)
|
||
}
|
||
|
||
/**
|
||
* Transform an element.
|
||
*
|
||
* @param {Element} node
|
||
* hast element node.
|
||
* @param {State} state
|
||
* Info passed around about the current state.
|
||
* @returns {undefined}
|
||
* Nothing.
|
||
*/
|
||
function element(node, state) {
|
||
startTag(node, state)
|
||
|
||
all(node.children, state)
|
||
|
||
endTag(node, state)
|
||
}
|
||
|
||
/**
|
||
* Transform a text.
|
||
*
|
||
* @param {Text} node
|
||
* hast text node.
|
||
* @param {State} state
|
||
* Info passed around about the current state.
|
||
* @returns {undefined}
|
||
* Nothing.
|
||
*/
|
||
function text(node, state) {
|
||
/** @type {CharacterToken} */
|
||
const token = {
|
||
type: Token.TokenType.CHARACTER,
|
||
chars: node.value,
|
||
location: createParse5Location(node)
|
||
}
|
||
|
||
resetTokenizer(state, pointStart(node))
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.currentToken = token
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser._processToken(state.parser.currentToken)
|
||
}
|
||
|
||
/**
|
||
* Transform a doctype.
|
||
*
|
||
* @param {Doctype} node
|
||
* hast doctype node.
|
||
* @param {State} state
|
||
* Info passed around about the current state.
|
||
* @returns {undefined}
|
||
* Nothing.
|
||
*/
|
||
function doctype(node, state) {
|
||
/** @type {DoctypeToken} */
|
||
const token = {
|
||
type: Token.TokenType.DOCTYPE,
|
||
name: 'html',
|
||
forceQuirks: false,
|
||
publicId: '',
|
||
systemId: '',
|
||
location: createParse5Location(node)
|
||
}
|
||
|
||
resetTokenizer(state, pointStart(node))
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.currentToken = token
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser._processToken(state.parser.currentToken)
|
||
}
|
||
|
||
/**
|
||
* Transform a stitch.
|
||
*
|
||
* @param {Nodes} node
|
||
* unknown node.
|
||
* @param {State} state
|
||
* Info passed around about the current state.
|
||
* @returns {undefined}
|
||
* Nothing.
|
||
*/
|
||
function stitch(node, state) {
|
||
// Mark that there are stitches, so we need to walk the tree and revert them.
|
||
state.stitches = true
|
||
|
||
/** @type {Nodes} */
|
||
const clone = cloneWithoutChildren(node)
|
||
|
||
// Recurse, because to somewhat handle `[<x>]</x>` (where `[]` denotes the
|
||
// passed through node).
|
||
if ('children' in node && 'children' in clone) {
|
||
// Root in root out.
|
||
const fakeRoot = /** @type {Root} */ (
|
||
raw({type: 'root', children: node.children}, state.options)
|
||
)
|
||
clone.children = fakeRoot.children
|
||
}
|
||
|
||
// Hack: `value` is supposed to be a string, but as none of the tools
|
||
// (`parse5` or `hast-util-from-parse5`) looks at it, we can pass nodes
|
||
// through.
|
||
comment({type: 'comment', value: {stitch: clone}}, state)
|
||
}
|
||
|
||
/**
|
||
* Transform a comment (or stitch).
|
||
*
|
||
* @param {Comment | Stitch} node
|
||
* hast comment node.
|
||
* @param {State} state
|
||
* Info passed around about the current state.
|
||
* @returns {undefined}
|
||
* Nothing.
|
||
*/
|
||
function comment(node, state) {
|
||
/** @type {string} */
|
||
// @ts-expect-error: we pass stitches through.
|
||
const data = node.value
|
||
|
||
/** @type {CommentToken} */
|
||
const token = {
|
||
type: Token.TokenType.COMMENT,
|
||
data,
|
||
location: createParse5Location(node)
|
||
}
|
||
resetTokenizer(state, pointStart(node))
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.currentToken = token
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser._processToken(state.parser.currentToken)
|
||
}
|
||
|
||
/**
|
||
* Transform a raw node.
|
||
*
|
||
* @param {Raw} node
|
||
* hast raw node.
|
||
* @param {State} state
|
||
* Info passed around about the current state.
|
||
* @returns {undefined}
|
||
* Nothing.
|
||
*/
|
||
function handleRaw(node, state) {
|
||
// Reset preprocessor:
|
||
// See: <https://github.com/inikulin/parse5/blob/6f7ca60/packages/parse5/lib/tokenizer/preprocessor.ts#L18-L31>.
|
||
state.parser.tokenizer.preprocessor.html = ''
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer.preprocessor.pos = -1
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer.preprocessor.lastGapPos = -2
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer.preprocessor.gapStack = []
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer.preprocessor.skipNextNewLine = false
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer.preprocessor.lastChunkWritten = false
|
||
state.parser.tokenizer.preprocessor.endOfChunkHit = false
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer.preprocessor.isEol = false
|
||
|
||
// Now pass `node.value`.
|
||
setPoint(state, pointStart(node))
|
||
state.parser.tokenizer.write(node.value, false)
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer._runParsingLoop()
|
||
|
||
// Character references hang, so if we ended there, we need to flush
|
||
// those too.
|
||
// We reset the preprocessor as if the document ends here.
|
||
// Then one single call to the relevant state does the trick, parse5
|
||
// consumes the whole token.
|
||
|
||
// Note: `State` is not exposed by `parse5`, so these numbers are fragile.
|
||
// See: <https://github.com/inikulin/parse5/blob/46cba43/packages/parse5/lib/tokenizer/index.ts#L58>
|
||
// Note: a change to `parse5`, which breaks this, was merged but not released.
|
||
// Investigate when it is.
|
||
if (
|
||
state.parser.tokenizer.state === 72 /* NAMED_CHARACTER_REFERENCE */ ||
|
||
state.parser.tokenizer.state === 78 /* NUMERIC_CHARACTER_REFERENCE_END */
|
||
) {
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer.preprocessor.lastChunkWritten = true
|
||
/** @type {number} */
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
const cp = state.parser.tokenizer._consume()
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer._callState(cp)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Crash on an unknown node.
|
||
*
|
||
* @param {unknown} node_
|
||
* unknown node.
|
||
* @param {State} state
|
||
* Info passed around about the current state.
|
||
* @returns {undefined}
|
||
* Never.
|
||
*/
|
||
function unknown(node_, state) {
|
||
const node = /** @type {Nodes} */ (node_)
|
||
|
||
if (
|
||
state.options.passThrough &&
|
||
state.options.passThrough.includes(node.type)
|
||
) {
|
||
stitch(node, state)
|
||
} else {
|
||
let extra = ''
|
||
|
||
if (knownMdxNames.has(node.type)) {
|
||
extra =
|
||
". It looks like you are using MDX nodes with `hast-util-raw` (or `rehype-raw`). If you use this because you are using remark or rehype plugins that inject `'html'` nodes, then please raise an issue with that plugin, as its a bad and slow idea. If you use this because you are using markdown syntax, then you have to configure this utility (or plugin) to pass through these nodes (see `passThrough` in docs), but you can also migrate to use the MDX syntax"
|
||
}
|
||
|
||
throw new Error('Cannot compile `' + node.type + '` node' + extra)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Reset the tokenizer of a parser.
|
||
*
|
||
* @param {State} state
|
||
* Info passed around about the current state.
|
||
* @param {Point | undefined} point
|
||
* Point.
|
||
* @returns {undefined}
|
||
* Nothing.
|
||
*/
|
||
function resetTokenizer(state, point) {
|
||
setPoint(state, point)
|
||
|
||
// Process final characters if they’re still there after hibernating.
|
||
/** @type {CharacterToken} */
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
const token = state.parser.tokenizer.currentCharacterToken
|
||
|
||
if (token && token.location) {
|
||
token.location.endLine = state.parser.tokenizer.preprocessor.line
|
||
token.location.endCol = state.parser.tokenizer.preprocessor.col + 1
|
||
token.location.endOffset = state.parser.tokenizer.preprocessor.offset + 1
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.currentToken = token
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser._processToken(state.parser.currentToken)
|
||
}
|
||
|
||
// Reset tokenizer:
|
||
// See: <https://github.com/inikulin/parse5/blob/6f7ca60/packages/parse5/lib/tokenizer/index.ts#L187-L223>.
|
||
// Especially putting it back in the `data` state is useful: some elements,
|
||
// like textareas and iframes, change the state.
|
||
// See GH-7.
|
||
// But also if broken HTML is in `raw`, and then a correct element is given.
|
||
// See GH-11.
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer.paused = false
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer.inLoop = false
|
||
|
||
// Note: don’t reset `state`, `inForeignNode`, or `lastStartTagName`, we
|
||
// manually update those when needed.
|
||
state.parser.tokenizer.active = false
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer.returnState = TokenizerMode.DATA
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer.charRefCode = -1
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer.consumedAfterSnapshot = -1
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer.currentLocation = null
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer.currentCharacterToken = null
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer.currentToken = null
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer.currentAttr = {name: '', value: ''}
|
||
}
|
||
|
||
/**
|
||
* Set current location.
|
||
*
|
||
* @param {State} state
|
||
* Info passed around about the current state.
|
||
* @param {Point | undefined} point
|
||
* Point.
|
||
* @returns {undefined}
|
||
* Nothing.
|
||
*/
|
||
function setPoint(state, point) {
|
||
if (point && point.offset !== undefined) {
|
||
/** @type {Location} */
|
||
const location = {
|
||
startLine: point.line,
|
||
startCol: point.column,
|
||
startOffset: point.offset,
|
||
endLine: -1,
|
||
endCol: -1,
|
||
endOffset: -1
|
||
}
|
||
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer.preprocessor.lineStartPos = -point.column + 1 // Looks weird, but ensures we get correct positional info.
|
||
state.parser.tokenizer.preprocessor.droppedBufferSize = point.offset
|
||
state.parser.tokenizer.preprocessor.line = point.line
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.tokenizer.currentLocation = location
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Emit a start tag.
|
||
*
|
||
* @param {Element} node
|
||
* Element.
|
||
* @param {State} state
|
||
* Info passed around about the current state.
|
||
* @returns {undefined}
|
||
* Nothing.
|
||
*/
|
||
function startTag(node, state) {
|
||
// Ignore tags if we’re in plain text.
|
||
if (state.parser.tokenizer.state === TokenizerMode.PLAINTEXT) return
|
||
|
||
resetTokenizer(state, pointStart(node))
|
||
|
||
const current = state.parser.openElements.current
|
||
let ns = 'namespaceURI' in current ? current.namespaceURI : webNamespaces.html
|
||
|
||
if (ns === webNamespaces.html && node.tagName === 'svg') {
|
||
ns = webNamespaces.svg
|
||
}
|
||
|
||
const result = toParse5(
|
||
// Shallow clone to not delve into `children`: we only need the attributes.
|
||
{...node, children: []},
|
||
{space: ns === webNamespaces.svg ? 'svg' : 'html'}
|
||
)
|
||
// Always element.
|
||
/* c8 ignore next */
|
||
const attrs = 'attrs' in result ? result.attrs : []
|
||
|
||
/** @type {TagToken} */
|
||
const tag = {
|
||
type: Token.TokenType.START_TAG,
|
||
tagName: node.tagName,
|
||
tagID: html.getTagID(node.tagName),
|
||
// We always send start and end tags.
|
||
selfClosing: false,
|
||
ackSelfClosing: false,
|
||
attrs,
|
||
location: createParse5Location(node)
|
||
}
|
||
|
||
// The HTML parsing algorithm works by doing half of the state management in
|
||
// the tokenizer and half in the parser.
|
||
// We can’t use the tokenizer here, as we don’t have strings.
|
||
// So we act *as if* the tokenizer emits tokens:
|
||
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.currentToken = tag
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser._processToken(state.parser.currentToken)
|
||
|
||
// …but then we still need a bunch of work that the tokenizer would normally
|
||
// do, such as:
|
||
|
||
// Set a tag name, similar to how the tokenizer would do it.
|
||
state.parser.tokenizer.lastStartTagName = node.tagName
|
||
|
||
// `inForeignNode` is correctly set by the parser.
|
||
}
|
||
|
||
/**
|
||
* Emit an end tag.
|
||
*
|
||
* @param {Element} node
|
||
* Element.
|
||
* @param {State} state
|
||
* Info passed around about the current state.
|
||
* @returns {undefined}
|
||
* Nothing.
|
||
*/
|
||
function endTag(node, state) {
|
||
// Do not emit closing tags for HTML void elements.
|
||
if (
|
||
!state.parser.tokenizer.inForeignNode &&
|
||
htmlVoidElements.includes(node.tagName)
|
||
) {
|
||
return
|
||
}
|
||
|
||
// Ignore tags if we’re in plain text.
|
||
if (state.parser.tokenizer.state === TokenizerMode.PLAINTEXT) return
|
||
|
||
resetTokenizer(state, pointEnd(node))
|
||
|
||
/** @type {TagToken} */
|
||
const tag = {
|
||
type: Token.TokenType.END_TAG,
|
||
tagName: node.tagName,
|
||
tagID: html.getTagID(node.tagName),
|
||
selfClosing: false,
|
||
ackSelfClosing: false,
|
||
attrs: [],
|
||
location: createParse5Location(node)
|
||
}
|
||
|
||
// The HTML parsing algorithm works by doing half of the state management in
|
||
// the tokenizer and half in the parser.
|
||
// We can’t use the tokenizer here, as we don’t have strings.
|
||
// So we act *as if* the tokenizer emits tokens:
|
||
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser.currentToken = tag
|
||
// @ts-expect-error: private.
|
||
// type-coverage:ignore-next-line
|
||
state.parser._processToken(state.parser.currentToken)
|
||
|
||
// …but then we still need a bunch of work that the tokenizer would normally
|
||
// do, such as:
|
||
|
||
// Switch back to the data state after alternative states that don’t accept
|
||
// tags:
|
||
if (
|
||
// Current element is closed.
|
||
tag.tagName === state.parser.tokenizer.lastStartTagName &&
|
||
// `<textarea>` and `<title>`
|
||
(state.parser.tokenizer.state === TokenizerMode.RCDATA ||
|
||
// `<iframe>`, `<noembed>`, `<style>`, `<xmp>`
|
||
state.parser.tokenizer.state === TokenizerMode.RAWTEXT ||
|
||
// `<script>`
|
||
state.parser.tokenizer.state === TokenizerMode.SCRIPT_DATA)
|
||
) {
|
||
state.parser.tokenizer.state = TokenizerMode.DATA
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Check if `node` represents a whole document or a fragment.
|
||
*
|
||
* @param {Nodes} node
|
||
* hast node.
|
||
* @returns {boolean}
|
||
* Whether this represents a whole document or a fragment.
|
||
*/
|
||
function documentMode(node) {
|
||
const head = node.type === 'root' ? node.children[0] : node
|
||
return Boolean(
|
||
head &&
|
||
(head.type === 'doctype' ||
|
||
(head.type === 'element' && head.tagName === 'html'))
|
||
)
|
||
}
|
||
|
||
/**
|
||
* Get a `parse5` location from a node.
|
||
*
|
||
* @param {Nodes | Stitch} node
|
||
* hast node.
|
||
* @returns {Location}
|
||
* `parse5` location.
|
||
*/
|
||
function createParse5Location(node) {
|
||
const start = pointStart(node) || {
|
||
line: undefined,
|
||
column: undefined,
|
||
offset: undefined
|
||
}
|
||
const end = pointEnd(node) || {
|
||
line: undefined,
|
||
column: undefined,
|
||
offset: undefined
|
||
}
|
||
|
||
/** @type {Record<keyof Location, number | undefined>} */
|
||
const location = {
|
||
startLine: start.line,
|
||
startCol: start.column,
|
||
startOffset: start.offset,
|
||
endLine: end.line,
|
||
endCol: end.column,
|
||
endOffset: end.offset
|
||
}
|
||
|
||
// @ts-expect-error: unist point values can be `undefined` in hast, which
|
||
// `parse5` types don’t want.
|
||
return location
|
||
}
|
||
|
||
/**
|
||
* @template {Nodes} NodeType
|
||
* Node type.
|
||
* @param {NodeType} node
|
||
* Node to clone.
|
||
* @returns {NodeType}
|
||
* Cloned node, without children.
|
||
*/
|
||
function cloneWithoutChildren(node) {
|
||
return 'children' in node
|
||
? structuredClone({...node, children: []})
|
||
: structuredClone(node)
|
||
}
|