tdewolff Parse

https://pkg.go.dev/github.com/tdewolff/parse/v2
Admin
This package contains several lexers and parsers written in Go that are designed to be streaming,...
Tokens:31,618
Snippets:475
Trust Score:9.6
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install the HTML package

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/html

Command to install the package via go get.

```bash
go get -u github.com/tdewolff/parse/v2/html
```

--------------------------------

### Install the XML package

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/xml

Use the go get command to add the package to your project.

```bash
go get -u github.com/tdewolff/parse/v2/xml
```

--------------------------------

### Install the js package

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Command to install the package via go get.

```bash
go get -u github.com/tdewolff/parse/v2/js
```

--------------------------------

### Install the CSS package

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/css

Use the go get command to install the package or add it to your project imports.

```bash
go get -u github.com/tdewolff/parse/v2/css
```

```go
import "github.com/tdewolff/parse/v2/css"
```

--------------------------------

### Install the JSON package

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/json

Use the go get command to add the package to your project.

```bash
go get -u github.com/tdewolff/parse/v2/json
```

--------------------------------

### Full XML Tokenization Example

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/xml

A complete example demonstrating how to read from stdin and process tags and attributes.

```go
package main

import (
	"os"

	"github.com/tdewolff/parse/v2/xml"
)

// Tokenize XML from stdin.
func main() {
	l := xml.NewLexer(parse.NewInput(os.Stdin))
	for {
		tt, data := l.Next()
		switch tt {
		case xml.ErrorToken:
			if l.Err() != io.EOF {
				fmt.Println("Error on line", l.Line(), ":", l.Err())
			}
			return
		case xml.StartTagToken:
			fmt.Println("Tag", string(data))
			for {
				ttAttr, dataAttr := l.Next()
				if ttAttr != xml.AttributeToken {
					break
				}

				key := dataAttr
				val := l.AttrVal()
				fmt.Println("Attribute", string(key), "=", string(val))
			}
		// ...
		}
	}
}
```

--------------------------------

### Full Tokenization Example

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/html

Complete example demonstrating how to tokenize HTML from stdin and extract attributes.

```go
package main

import (
	"os"

	"github.com/tdewolff/parse/v2/html"
)

// Tokenize HTML from stdin.
func main() {
	l := html.NewLexer(parse.NewInput(os.Stdin))
	for {
		tt, data := l.Next()
		switch tt {
		case html.ErrorToken:
			if l.Err() != io.EOF {
				fmt.Println("Error on line", l.Line(), ":", l.Err())
			}
			return
		case html.StartTagToken:
			fmt.Println("Tag", string(data))
			for {
				ttAttr, dataAttr := l.Next()
				if ttAttr != html.AttributeToken {
					break
				}

				key := dataAttr
				val := l.AttrVal()
				fmt.Println("Attribute", string(key), "=", string(val))
			}
		// ...
		}
	}
}
```

--------------------------------

### Install and Import the JSON Package

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/json

Commands to install the package via go get and the required import statement for Go projects.

```bash
go get -u github.com/tdewolff/parse/v2/json
```

```go
import "github.com/tdewolff/parse/v2/json"
```

--------------------------------

### Example output

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/buffer

Displays the expected output format.

```text
Output:
Lorem ipsum
```

--------------------------------

### Lexer Example Output

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/html

Example output from the lexer.

```text
Output:
<span class='user'>John Doe</span>
```

--------------------------------

### Tokenize JS from stdin

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Full example demonstrating how to read and process tokens from standard input.

```go
package main

import (
	"os"

	"github.com/tdewolff/parse/v2/js"
)

// Tokenize JS from stdin.
func main() {
	l := js.NewLexer(parse.NewInput(os.Stdin))
	for {
		tt, text := l.Next()
		switch tt {
		case js.ErrorToken:
			if l.Err() != io.EOF {
				fmt.Println("Error on line", l.Line(), ":", l.Err())
			}
			return
		case js.IdentifierToken:
			fmt.Println("Identifier", string(text))
		case js.NumericToken:
			fmt.Println("Numeric", string(text))
		// ...
		}
	}
}
```

--------------------------------

### Parser Output Example

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/json

Example output for a parser operation.

```text
{"key":5}
```

--------------------------------

### Get Var info

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/js

Retrieves information about the variable.

```go
func (v *Var) Info() string
```

--------------------------------

### Tokenize CSS from stdin

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/css

Complete example demonstrating how to read CSS from standard input and process specific tokens.

```go
package main

import (
	"os"

	"github.com/tdewolff/parse/v2/css"
)

// Tokenize CSS3 from stdin.
func main() {
	l := css.NewLexer(parse.NewInput(os.Stdin))
	for {
		tt, text := l.Next()
		switch tt {
		case css.ErrorToken:
			if l.Err() != io.EOF {
				fmt.Println("Error on line", l.Line(), ":", l.Err())
			}
			return
		case css.IdentToken:
			fmt.Println("Identifier", string(text))
		case css.NumberToken:
			fmt.Println("Number", string(text))
		// ...
		}
	}
}
```

--------------------------------

### Tokenize JSON from Stdin

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/json

A complete example demonstrating how to read JSON from standard input and handle specific grammar types.

