RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://github.com/syntax-tree/xast below:

syntax-tree/xast: Extensible Abstract Syntax Tree

Extensible Abstract Syntax Tree format.

xast is a specification for representing XML as an abstract syntax tree. It implements the unist spec.

This document may not be released. See releases for released documents. The latest released version is 1.0.0.

Introduction
- Where this specification fits
- Scope
Types
Nodes (abstract)
- Literal
- Parent
Nodes
- Cdata
- Comment
- Doctype
- Element
- Instruction
- Root
- Text
Other types
Glossary
List of utilities
References
Related
Contribute
Acknowledgments
License

This document defines a format for representing XML as an abstract syntax tree. This specification is written in a Web IDL-like grammar. Development started in January 2020.

Where this specification fits

xast extends unist, a format for syntax trees, to benefit from its ecosystem of utilities.

xast relates to JavaScript in that it has an ecosystem of utilities for working with compliant syntax trees in JavaScript. However, xast is not limited to JavaScript and can be used in other programming languages.

xast relates to the unified project in that xast syntax trees are used throughout its ecosystem.

xast represents XML syntax, not semantics: there are no namespaces or local names; only qualified names.

xast supports a sensible subset of XML by omitting the ostensibly bad DTD. XML processors are not guaranteed to process DTDs, making them unsafe.

xast represents expanded entities and therefore does not deal with entities or character references. It is suggested that utilities around xast, that parse or serialize, do not support parameter-entity references or entity references other than the predefined entities (< for < U+003C LESS THAN; > for > U+003E GREATER THAN; & for & U+0026 AMPERSAND; ' for ' U+0027 APOSTROPHE; " for " U+0022 QUOTATION MARK). This prevents billion laughs attacks.

Declarations ([XML]) other than doctype have no representation in xast:

<!ELEMENT %name.para; %content.para;>
<!ATTLIST poem xml:space (default|preserve) 'preserve'>
<!ENTITY % ISOLat2 SYSTEM "http://www.xml.com/iso/isolat2-xml.entities">
<!ENTITY Pub-Status "This is a pre-release of the specification.">
<![%draft;[<!ELEMENT book (comments*, title, body, supplements?)>]]>
<![%final;[<!ELEMENT book (title, body, supplements?)>]]>

Internal document type declarations have no representation in xast:

<!DOCTYPE greeting [
  <!ELEMENT greeting (#PCDATA)>
]>
<greeting>Hello, world!</greeting>

If you are using TypeScript, you can use the xast types by installing them with npm:

interface Literal <: UnistLiteral {
  value: string
}

Literal (UnistLiteral) represents a node in xast containing a value.

interface Parent <: UnistParent {
  children: [Cdata | Comment | Doctype | Element | Instruction | Text]
}

Parent (UnistParent) represents a node in xast containing other nodes (said to be children).

Its content is limited to only other xast content.

interface Cdata <: Literal {
  type: 'cdata'
}

Cdata (Literal) represents a CDATA section ([XML]).

For example, the following XML:

<![CDATA[<greeting>Hello, world!</greeting>]]>

Yields:

{
  type: 'cdata',
  value: '<greeting>Hello, world!</greeting>'
}

interface Comment <: Literal {
  type: 'comment'
}

Comment (Literal) represents a comment ([XML]).

For example, the following XML:

Yields:

{type: 'comment', value: 'Charlie'}

interface Doctype <: Node {
  type: 'doctype'
  name: string
  public: string?
  system: string?
}

Doctype (Node) represents a doctype ([XML]).

A name field must be present.

A public field should be present. If present, it must be set to a string, and represents the document’s public identifier.

A system field should be present. If present, it must be set to a string, and represents the document’s system identifier.

For example, the following XML:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">

Yields:

{
  type: 'doctype',
  name: 'HTML',
  public: '-//W3C//DTD HTML 4.0 Transitional//EN',
  system: 'http://www.w3.org/TR/REC-html40/loose.dtd'
}

interface Element <: Parent {
  type: 'element'
  name: string
  attributes: Attributes?
  children: [Cdata | Comment | Element | Instruction | Text]
}

Element (Parent) represents an element ([XML]).

The name field must be present. It represents the element’s name ([XML]), specifically its qualified name ([XML-NAMES]).

The children field should be present.

The attributes field should be present. It represents information associated with the element. The value of the attributes field implements the Attributes interface.

For example, the following XML:

<package unique-identifier="id" xmlns="http://www.idpf.org/2007/opf" />

Yields:

{
  type: 'element',
  name: 'package',
  attributes: {
    'unique-identifier': 'id',
    xmlns: 'http://www.idpf.org/2007/opf'
  },
  children: []
}

interface Instruction <: Literal {
  type: 'instruction'
  name: string
}

Instruction (Literal) represents a processing instruction ([XML]).

A name field must be present.

For example, the following XML:

<?xml version="1.0" encoding="UTF-8"?>

Yields:

{
  type: 'instruction',
  name: 'xml',
  value: 'version="1.0" encoding="UTF-8"'
}

interface Root <: Parent {
  type: 'root'
}

Root (Parent) represents a document fragment or a whole document.

Root should be used as the root of a tree and must not be used as a child.

XML specifies that documents should have exactly one element child, therefore a root should have exactly one element child when representing a whole document.

interface Text <: Literal {
  type: 'text'
}

Text (Literal) represents character data ([XML]).

For example, the following XML:

<dc:language>en</dc:language>

Yields:

{
  type: 'element',
  name: 'dc:language',
  attributes: {},
  children: [{type: 'text', value: 'en'}]
}

Attributes represents information associated with an element.

Every field must be a AttributeName and every value an AttributeValue.

typedef string AttributeName

Attribute names are keys on Attributes objects and must reflect XML attribute names exactly.

typedef string AttributeValue

Attribute values are values on Attributes objects and must reflect XML attribute values exactly as a string.

In JSON, the value null must be treated as if the attribute was not included. In JavaScript, both null and undefined must be similarly ignored.

See the unist glossary.

See the unist list of utilities for more utilities.

xastscript — create trees
xast-util-feed — build feeds (RSS, Atom)
xast-util-from-xml — parse from XML
xast-util-sitemap — build sitemap.xml
xast-util-to-string — get the text value
xast-util-to-xml — serialize to XML
hast-util-to-xast — transform to xast

JSON The JavaScript Object Notation (JSON) Data Interchange Format, T. Bray. IETF.
JavaScript: ECMAScript Language Specification. Ecma International.
unist: Universal Syntax Tree. T. Wormer; et al.
XML: Extensible Markup Language (XML) 1.0 (Fifth Edition) T. Bray; et al. W3C.
XML-NAMES: Namespaces in XML 1.0 (Third Edition) T. Bray; et al. W3C.
Web IDL: Web IDL, C. McCormack. W3C.

hast — Hypertext Abstract Syntax Tree format
mdast — Markdown Abstract Syntax Tree format
nlcst — Natural Language Concrete Syntax Tree format

See contributing.md in syntax-tree/.github for ways to get started. See support.md for ways to get help. Ideas for new utilities and tools can be posted in syntax-tree/ideas.

A curated list of awesome syntax-tree, unist, hast, mdast, nlcst, and xast resources can be found in awesome syntax-tree.

This project has a code of conduct. By interacting with this repository, organization, or community you agree to abide by its terms.

The initial release of this project was authored by @wooorm.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4