Lottie Abstract Syntax Tree.

last is a specification for representing Lottie JSON in a syntax tree. It implements unist.

• Introduction
• Install
  • Where this specification fits
• Nodes
  • Parent
  • Literal
  • Root
  • Primitive
  • KeyNode
  • Member
  • ObjectNode
  • ArrayNode
  • Attribute
  • Element
  • Collection
• Glossary
• List of utilities
• References
• Security
• Related
• Contribute
• Acknowledgments
• License

This document defines a format for representing lottie as an abstract syntax tree. Development of last started in 2022.

yarn add @lottiefiles/last

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

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

last relates to the unified and relottie projects in that last syntax trees are used throughout their ecosystems.

interface Parent extends UnistParent {
  /**
   * Lottie's qualified name.
   */
  title: AnyTitle;
}

Parent (UnistParent) represents an abstract interface in last, containing other nodes (said to be children). In addition, has title prop which contains Lottie qualified name that can be found in titles.ts (that based on lottie-json-schema)

interface Literal extends UnistLiteral {}

Literal (UnistLiteral) represents an abstract interface in last containing a value.

interface Root extends Omit<ObjectNode, 'type'> {
  title: 'animation';
  type: 'root';
  hasExpressions: boolean
}

Root (Parent) represents a Lottie JSON.

Root can be used as the root of a tree, never as a child.

Root also has hasExpressions prop that tells whether the Lottie animation contains JS expressions. It is important to identify it early because of the security concerns.

type PrimitiveValueType = 'string' | 'number' | 'boolean' | 'null';

type PrimitiveValue = string | number | boolean | null;

interface Primitive extends Literal {
  type: 'primitive';
  value: PrimitiveValue;
  valueType?: PrimitiveValueType;
}

Primitive (Literal) represents a JSON property's value

interface KeyNode extends Literal {
  type: 'key';
  value: string;
}

KeyNode (Literal) represents a JSON property key.

/**
 * Base interface for Element, Collection & Attribute
 */
interface Member extends Parent {
  /**
   * Property's key
   */
  key: KeyNode | string;
  title: AttributeTitle | CollectionTitle | ElementTitle;
}

Member (Parent) represents the main interface for nodes that have a JSON property key that could be (KeyNode) or a string value.

type ObjectNodeValue = Attribute | Element | Collection;

interface ObjectNode extends Parent {
  children: ObjectNodeValue[];
  title: ObjectTitle;
  type: 'object';
}

ObjectNode (Parent) represents a JSON object value.

type ArrayNodeValue = Primitive | ObjectNode | ArrayNode;

interface ArrayNode extends Parent {
  children: ArrayNodeValue[];
  title: ArrayTitle;
  type: 'array';
}

ArrayNode (Parent) represents a JSON array value.

interface Attribute extends Member {
  children: [Primitive] | [];
  title: AttributeTitle;
  type: 'attribute';
}

Attribute (Member) represents a Member node which value is (Primitive).

interface Element extends Member {
  children: [ObjectNode] | [];
  title: ElementTitle;
  type: 'element';
}

Element (Member) represents a Member node which value is (ObjectNode).

interface Collection extends Member {
  children: [ArrayNode] | [];
  title: CollectionTitle;
  type: 'collection';
}

Collection (Member) represents a Member node which value is (ArrayNode).

See the unist glossary.

See the unist list of utilities for more utilities.

• last-builder — build last structures with composable functions

• unist: Universal Syntax Tree. T. Wormer; et al.
• lottie-web: Lottie Web Player. H. Torrisi; et al.
• lottie-docs: A human's guide to the Lottie format. M. Basaglia; et al.
• Lottie Animation Format Documentation

As last properties can have expressions, and improper use of last can open you up to cross-site scripting cross-site scripting (XSS). Carefully assess each plugin and the risks involved in using them.

• hast — Hypertext Abstract Syntax Tree format
• nlcst — Natural Language Concrete Syntax Tree format

By interacting with this repository, organization, or community you agree to abide by its terms.

• unified
• remark
• lottie-docs