```go
package main

import (
	"os"

	"github.com/tdewolff/parse/v2/json"
)

// Tokenize JSON from stdin.
func main() {
	p := json.NewParser(parse.NewInput(os.Stdin))
	for {
		gt, text := p.Next()
		switch gt {
		case json.ErrorGrammar:
			if p.Err() != io.EOF {
				fmt.Println("Error on line", p.Line(), ":", p.Err())
			}
			return
		case json.LiteralGrammar:
			fmt.Println("Literal", string(text))
		case json.NumberGrammar:
			fmt.Println("Number", string(text))
		// ...
		}
	}
}
```

--------------------------------

### Parse CSS stylesheet

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/css

Complete example demonstrating how to parse a CSS string and reconstruct it from grammar units.

```go
package main

import (
	"bytes"
	"fmt"

	"github.com/tdewolff/parse/v2/css"
)

func main() {
	// true because this is the content of an inline style attribute
	p := css.NewParser(parse.NewInput(bytes.NewBufferString("color: red;")), true)
	out := ""
	for {
		gt, _, data := p.Next()
		if gt == css.ErrorGrammar {
			break
		} else if gt == css.AtRuleGrammar || gt == css.BeginAtRuleGrammar || gt == css.BeginRulesetGrammar || gt == css.DeclarationGrammar {
			out += string(data)
			if gt == css.DeclarationGrammar {
				out += ":"
			}
			for _, val := range p.Values() {
				out += string(val.Data)
			}
			if gt == css.BeginAtRuleGrammar || gt == css.BeginRulesetGrammar {
				out += "{"
			} else if gt == css.AtRuleGrammar || gt == css.DeclarationGrammar {
				out += ";"
			}
		} else {
			out += string(data)
		}
	}
	fmt.Println(out)
}
```

--------------------------------

### Get String Representation of Property

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Returns the string representation of a property.

```go
func (n Property) String() string
```

--------------------------------

### Get String Representation of OpPrec

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Returns the string representation of an OpPrec value.

```go
func (prec OpPrec) String() string
```

--------------------------------

### Get Current Lexeme

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Returns the bytes of the current selection.

```go
func (z *Input) Lexeme() []byte
```

--------------------------------

### Get String Representation of Params

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Returns the string representation of parameters.

```go
func (n Params) String() string
```

--------------------------------

### Get Var name

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/js

Returns the variable name as a byte slice.

```go
func (v *Var) Name() []byte
```

--------------------------------

### Get String Representation of Return Statement

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Returns the string representation of a return statement.

```go
func (n ReturnStmt) String() string
```

--------------------------------

### Get Character Offset

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Returns the character position in the buffer.

```go
func (z *Input) Offset() int
```

--------------------------------

### Get Buffer Length

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Returns the length of the underlying buffer.

```go
func (z *Input) Len() int
```

--------------------------------

### Get String Representation of Property Name

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Returns the string representation of a property name.

```go
func (n PropertyName) String() string
```

--------------------------------

### Initialize and use the CSS Parser

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/css

Create a parser instance and iterate over grammar units.

```go
// true because this is the content of an inline style attribute
p := css.NewParser(parse.NewInput(bytes.NewBufferString("color: red;")), true)
```

```go
for {
    gt, _, data := p.Next()
    if gt == css.ErrorGrammar {
        break
    }
    // ...
}
```

--------------------------------

### Initialize the Lexer

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/xml

Create a new lexer instance using an input source.

```go
l := xml.NewLexer(parse.NewInput(r))
```

--------------------------------

### Get length of VarsByUses

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/js

Returns the number of elements in the collection.

```go
func (vs VarsByUses) Len() int
```

--------------------------------

### Initialize the Lexer

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/html

Create a new lexer instance using an io.Reader.

```go
l := html.NewLexer(parse.NewInput(r))
```

--------------------------------

### Get Position Mark

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Returns a mark that can be used for rewinding.

```go
func (z *Input) Pos() int
```

--------------------------------

### Lexer Initialization

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/html

Functions to create a new lexer instance.

```go
func NewLexer(r *parse.Input) *Lexer
```

```go
func NewTemplateLexer(r *parse.Input, tmpl [2]string) *Lexer
```

--------------------------------

### Initialize Lexer

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/xml

Creates a new Lexer instance for a given input.

```go
func NewLexer(r *parse.Input) *Lexer
```

--------------------------------

### Initialize and use the CSS Lexer

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/css

Create a new lexer from an io.Reader and iterate through tokens until EOF.

```go
l := css.NewLexer(parse.NewInput(r))
```

```go
for {
	tt, text := l.Next()
	switch tt {
	case css.ErrorToken:
		// error or EOF set in l.Err()
		return
	// ...
	}
}
```

--------------------------------

### Lexer Initialization and Usage

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Provides state for lexing and tokenizing input.

```go
type Lexer struct {
	// contains filtered or unexported fields
}
```

```go
func NewLexer(r *parse.Input) *Lexer
```

```text
Output:
var x = 'lorem ipsum';
```

```go
func (l *Lexer) Err() error
```

```go
func (l *Lexer) Next() (TokenType, []byte)
```

```go
func (l *Lexer) RegExp() (TokenType, []byte)
```

--------------------------------

### Initialize the JSON Parser

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/json

Create a new parser instance using an input reader.

```go
p := json.NewParser(parse.NewInput(r))
```

--------------------------------

### Initialize and Use the JSON Parser

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/json

Basic initialization of the parser and a loop structure to iterate through tokens until EOF or an error occurs.

```go
p := json.NewParser(parse.NewInput(r))
```

