2.0.4 • Published 11 months ago
lhast v2.0.4
lhast
Lightweight Hypertext Abstract Syntax Tree.
A lightweight version of hast v2.4 with a more compact format for serialization.
Intall
npm install --save lhast
# or
yarn add lhast
API
LHAST
interface Node {
type: string
}
interface Parent {
children: Node[]
}
interface ParentOf<T extends Node[]> extends Parent {
children: T
}
interface Root extends Node, ParentOf<RootContent[]> {
type: 'root'
}
interface Element extends Node, ParentOf<ElementContent[]> {
type: 'element'
tagName: string
properties: Properties
}
interface Text extends Node {
type: 'text'
value: string
}
type RootContent =
| Element
| Text
type ElementContent =
| Element
| Text
type Properties = Record<string, boolean | number | string | string[]>
LHASTCompact
type Node =
| Root
| Element
| Text
type Root = RootContent[]
type Element = ElementWithProperties | ElementWithoutProperties
type ElementWithProperties = [
tagName: string
, properties: Properties
, ...children: ElementContent[]
]
type ElementWithoutProperties = [
tagName: string
, ...children: ElementContent[]
]
type Text = string
type RootContent =
| Element
| Text
type ElementContent =
| Element
| Text
type Properties = Record<string, boolean | number | string | string[]>
parseDocument
function parseDocument(html: string): LHAST.Root
parseFragment
function parseFragment(html: string): LHAST.Root
compact
function compact(root: LHAST.Root): LHASTCompact.Root
uncompact
function uncompact(root: LHAST.COMPACT.Root): LHAST.Root
validateLHAST
function validateLHAST(data: unknown): void
validateLHASTCompact
function validateLHASTCompact(data: unknown): void
isAST
function isLHAST(data: unknown): data is LHAST.Root
isLHASTCompact
function isLHASTCompact(data: unknown): data is LHASTCompact.Root
LHASTSchema
const LHASTSchema
LHASTCompactSchema
const LHASTCompactSchema
utils
builder
import * as Builder from 'lhast/utils/builder'
Each lhast node has a corresponding builder.
is
import * as Is from 'lhast/utils/is'
Each lhast node has a corresponding is
function.
flatMap
import { flatMap } from 'lhast/utils/flat-map'
function flatMap(
node: LHAST.Node
, fn: (node: LHAST.Node) => AST.Node[]
): LHAST.Node[]
map
import { map } from 'lhast/utils/map'
function map(
node: LHAST.Node
, fn: (node: LHAST.Node) => AST.Node
): LHAST.Node
filter
import { filter } from 'lhast/utils/filter'
function filter(
node: LHAST.Node
, predicate: (node: LHAST.Node) => unknown
): LHAST.Node | undefined
find
import { find } from 'lhast/utils/find'
function find<T extends LHAST.Node>(
node: LHAST.Node
, predicate: (node: LHAST.Node) => boolean
): T | undefined
findAll
import { findAll } from 'lhast/utils/find-all'
function* findAll<T extends LHAST.Node>(
node: LHAST.Node
, predicate: (node: LHAST.Node) => boolean
): Iterable<T>
traverseDescendantNodes
import { traverseDescendantNodes } from 'lhast/utils/traverse-descendant-nodes'
function traverseDescendantNodes(node: LHAST.Node): Iterable<LHAST.Node>
reverse
import { reverse } from 'lhast/utils/reverse'
function reverse(root: LHAST.Root): LHAST.Root
addHelpers
import { addHelpers, addHelpersInPlace, NodeWithHelpers } from 'lhast/utils/add-helpers'
type NullOrNodeWithHelpers<T extends LHAST.Node | null> =
T extends null
? null
: NodeWithHelpers<NonNullable<T>>
type NodeWithHelpers<
Node extends LHAST.Node
, Sibling extends LHAST.Node | null = AST.Node | null
, Parent extends LHAST.Node | null = AST.Node | null
> =
Node extends LHAST.Root
? Mixin<Node, {
id: string
parent: null
index: null
previousSibling: null
nextSibling: null
children: Array<NodeWithHelpers<LHAST.RootContent, AST.RootContent, AST.Root>>
}>
: Node extends LHAST.Element
? Mixin<Node, {
id: string
parent: NullOrNodeWithHelpers<Parent>
index: number
previousSibling: NullOrNodeWithHelpers<Sibling>
nextSibling: NullOrNodeWithHelpers<Sibling>
children: Array<
NodeWithHelpers<
LHAST.ElementContent
, LHAST.ElementContent
, LHAST.Element
>
>
}>
: Mixin<Node, {
id: string
parent: NullOrNodeWithHelpers<Parent>
index: number | null
previousSibling: NullOrNodeWithHelpers<Sibling>
nextSibling: NullOrNodeWithHelpers<Sibling>
}>
function addHelpers<T extends LHAST.Node>(node: T): NodeWithHelpers<T>
function addHelpersInPlace<T extends LHAST.Node>(node: T): NodeWithHelpers<T>
removeHelpers
import { removeHelpers, removeHelpersInPlace } from 'lhast/utils/remove-helpers'
function removeHelpers<T extends LHAST.Node>(node: NodeWithHelpers<T>): T
function removeHelpersInPlace<T extends LHAST.Node>(node: NodeWithHelpers<T>): T
withHelpers
import { withHelpers, withHelpersInPlace } from 'lhast/utils/with-helpers'
function withHelpers<T extends AST.Node, U>(
node: T
, fn: (node: NodeWithHelpers<T>) => U
): U
function withHelpersInPlace<T extends AST.Node, U>(
node: T
, fn: (node: NodeWithHelpers<T>) => U
): U
2.0.4
11 months ago
2.0.3
2 years ago
2.0.2
2 years ago
2.0.1
2 years ago
1.0.7
2 years ago
1.0.6
2 years ago
2.0.0
2 years ago
1.0.2
2 years ago
1.0.4
2 years ago
1.0.3
2 years ago
1.0.1
2 years ago
1.0.0
2 years ago
0.5.0
2 years ago
0.4.4
2 years ago
0.4.3
2 years ago
0.4.2
2 years ago
0.4.1
2 years ago
0.4.0
2 years ago
0.3.5
2 years ago
0.3.4
2 years ago
0.3.3
2 years ago
0.3.2
2 years ago
0.3.1
2 years ago
0.3.0
2 years ago
0.2.1
2 years ago
0.2.0
2 years ago
0.1.1
2 years ago
0.1.0
2 years ago