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): asserts data is LHAST.Root

validateLHASTCompact

function validateLHASTCompact(data: unknown): asserts data is LHASTCompact.Root

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