```go
for {
	gt, text := p.Next()
	switch gt {
	case json.ErrorGrammar:
		// error or EOF set in p.Err()
		return
	// ...
	}
}
```

--------------------------------

### DirectivePrologueStmt Structure and Methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Represents a string literal directive at the start of a scope.

```go
type DirectivePrologueStmt struct {
	Value []byte
}
```

```go
func (n DirectivePrologueStmt) JS(w io.Writer)
```

```go
func (n DirectivePrologueStmt) String() string
```

--------------------------------

### Lexer navigation and state methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/buffer

Methods to retrieve buffer data, current position, errors, and manage selection state.

```go
func (z *Lexer) Bytes() []byte
```

```go
func (z *Lexer) Err() error
```

```go
func (z *Lexer) Lexeme() []byte
```

```go
func (z *Lexer) Move(n int)
```

```go
func (z *Lexer) Offset() int
```

```go
func (z *Lexer) Pos() int
```

```go
func (z *Lexer) Reset()
```

```go
func (z *Lexer) Restore()
```

```go
func (z *Lexer) Rewind(pos int)
```

```go
func (z *Lexer) Shift() []byte
```

```go
func (z *Lexer) Skip()
```

--------------------------------

### Import the XML package

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/xml

Add this import statement to your Go source files.

```go
import "github.com/tdewolff/parse/v2/xml"
```

--------------------------------

### Initialize Parser

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/css

Creates a new Parser instance, with an option to specify if the input is an inline style attribute.

```go
func NewParser(r *parse.Input, isInline bool) *Parser
```

--------------------------------

### Get Input Error

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Returns the error from io.Input or io.EOF upon reaching the end.

```go
func (z *Input) Err() error
```

--------------------------------

### Import the JSON package

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/json

Add this import statement to your Go source files.

```go
import "github.com/tdewolff/parse/v2/json"
```

--------------------------------

### Define Parser Options

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Configuration options for the parser behavior.

```go
type Options struct {
	WhileToFor bool
	Inline     bool
}
```

--------------------------------

### Initialize Reader

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/buffer

Creates a new Reader instance for a given byte slice.

```go
func NewReader(buf []byte) *Reader
```

--------------------------------

### Lexer navigation methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/buffer

Methods to move, skip, or rewind the position within the buffer.

```go
func (z *Lexer) Move(n int)
```

```go
func (z *Lexer) Offset() int
```

```go
func (z *Lexer) Pos() int
```

```go
func (z *Lexer) Reset()
```

```go
func (z *Lexer) Restore()
```

```go
func (z *Lexer) Rewind(pos int)
```

```go
func (z *Lexer) Shift() []byte
```

```go
func (z *Lexer) Skip()
```

--------------------------------

### Import the HTML package

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/html

Import statement for including the package in a Go project.

```go
import "github.com/tdewolff/parse/v2/html"
```

--------------------------------

### Lexer Methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/html

Methods for interacting with the lexer state and retrieving token information.

```go
func (l *Lexer) AttrKey() []byte
```

```go
func (l *Lexer) AttrVal() []byte
```

```go
func (l *Lexer) Err() error
```

```go
func (l *Lexer) HasTemplate() bool
```

```go
func (l *Lexer) Next() (TokenType, []byte)
```

```go
func (l *Lexer) Text() []byte
```

--------------------------------

### Writer Definition and Initialization

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/buffer

Defines the Writer structure and constructors for byte slice output.

```go
type Writer struct {
	// contains filtered or unexported fields
}
```

```go
func NewStaticWriter(buf []byte) *Writer
```

```go
func NewWriter(buf []byte) *Writer
```

--------------------------------

### AST Traversal

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Utility to traverse the AST.

```go
func Walk(v IVisitor, n INode)
```

--------------------------------

### NewParser Constructor

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/json

Creates a new parser for a given input.

```go
func NewParser(r *parse.Input) *Parser
```

--------------------------------

### Arg Struct and Methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Represents an argument and provides methods to write it as JavaScript or convert it to a string.

```go
func (n Arg) JS(w io.Writer)
```

```go
func (n Arg) String() string
```

--------------------------------

### Printable

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Returns a printable string representation of a rune.

```go
func Printable(r rune) string
```

--------------------------------

### BinaryReader Constructors

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Various constructors for creating a BinaryReader from different sources.

```go
func NewBinaryReader(f IBinaryReader) *BinaryReader
```

```go
func NewBinaryReaderBytes(data []byte) *BinaryReader
```

```go
func NewBinaryReaderFile(f *os.File) (*BinaryReader, error)
```

```go
func NewBinaryReaderMmap(filename string) (*BinaryReader, error)
```

```go
func NewBinaryReaderPath(filename string) (*BinaryReader, error)
```

```go
func NewBinaryReaderReader(r io.Reader, n int64) (*BinaryReader, error)
```

--------------------------------

### BinaryReader Clone

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Creates a copy of the BinaryReader.

```go
func (r *BinaryReader) Clone() *BinaryReader
```

--------------------------------

### List of CSS grammar units

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/css

Reference list of all grammar units returned by the parser.

```go
ErrorGrammar
AtRuleGrammar
EndAtRuleGrammar
RulesetGrammar
EndRulesetGrammar
DeclarationGrammar
TokenGrammar
```

--------------------------------

### NewStreamLexer Constructor

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/buffer

Returns a new StreamLexer for a given io.Reader with a 4kB estimated buffer size.

```go
func NewStreamLexer(r io.Reader) *StreamLexer
```

--------------------------------

### Copy

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Returns a copy of the given byte slice.

```go
func Copy(src []byte) (dst []byte)
```

--------------------------------

### AST Structure and Methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

The main AST structure and its serialization methods.

```go
type AST struct {
	BlockStmt // module
}
```

```go
func Parse(r *parse.Input, o Options) (*AST, error)
```

```go
func (ast AST) JS(w io.Writer)
```

```go
func (ast AST) JSON(w io.Writer) error
```

```go
func (ast AST) JSONString() (string, error)
```

```go
func (ast AST) JSString() string
```

```go
func (ast AST) String() string
```

--------------------------------

### Available Token Types

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/html

List of all possible token types returned by the lexer.

```go
ErrorToken TokenType = iota // extra token when errors occur
CommentToken
DoctypeToken
StartTagToken
StartTagCloseToken
StartTagVoidToken
EndTagToken
AttributeToken
TextToken
```

--------------------------------

### Convert Token to String

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/css

Returns the string representation of a token.

```go
func (t Token) String() string
```

--------------------------------

### Import the js package

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Import statement for including the package in a Go project.

```go
import "github.com/tdewolff/parse/v2/js"
```

--------------------------------

### List of CSS tokens

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/css

Reference list of all token types returned by the lexer.

```go
ErrorToken			// non-official token, returned when errors occur
IdentToken
FunctionToken		// rgb( rgba( ...
AtKeywordToken		// @abc
HashToken			// #abc
StringToken
BadStringToken
URLToken			// url(
BadURLToken
DelimToken			// any unmatched character
NumberToken			// 5
PercentageToken		// 5%
DimensionToken		// 5em
UnicodeRangeToken
IncludeMatchToken	// ~=
DashMatchToken		// |=
PrefixMatchToken	// ^=
SuffixMatchToken	// $=
SubstringMatchToken // *=
ColumnToken			// ||
WhitespaceToken
CDOToken 			// <!--
CDCToken 			// -->
ColonToken
SemicolonToken
CommaToken
BracketToken 		// ( ) [ ] { }, all bracket tokens use this, Data() can distinguish between the brackets
CommentToken		// non-official token
```

--------------------------------

### NewStreamLexerSize Constructor

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/buffer

Returns a new StreamLexer for a given io.Reader and estimated required buffer size.

```go
func NewStreamLexerSize(r io.Reader, size int) *StreamLexer
```

--------------------------------

### Mediatype

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Parses a mediatype string into its components.

```go
func Mediatype(b []byte) ([]byte, map[string]string)
```

--------------------------------

### Error Handling Utilities

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Structures and constructors for reporting parsing errors.

```go
type Error struct {
	Message string
	Line    int
	Column  int
	Context string
}
```

```go
func NewError(r io.Reader, offset int, message string, a ...interface{}) *Error
```

```go
func NewErrorLexer(l *Input, message string, a ...interface{}) *Error
```

```go
func (e *Error) Error() string
```

```go
func (e *Error) Position() (int, int, string)
```

--------------------------------

### Writer Bytes Method

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/buffer

Returns the underlying byte slice.

```go
func (w *Writer) Bytes() []byte
```

--------------------------------

### AST Interfaces

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Core interfaces for bindings, expressions, nodes, statements, and visitors.

```go
type IBinding interface {
	INode
	// contains filtered or unexported methods
}
```

```go
type IExpr interface {
	INode
	// contains filtered or unexported methods
}
```

```go
type INode interface {
	String() string
	JS(io.Writer)
}
```

```go
type IStmt interface {
	INode
	// contains filtered or unexported methods
}
```

```go
type IVisitor interface {
	Enter(n INode) IVisitor
	Exit(n INode)
}
```

--------------------------------

### DoWhileStmt Structure and Methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Represents a do-while iteration statement.

```go
type DoWhileStmt struct {
	Cond IExpr
	Body IStmt
}
```

```go
func (n DoWhileStmt) JS(w io.Writer)
```

```go
func (n DoWhileStmt) String() string
```

--------------------------------

### Define Template Delimiters

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/html

Predefined template delimiter configurations for various template engines.

```go
var ASPTemplate = [2]string{"<%", "%>"}
```

```go
var EJSTemplate = [2]string{"<%", "%>"}
```

```go
var GoTemplate = [2]string{{"{{", "}}"}
```

```go
var HandlebarsTemplate = [2]string{{"{{", "}}"}
```

```go
var MustacheTemplate = [2]string{{"{{", "}}"}
```

```go
var PHPTemplate = [2]string{"<?", "?>"}
```

--------------------------------

### NewWriter Constructor

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/buffer

Returns a new Writer for a given byte slice.

```go
func NewWriter(buf []byte) *Writer
```

```text
Output:
Lorem ipsum
```

--------------------------------

### Reader Methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/buffer

Methods for interacting with the Reader buffer.

```go
func (r *Reader) Bytes() []byte
```

```go
func (r *Reader) Len() int
```

```go
func (r *Reader) Read(b []byte) (n int, err error)
```

```go
func (r *Reader) Reset()
```

--------------------------------

### Args Struct and Methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Represents a list of arguments used in expressions.

```go
type Args struct {
	List []Arg
}
```

```go
func (n Args) JS(w io.Writer)
```

```go
func (n Args) String() string
```

--------------------------------

### Parser Limits

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Configuration limits for nested expressions and statements.

```go
var NestedExprLimit = 1000
```

```go
var NestedStmtLimit = 1000
```

--------------------------------

### TryStmt methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Methods for writing or stringifying a try statement.

```go
func (n TryStmt) JS(w io.Writer)
```

```go
func (n TryStmt) String() string
```

--------------------------------

### json.NewParser

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/json

Initializes a new JSON parser for a given input source.

```APIDOC
## func NewParser(r *parse.Input) *Parser

### Description
Returns a new Parser instance initialized with the provided input source.

### Parameters
- **r** (*parse.Input) - Required - The input source to be tokenized.
```

--------------------------------

### Convert Var to string

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/js

Returns the string representation of the variable.

```go
func (v Var) String() string
```

--------------------------------

### TokenType string conversion methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Methods to retrieve the byte or string representation of a token type.

```go
func (tt TokenType) Bytes() []byte
```

```go
func (tt TokenType) String() string
```

--------------------------------

### BitmapReader Methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2

Methods for reading individual bits from a binary buffer.

```APIDOC
## func NewBitmapReader

### Description
Returns a binary bitmap reader.

### Signature
`func NewBitmapReader(buf []byte) *BitmapReader`

## func (*BitmapReader) EOF

### Description
Returns if we reached the buffer's end-of-file.

### Signature
`func (r *BitmapReader) EOF() bool`

## func (*BitmapReader) Pos

### Description
Returns the current bit position.

### Signature
`func (r *BitmapReader) Pos() uint32`

## func (*BitmapReader) Read

### Description
Reads the next bit.

### Signature
`func (r *BitmapReader) Read() bool`
```

--------------------------------

### Writer Methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/buffer

Methods for managing the state and content of a Writer.

```go
func (w *Writer) Bytes() []byte
```

```go
func (w *Writer) Close() error
```

```go
func (w *Writer) Len() int
```

```go
func (w *Writer) Reset()
```

--------------------------------

### ImportStmt Structure

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Represents an import statement.

```go
type ImportStmt struct {
	List    []Alias
	Default []byte // can be nil
	Module  []byte
}
```

```go
func (n ImportStmt) JS(w io.Writer)
```

```go
func (n ImportStmt) String() string
```

--------------------------------

### Input Buffer Management

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Buffered reader implementation for parsing input streams.

```go
type Input struct {
	// contains filtered or unexported fields
}
```

```go
func NewInput(r io.Reader) *Input
```

```go
func NewInputBytes(b []byte) *Input
```

```go
func NewInputString(s string) *Input
```

```go
func (z *Input) Bytes() []byte
```

--------------------------------

### Define Token Types

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/xml

Enumeration of possible XML token types.

```go
const (
	ErrorToken TokenType = iota // extra token when errors occur
	CommentToken
	DOCTYPEToken
	CDATAToken
	StartTagToken
	StartTagPIToken
	StartTagCloseToken
	StartTagCloseVoidToken
	StartTagClosePIToken
	EndTagToken
	AttributeToken
	TextToken
)
```

--------------------------------

### Template Delimiter Definitions

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/html

Predefined template delimiter configurations for various template engines.

```go
var ASPTemplate = [2]string{"<%", "%>"}
```

```go
var EJSTemplate = [2]string{"<%", "%>"}
```

```go
var GoTemplate = [2]string{"{{", "}}"}
```

```go
var HandlebarsTemplate = [2]string{"{{", "}}"}
```

```go
var MustacheTemplate = [2]string{"{{", "}}"}
```

```go
var PHPTemplate = [2]string{"<?", "?>"}
```

--------------------------------

### AST Structure and Parsing

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/js

Definition of the AST structure and the main Parse function.

```go
type AST struct {
	BlockStmt // module
}
```

```go
func Parse(r *parse.Input, o Options) (*AST, error)
```

--------------------------------

### Token Types

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/html

Definitions for various HTML token types.

```go
type TokenType uint32
```

```go
const (
	ErrorToken TokenType = iota // extra token when errors occur
	CommentToken
	DoctypeToken
	StartTagToken
	StartTagCloseToken
	StartTagVoidToken
	EndTagToken
	AttributeToken
	TextToken
	SVGToken
	MathToken
	XMLToken
	TemplateToken
)
```

--------------------------------

### Define identifier token constants

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Token types for identifiers and contextual keywords.

```go
const (
	IdentifierToken TokenType = 0x1000 + iota
	AsToken
	AsyncToken
	FromToken
	GetToken
	ImplementsToken
	InterfaceToken
	LetToken
	MetaToken
	OfToken
	PackageToken
	PrivateToken
	ProtectedToken
	PublicToken
	SetToken
	StaticToken
	TargetToken
)
```

--------------------------------

### BinaryReader Methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2

Methods for reading binary data from a buffer, including support for various integer types and io.Reader compliance.

```go
func (r *BinaryReader) Close() error
```

```go
func (r *BinaryReader) Err() error
```

```go
func (r *BinaryReader) IBinaryReader() IBinaryReader
```

```go
func (r *BinaryReader) InPageCache(start, end int64) bool
```

```go
func (r *BinaryReader) Len() int64
```

```go
func (r *BinaryReader) Pos() int64
```

```go
func (r *BinaryReader) Read(b []byte) (int, error)
```

```go
func (r *BinaryReader) ReadAt(b []byte, off int64) (int, error)
```

```go
func (r *BinaryReader) ReadByte() (byte, error)
```

```go
func (r *BinaryReader) ReadBytes(n int64) []byte
```

```go
func (r *BinaryReader) ReadInt8() int8
```

```go
func (r *BinaryReader) ReadInt16() int16
```

```go
func (r *BinaryReader) ReadInt24() int32
```

```go
func (r *BinaryReader) ReadInt32() int32
```

```go
func (r *BinaryReader) ReadInt64() int64
```

```go
func (r *BinaryReader) ReadString(n int64) string
```

```go
func (r *BinaryReader) ReadUint8() uint8
```

```go
func (r *BinaryReader) ReadUint16() uint16
```

```go
func (r *BinaryReader) ReadUint24() uint32
```

```go
func (r *BinaryReader) ReadUint32() uint32
```

```go
func (r *BinaryReader) ReadUint64() uint64
```

```go
func (r *BinaryReader) Seek(off int64, whence int) (int64, error)
```

--------------------------------

### Input Methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2

Methods available on the Input struct for navigating and reading from the input stream.

```APIDOC
## func (z *Input) Offset() int
Returns the current offset in the input.

## func (z *Input) Peek(pos int) byte
Returns the byte at the specified position relative to the current offset.

## func (z *Input) PeekErr(pos int) error
Returns an error if the byte at the specified position cannot be read.

## func (z *Input) PeekRune(pos int) (rune, int)
Returns the rune and its byte length at the specified position.

## func (z *Input) Pos() int
Returns the current position.

## func (z *Input) Reset()
Resets the input state.

## func (z *Input) Restore()
Restores the input to a previously saved state.

## func (z *Input) Rewind(pos int)
Rewinds the input to the specified position.

## func (z *Input) Shift() []byte
Shifts the input and returns the consumed byte slice.

## func (z *Input) Skip()
Skips the current byte or character.
```

--------------------------------

### Define standard token constants

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Basic token types including errors, whitespace, comments, and string literals.

```go
const (
	ErrorToken TokenType = iota // extra token when errors occur
	WhitespaceToken
	LineTerminatorToken // \r \n \r\n
	CommentToken
	CommentLineTerminatorToken
	StringToken
	TemplateToken
	TemplateStartToken
	TemplateMiddleToken
	TemplateEndToken
	RegExpToken
	PrivateIdentifierToken
)
```

--------------------------------

### Lexer peeking methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/buffer

Methods to inspect upcoming bytes or runes without advancing the position.

```go
func (z *Lexer) Peek(pos int) byte
```

```go
func (z *Lexer) PeekErr(pos int) error
```

```go
func (z *Lexer) PeekRune(pos int) (rune, int)
```

--------------------------------

### Position

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Returns the line and column number for a specific file offset.

```go
func Position(r io.Reader, offset int) (line, col int, context string)
```

--------------------------------

### StreamLexer Definition and Initialization

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/buffer

Defines the StreamLexer structure and constructors for creating instances from an io.Reader.

```go
type StreamLexer struct {
	// contains filtered or unexported fields
}
```

```go
func NewStreamLexer(r io.Reader) *StreamLexer
```

```go
func NewStreamLexerSize(r io.Reader, size int) *StreamLexer
```

--------------------------------

### XML Token Types

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/xml

List of all available token types returned by the lexer.

```go
ErrorToken TokenType = iota // extra token when errors occur
CommentToken
CDATAToken
StartTagToken
StartTagCloseToken
StartTagCloseVoidToken
StartTagClosePIToken
EndTagToken
AttributeToken
TextToken
```

--------------------------------

### BindingObject Struct and Methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Represents an object binding pattern.

```go
type BindingObject struct {
	List []BindingObjectItem
	Rest *Var // can be nil
}
```

```go
func (n BindingObject) JS(w io.Writer)
```

```go
func (n BindingObject) String() string
```

--------------------------------

### Parser Next Token

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/json

Retrieves the next grammar token from the input.

```go
func (p *Parser) Next() (GrammarType, []byte)
```

--------------------------------

### func NewParser

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/css

Initializes a new CSS Parser for parsing input.

```APIDOC
## func NewParser(r *parse.Input, isInline bool) *Parser

### Description
Returns a new CSS parser from an input reader. The isInline parameter specifies whether the content is an inline style attribute.

### Parameters
- **r** (*parse.Input) - The input source to parse
- **isInline** (bool) - Whether the input is an inline style

### Returns
- ***Parser** - A pointer to the initialized Parser
```

--------------------------------

### html.NewLexer

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/html

Initializes a new HTML lexer instance using an input source.

```APIDOC
## html.NewLexer(r *parse.Input)

### Description
Initializes a new Lexer instance to tokenize HTML content from the provided input.

### Parameters
- **r** (*parse.Input) - Required - The input source to be tokenized.

### Returns
- **l** (*html.Lexer) - The initialized lexer instance.
```

--------------------------------

### Define Hash Constants

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/html

Perfect hash constants for common HTML tags.

```go
const (
	Iframe    Hash = 0x6    // iframe
	Math      Hash = 0x604  // math
	Plaintext Hash = 0x2109 // plaintext
	Script    Hash = 0xa06  // script
	Style     Hash = 0x1405 // style
	Svg       Hash = 0x1903 // svg
	Textarea  Hash = 0x2608 // textarea
	Title     Hash = 0xf05  // title
	Xml       Hash = 0x1c03 // xml
	Xmp       Hash = 0x1f03 // xmp
)
```

--------------------------------

### Comment Structure and Methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Represents a comment block or line.

```go
type Comment struct {
	Value []byte
}
```

```go
func (n Comment) JS(w io.Writer)
```

```go
func (n Comment) String() string
```

--------------------------------

### AST Serialization Methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/js

Methods for converting AST to JavaScript or JSON strings.

```go
func (ast AST) JS(w io.Writer)
```

```go
func (ast AST) JSON(w io.Writer) error
```

```go
func (ast AST) JSONString() (string, error)
```

```go
func (ast AST) JSString() string
```

```go
func (ast AST) String() string
```

--------------------------------

### Parser and State API

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/json

Core methods for interacting with the Parser and the State enumeration.

```go
func (gt GrammarType) String() string
```

```go
type Parser struct {
	// contains filtered or unexported fields
}
```

```go
func NewParser(r *parse.Input) *Parser
```

```go
{"key":5}
```

```go
func (p *Parser) Err() error
```

```go
func (p *Parser) Next() (GrammarType, []byte)
```

```go
func (p *Parser) State() State
```

```go
type State uint32
```

```go
const (
	ValueState State = iota // extra token when errors occur
	ObjectKeyState
	ObjectValueState
	ArrayState
)
```

```go
func (state State) String() string
```

--------------------------------

### Convert WithStmt to string

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/js

Returns the string representation of the with statement.

```go
func (n WithStmt) String() string
```

--------------------------------

### Define PageSize constant

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Defines the default page size used for input processing.

```go
const PageSize = 4096
```

--------------------------------

### BitmapReader Operations

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Structures and methods for reading binary bitmaps.

```go
type BitmapReader struct {
	// contains filtered or unexported fields
}
```

```go
func NewBitmapReader(buf []byte) *BitmapReader
```

```go
func (r *BitmapReader) EOF() bool
```

```go
func (r *BitmapReader) Pos() uint32
```

```go
func (r *BitmapReader) Read() bool
```

--------------------------------

### Writer Close Method

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/buffer

Returns the last error.

```go
func (w *Writer) Close() error
```

--------------------------------

### Lexer buffer access methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/buffer

Methods to retrieve the underlying buffer, current lexeme, or error status.

```go
func (z *Lexer) Bytes() []byte
```

```go
func (z *Lexer) Err() error
```

```go
func (z *Lexer) Lexeme() []byte
```

--------------------------------

### Input Methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Methods available on the Input struct for buffer manipulation and inspection.

```APIDOC
## func (*Input) Err()

Err returns the error returned from io.Input or io.EOF when the end has been reached.

## func (*Input) Len()

Len returns the length of the underlying buffer.

## func (*Input) Lexeme()

Lexeme returns the bytes of the current selection.

## func (*Input) Move(n int)

Move advances the position by n.

## func (*Input) MoveRune()

MoveRune advances the position by the length of the current rune.

## func (*Input) Offset()

Offset returns the character position in the buffer.

## func (*Input) Peek(pos int) byte

Peek returns the ith byte relative to the end position. Peek returns 0 when an error has occurred.

## func (*Input) PeekErr(pos int) error

PeekErr returns the error at position pos.

## func (*Input) PeekRune(pos int) (rune, int)

PeekRune returns the rune and rune length of the ith byte relative to the end position.

## func (*Input) Pos() int

Pos returns a mark to which can be rewinded.

## func (*Input) Reset()

Reset resets position to the underlying buffer.

## func (*Input) Restore()

Restore restores the replaced byte past the end of the buffer by NULL.

## func (*Input) Rewind(pos int)

Rewind rewinds the position to the given position.

## func (*Input) Shift() []byte

Shift returns the bytes of the current selection and collapses the position to the end of the selection.

## func (*Input) Skip()

Skip collapses the position to the end of the selection.
```

--------------------------------

### Hash Type and Constants

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/html

Definitions for perfect hashes used to identify specific HTML tags.

```go
type Hash uint32
```

```go
const (
	Iframe    Hash = 0x6    // iframe
	Math      Hash = 0x604  // math
	Plaintext Hash = 0x2109 // plaintext
	Script    Hash = 0xa06  // script
	Style     Hash = 0x1405 // style
	Svg       Hash = 0x1903 // svg
	Textarea  Hash = 0x2608 // textarea
	Title     Hash = 0xf05  // title
	Xml       Hash = 0x1c03 // xml
	Xmp       Hash = 0x1f03 // xmp
)
```

--------------------------------

### Move Position by Rune

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Advances the position by the length of the current rune.

```go
func (z *Input) MoveRune()
```

--------------------------------

### String representation of TemplatePart

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Returns the string representation of the template part.

```go
func (n TemplatePart) String() string
```

--------------------------------

### html.NewLexer

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/html

Initializes a new HTML lexer using an input source.

```APIDOC
## html.NewLexer(r *parse.Input)

### Description
Initializes a new Lexer instance to tokenize HTML content from the provided input.

### Parameters
- **r** (*parse.Input) - Required - The input source to be tokenized.
```

--------------------------------

### BinaryWriter Methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Methods for writing various data types to a BinaryWriter buffer.

```go
func (w *BinaryWriter) WriteString(v string)
```

```go
func (w *BinaryWriter) WriteUint8(v uint8)
```

```go
func (w *BinaryWriter) WriteUint16(v uint16)
```

```go
func (w *BinaryWriter) WriteUint24(v uint32)
```

```go
func (w *BinaryWriter) WriteUint32(v uint32)
```

```go
func (w *BinaryWriter) WriteUint64(v uint64)
```

--------------------------------

### Write Return Statement to Writer

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Writes the JavaScript representation of a return statement to an io.Writer.

```go
func (n ReturnStmt) JS(w io.Writer)
```

--------------------------------

### Write Parameters to Writer

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Writes the JavaScript representation of parameters to an io.Writer.

```go
func (n Params) JS(w io.Writer)
```

--------------------------------

### BinaryWriter Structure and Methods

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2

Structure and methods for writing big-endian binary data to a buffer.

```go
type BinaryWriter struct {
	ByteOrder binary.AppendByteOrder
	// contains filtered or unexported fields
}
```

```go
func NewBinaryWriter(buf []byte) *BinaryWriter
```

```go
func (w *BinaryWriter) Bytes() []byte
```

```go
func (w *BinaryWriter) Len() int64
```

```go
func (w *BinaryWriter) Write(b []byte) (int, error)
```

```go
func (w *BinaryWriter) WriteByte(v byte)
```

```go
func (w *BinaryWriter) WriteBytes(v []byte)
```

```go
func (w *BinaryWriter) WriteInt8(v int8)
```

```go
func (w *BinaryWriter) WriteInt16(v int16)
```

```go
func (w *BinaryWriter) WriteInt24(v int32)
```

```go
func (w *BinaryWriter) WriteInt32(v int32)
```

```go
func (w *BinaryWriter) WriteInt64(v int64)
```

--------------------------------

### String representation of Scope

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Returns the string representation of the scope.

```go
func (s Scope) String() string
```

--------------------------------

### Reader Len Method

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/buffer

Returns the length of the buffer.

```go
func (r *Reader) Len() int
```

--------------------------------

### Lexer Next Token

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/xml

Advances the lexer to the next token.

```go
func (l *Lexer) Next() (TokenType, []byte)
```

--------------------------------

### Input Buffering

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2

Methods for creating and managing buffered input streams.

```APIDOC
## func NewInput

### Description
Returns a new Input for a given io.Reader.

### Signature
`func NewInput(r io.Reader) *Input`

## func NewInputBytes

### Description
Returns a new Input for a given byte slice.

### Signature
`func NewInputBytes(b []byte) *Input`

## func NewInputString

### Description
Returns a new Input for a given string.

### Signature
`func NewInputString(s string) *Input`

## func (*Input) Bytes

### Description
Returns the underlying buffer.

### Signature
`func (z *Input) Bytes() []byte`
```

--------------------------------

### Indenter Operations

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13

Utilities for managing indentation during writing.

```go
type Indenter struct {
	io.Writer
	// contains filtered or unexported fields
}
```

```go
func NewIndenter(w io.Writer, n int) Indenter
```

```go
func (Indenter) Indent() int
```

```go
func (Indenter) Write(b []byte) (int, error)
```

--------------------------------

### ImportMetaExpr Structure

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Represents an import meta property.

```go
type ImportMetaExpr struct{}
```

```go
func (n ImportMetaExpr) JS(w io.Writer)
```

```go
func (n ImportMetaExpr) String() string
```

--------------------------------

### Write Property Name to Writer

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Writes the JavaScript representation of a property name to an io.Writer.

```go
func (n PropertyName) JS(w io.Writer)
```

--------------------------------

### js.NewParser

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/js

Parses JavaScript input and returns an abstract syntax tree (AST).

```APIDOC
## js.NewParser

### Description
Parses a string or input source and returns an abstract syntax tree (AST) representing the JavaScript code.

### Usage
```go
ast, err := js.NewParser(parse.NewInputString("if (state == 5) { console.log('In state five'); }"))
```
```

--------------------------------

### js.NewParser

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/js

Parses JavaScript input and returns an abstract syntax tree (AST).

```APIDOC
## js.NewParser(input)

### Description
Parses the provided input and returns an abstract syntax tree (AST) representing the JavaScript code.

### Usage
```go
ast, err := js.NewParser(parse.NewInputString("if (state == 5) { console.log('In state five'); }"))
```
```

--------------------------------

### Define Hash Constants

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/css

Defines perfect hashes for common CSS identifiers.

```go
type Hash uint32

const (
	Document  Hash = 0x8    // document
	Font_Face Hash = 0x809  // font-face
	Keyframes Hash = 0x1109 // keyframes
	Layer     Hash = 0x2105 // layer
	Media     Hash = 0x2605 // media
	Page      Hash = 0x2b04 // page
	Supports  Hash = 0x1908 // supports
)
```

--------------------------------

### Retrieve Parser Values

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2%40v2.8.13/css

Returns a slice of tokens for the last grammar, applicable to at-rules, rulesets, and declarations.

```go
func (p *Parser) Values() []Token
```

--------------------------------

### Switch Statement Representation

Source: https://pkg.go.dev/github.com/tdewolff/parse/v2/js

Structure and methods for handling JavaScript switch statements.

```go
type SwitchStmt struct {
	Init IExpr
	List []CaseClause
	Scope
}
```

```go
func (n SwitchStmt) JS(w io.Writer)
```

```go
func (n SwitchStmt) String() string
```
Tokens:
Raw