• Version 9.33.1
  • Published
  • 1.31 MB
  • No dependencies
  • MIT license


npm i liquidjs
yarn add liquidjs
pnpm add liquidjs


A simple, expressive and safe Shopify / Github Pages compatible template engine in pure JavaScript.







Type Aliases



variable defaultOperators

const defaultOperators: Operators;

    variable version

    const version: string;


      function assert

      assert: <T>(
      predicate: T | null | undefined,
      message?: string | (() => string)
      ) => void;

        function createTrie

        createTrie: (operators: Operators) => Trie;

          function evalQuotedToken

          evalQuotedToken: (token: QuotedToken) => string;

            function evalToken

            evalToken: (token: Token | undefined, ctx: Context, lenient?: boolean) => any;

              function isFalsy

              isFalsy: (val: any, ctx: Context) => boolean;

                function isTruthy

                isTruthy: (val: any, ctx: Context) => boolean;

                  function toPromise

                  toPromise: <T>(
                  val: Generator<unknown, T, unknown> | Thenable<T> | T
                  ) => Promise<T>;

                    function toThenable

                    toThenable: <T>(
                    val: IteratorResult<unknown, T> | Thenable<T> | any
                    ) => Thenable<T>;

                      function toValue

                      toValue: (value: any) => any;


                        class AssertionError

                        class AssertionError extends Error {}


                          constructor(message: string);

                            class Context

                            class Context {}


                              env?: {},
                              opts?: NormalizedFullOptions,
                              renderOptions?: RenderOptions

                                property environments

                                environments: Scope;
                                • user passed in scope {% increment %}, {% decrement %} changes this scope, whereas {% capture %}, {% assign %} only hide this scope

                                property globals

                                globals: Scope;
                                • global scope used as fallback for missing variables

                                property opts

                                opts: NormalizedFullOptions;
                                • The normalized liquid options object

                                property strictVariables

                                strictVariables: boolean;
                                • Throw when accessing undefined variable?

                                property sync

                                sync: boolean;

                                  method bottom

                                  bottom: () => Scope;

                                    method get

                                    get: (paths: string[]) => object;

                                      method getAll

                                      getAll: () => Scope;

                                        method getFromScope

                                        getFromScope: (scope: object, paths: string[] | string) => object;

                                          method getRegister

                                          getRegister: (key: string) => any;

                                            method pop

                                            pop: () => Scope | undefined;

                                              method push

                                              push: (ctx: object) => number;

                                                method restoreRegister

                                                restoreRegister: (keyValues: [string, any][]) => void;

                                                  method saveRegister

                                                  saveRegister: (...keys: string[]) => [string, any][];

                                                    method setRegister

                                                    setRegister: (key: string, value: any) => any;

                                                      class Drop

                                                      abstract class Drop {}

                                                        method liquidMethodMissing

                                                        liquidMethodMissing: (
                                                        key: string
                                                        ) => Promise<string | undefined> | string | undefined;

                                                          method valueOf

                                                          valueOf: () => any;

                                                            class Expression

                                                            class Expression {}


                                                              constructor(tokens: IterableIterator<Token>);

                                                                method evaluate

                                                                evaluate: (
                                                                ctx: Context,
                                                                lenient: boolean
                                                                ) => Generator<unknown, unknown, unknown>;

                                                                  class Hash

                                                                  class Hash {}
                                                                  • Key-Value Pairs Representing Tag Arguments Example: For the markup , foo:'bar', coo:2 reversed %}, hash['foo'] === 'bar' hash['coo'] === 2 hash['reversed'] === undefined


                                                                  constructor(markup: string, jekyllStyle?: boolean);

                                                                    property hash

                                                                    hash: HashValue;

                                                                      method render

                                                                      render: (ctx: Context) => Generator<unknown, HashValue, unknown>;

                                                                        class InternalUndefinedVariableError

                                                                        class InternalUndefinedVariableError extends Error {}


                                                                          constructor(variableName: string);

                                                                            property variableName

                                                                            variableName: string;

                                                                              class Liquid

                                                                              class Liquid {}


                                                                                constructor(opts?: LiquidOptions);

                                                                                  property filters

                                                                                  readonly filters: FilterMap;

                                                                                    property options

                                                                                    readonly options: NormalizedFullOptions;

                                                                                      property parser

                                                                                      readonly parser: Parser;

                                                                                        property renderer

                                                                                        readonly renderer: Render;

                                                                                          property tags

                                                                                          readonly tags: TagMap;

                                                                                            method evalValue

                                                                                            evalValue: (str: string, ctx: Context) => Promise<any>;

                                                                                              method evalValueSync

                                                                                              evalValueSync: (str: string, ctx: Context) => any;

                                                                                                method express

                                                                                                express: () => (
                                                                                                this: any,
                                                                                                filePath: string,
                                                                                                ctx: object,
                                                                                                callback: (err: Error | null, rendered: string) => void
                                                                                                ) => void;

                                                                                                  method parse

                                                                                                  parse: (html: string, filepath?: string) => Template[];

                                                                                                    method parseAndRender

                                                                                                    parseAndRender: (
                                                                                                    html: string,
                                                                                                    scope?: object,
                                                                                                    renderOptions?: RenderOptions
                                                                                                    ) => Promise<any>;

                                                                                                      method parseAndRenderSync

                                                                                                      parseAndRenderSync: (
                                                                                                      html: string,
                                                                                                      scope?: object,
                                                                                                      renderOptions?: RenderOptions
                                                                                                      ) => any;

                                                                                                        method parseFile

                                                                                                        parseFile: (file: string) => Promise<Template[]>;

                                                                                                          method parseFileSync

                                                                                                          parseFileSync: (file: string) => Template[];

                                                                                                            method plugin

                                                                                                            plugin: (plugin: (this: Liquid, L: typeof Liquid) => void) => void;

                                                                                                              method registerFilter

                                                                                                              registerFilter: (name: string, filter: FilterImplOptions) => void;

                                                                                                                method registerTag

                                                                                                                registerTag: (name: string, tag: TagImplOptions) => void;

                                                                                                                  method render

                                                                                                                  render: (
                                                                                                                  tpl: Template[],
                                                                                                                  scope?: object,
                                                                                                                  renderOptions?: RenderOptions
                                                                                                                  ) => Promise<any>;

                                                                                                                    method renderFile

                                                                                                                    renderFile: (
                                                                                                                    file: string,
                                                                                                                    ctx?: object,
                                                                                                                    renderOptions?: RenderOptions
                                                                                                                    ) => Promise<any>;

                                                                                                                      method renderFileSync

                                                                                                                      renderFileSync: (
                                                                                                                      file: string,
                                                                                                                      ctx?: object,
                                                                                                                      renderOptions?: RenderOptions
                                                                                                                      ) => any;

                                                                                                                        method renderFileToNodeStream

                                                                                                                        renderFileToNodeStream: (
                                                                                                                        file: string,
                                                                                                                        scope?: object,
                                                                                                                        renderOptions?: RenderOptions
                                                                                                                        ) => Promise<NodeJS.ReadableStream>;

                                                                                                                          method renderSync

                                                                                                                          renderSync: (
                                                                                                                          tpl: Template[],
                                                                                                                          scope?: object,
                                                                                                                          renderOptions?: RenderOptions
                                                                                                                          ) => any;

                                                                                                                            method renderToNodeStream

                                                                                                                            renderToNodeStream: (
                                                                                                                            tpl: Template[],
                                                                                                                            scope?: object,
                                                                                                                            renderOptions?: RenderOptions
                                                                                                                            ) => NodeJS.ReadableStream;

                                                                                                                              class LiquidError

                                                                                                                              abstract class LiquidError extends Error {}


                                                                                                                                constructor(err: Error, token: Token);

                                                                                                                                  property context

                                                                                                                                  context: string;

                                                                                                                                    method update

                                                                                                                                    protected update: () => void;

                                                                                                                                      class ParseError

                                                                                                                                      class ParseError extends LiquidError {}


                                                                                                                                        constructor(err: Error, token: Token);

                                                                                                                                          class ParseStream

                                                                                                                                          class ParseStream<T extends Token = TopLevelToken> {}


                                                                                                                                            constructor(tokens: T[], parseToken: ParseToken<T>);

                                                                                                                                              method on

                                                                                                                                              on: <T2 extends Template | T>(
                                                                                                                                              name: string,
                                                                                                                                              cb: (this: ParseStream, arg: T2) => void
                                                                                                                                              ) => ParseStream<T>;

                                                                                                                                                method start

                                                                                                                                                start: () => this;

                                                                                                                                                  method stop

                                                                                                                                                  stop: () => this;

                                                                                                                                                    class RenderError

                                                                                                                                                    class RenderError extends LiquidError {}


                                                                                                                                                      constructor(err: Error, tpl: Template);

                                                                                                                                                        method is

                                                                                                                                                        static is: (obj: any) => obj is RenderError;

                                                                                                                                                          class TagToken

                                                                                                                                                          class TagToken extends DelimitedToken {}


                                                                                                                                                            input: string,
                                                                                                                                                            begin: number,
                                                                                                                                                            end: number,
                                                                                                                                                            options: NormalizedFullOptions,
                                                                                                                                                            file?: string

                                                                                                                                                              property args

                                                                                                                                                              args: string;

                                                                                                                                                                property name

                                                                                                                                                                name: string;

                                                                                                                                                                  class Token

                                                                                                                                                                  abstract class Token {}


                                                                                                                                                                    kind: TokenKind,
                                                                                                                                                                    input: string,
                                                                                                                                                                    begin: number,
                                                                                                                                                                    end: number,
                                                                                                                                                                    file?: string

                                                                                                                                                                      property begin

                                                                                                                                                                      begin: number;

                                                                                                                                                                        property end

                                                                                                                                                                        end: number;

                                                                                                                                                                          property file

                                                                                                                                                                          file?: string;

                                                                                                                                                                            property input

                                                                                                                                                                            input: string;

                                                                                                                                                                              property kind

                                                                                                                                                                              kind: TokenKind;

                                                                                                                                                                                method getPosition

                                                                                                                                                                                getPosition: () => number[];

                                                                                                                                                                                  method getText

                                                                                                                                                                                  getText: () => string;

                                                                                                                                                                                    method size

                                                                                                                                                                                    size: () => number;

                                                                                                                                                                                      class TokenizationError

                                                                                                                                                                                      class TokenizationError extends LiquidError {}


                                                                                                                                                                                        constructor(message: string, token: Token);

                                                                                                                                                                                          class Tokenizer

                                                                                                                                                                                          class Tokenizer {}


                                                                                                                                                                                            constructor(input: string, trie: Trie, file?: string);

                                                                                                                                                                                              property file

                                                                                                                                                                                              file: string;

                                                                                                                                                                                                property input

                                                                                                                                                                                                input: string;

                                                                                                                                                                                                  property N

                                                                                                                                                                                                  N: number;

                                                                                                                                                                                                    property p

                                                                                                                                                                                                    p: number;

                                                                                                                                                                                                      method advance

                                                                                                                                                                                                      advance: (i?: number) => void;

                                                                                                                                                                                                        method end

                                                                                                                                                                                                        end: () => boolean;

                                                                                                                                                                                                          method match

                                                                                                                                                                                                          match: (word: string) => boolean;

                                                                                                                                                                                                            method mkError

                                                                                                                                                                                                            mkError: (msg: string, begin: number) => TokenizationError;

                                                                                                                                                                                                              method peek

                                                                                                                                                                                                              peek: (n?: number) => string;

                                                                                                                                                                                                                method peekType

                                                                                                                                                                                                                peekType: (n?: number) => number;

                                                                                                                                                                                                                  method readEndrawOrRawContent

                                                                                                                                                                                                                  readEndrawOrRawContent: (options: NormalizedFullOptions) => HTMLToken | TagToken;

                                                                                                                                                                                                                    method readExpression

                                                                                                                                                                                                                    readExpression: () => Expression;

                                                                                                                                                                                                                      method readExpressionTokens

                                                                                                                                                                                                                      readExpressionTokens: () => IterableIterator<Token>;

                                                                                                                                                                                                                        method readFileNameTemplate

                                                                                                                                                                                                                        readFileNameTemplate: (
                                                                                                                                                                                                                        options: NormalizedFullOptions
                                                                                                                                                                                                                        ) => IterableIterator<TopLevelToken>;

                                                                                                                                                                                                                          method readFilter

                                                                                                                                                                                                                          readFilter: () => FilterToken | null;

                                                                                                                                                                                                                            method readFilterArg

                                                                                                                                                                                                                            readFilterArg: () => FilterArg | undefined;

                                                                                                                                                                                                                              method readFilters

                                                                                                                                                                                                                              readFilters: () => FilterToken[];

                                                                                                                                                                                                                                method readHash

                                                                                                                                                                                                                                readHash: (jekyllStyle?: boolean) => HashToken | undefined;

                                                                                                                                                                                                                                  method readHashes

                                                                                                                                                                                                                                  readHashes: (jekyllStyle?: boolean) => HashToken[];

                                                                                                                                                                                                                                    method readHTMLToken

                                                                                                                                                                                                                                    readHTMLToken: (stopStrings: string[]) => HTMLToken;

                                                                                                                                                                                                                                      method readIdentifier

                                                                                                                                                                                                                                      readIdentifier: () => IdentifierToken;

                                                                                                                                                                                                                                        method readLiquidTagToken

                                                                                                                                                                                                                                        readLiquidTagToken: (options: NormalizedFullOptions) => LiquidTagToken;

                                                                                                                                                                                                                                          method readLiquidTagTokens

                                                                                                                                                                                                                                          readLiquidTagTokens: (options?: NormalizedFullOptions) => LiquidTagToken[];

                                                                                                                                                                                                                                            method readOperator

                                                                                                                                                                                                                                            readOperator: () => OperatorToken | undefined;

                                                                                                                                                                                                                                              method readOutputToken

                                                                                                                                                                                                                                              readOutputToken: (options?: NormalizedFullOptions) => OutputToken;

                                                                                                                                                                                                                                                method readQuoted

                                                                                                                                                                                                                                                readQuoted: () => QuotedToken | undefined;

                                                                                                                                                                                                                                                  method readRange

                                                                                                                                                                                                                                                  readRange: () => RangeToken | undefined;

                                                                                                                                                                                                                                                    method readTagToken

                                                                                                                                                                                                                                                    readTagToken: (options?: NormalizedFullOptions) => TagToken;

                                                                                                                                                                                                                                                      method readTo

                                                                                                                                                                                                                                                      readTo: (end: string) => number;

                                                                                                                                                                                                                                                        method readToDelimiter

                                                                                                                                                                                                                                                        readToDelimiter: (delimiter: string) => number;

                                                                                                                                                                                                                                                          method readTopLevelToken

                                                                                                                                                                                                                                                          readTopLevelToken: (options: NormalizedFullOptions) => TopLevelToken;

                                                                                                                                                                                                                                                            method readTopLevelTokens

                                                                                                                                                                                                                                                            readTopLevelTokens: (options?: NormalizedFullOptions) => TopLevelToken[];

                                                                                                                                                                                                                                                              method readValue

                                                                                                                                                                                                                                                              readValue: () => ValueToken | undefined;

                                                                                                                                                                                                                                                                method readValueOrThrow

                                                                                                                                                                                                                                                                readValueOrThrow: () => ValueToken;

                                                                                                                                                                                                                                                                  method readWord

                                                                                                                                                                                                                                                                  readWord: () => IdentifierToken;
                                                                                                                                                                                                                                                                  • Deprecated

                                                                                                                                                                                                                                                                  method remaining

                                                                                                                                                                                                                                                                  remaining: () => string;

                                                                                                                                                                                                                                                                    method rmatch

                                                                                                                                                                                                                                                                    rmatch: (pattern: string) => boolean;

                                                                                                                                                                                                                                                                      method skipBlank

                                                                                                                                                                                                                                                                      skipBlank: () => void;

                                                                                                                                                                                                                                                                        method snapshot

                                                                                                                                                                                                                                                                        snapshot: (begin?: number) => string;

                                                                                                                                                                                                                                                                          class UndefinedVariableError

                                                                                                                                                                                                                                                                          class UndefinedVariableError extends LiquidError {}


                                                                                                                                                                                                                                                                            constructor(err: Error, token: Token);

                                                                                                                                                                                                                                                                              class Value

                                                                                                                                                                                                                                                                              class Value {}


                                                                                                                                                                                                                                                                                constructor(str: string, liquid: Liquid);
                                                                                                                                                                                                                                                                                • Parameter str

                                                                                                                                                                                                                                                                                  the value to be valuated, eg.: "foobar" | truncate: 3

                                                                                                                                                                                                                                                                                property filters

                                                                                                                                                                                                                                                                                readonly filters: Filter[];

                                                                                                                                                                                                                                                                                  property initial

                                                                                                                                                                                                                                                                                  readonly initial: Expression;

                                                                                                                                                                                                                                                                                    method value

                                                                                                                                                                                                                                                                                    value: (ctx: Context, lenient: boolean) => Generator<unknown, unknown, unknown>;


                                                                                                                                                                                                                                                                                      interface Emitter

                                                                                                                                                                                                                                                                                      interface Emitter {}

                                                                                                                                                                                                                                                                                        property buffer

                                                                                                                                                                                                                                                                                        buffer: string;
                                                                                                                                                                                                                                                                                        • Buffered string

                                                                                                                                                                                                                                                                                        method write

                                                                                                                                                                                                                                                                                        write: (html: any) => void;
                                                                                                                                                                                                                                                                                        • Write a html value into emitter

                                                                                                                                                                                                                                                                                          Parameter html

                                                                                                                                                                                                                                                                                          string, Drop or other primitive value

                                                                                                                                                                                                                                                                                        interface FilterImplOptions

                                                                                                                                                                                                                                                                                        interface FilterImplOptions {}

                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                          (this: FilterImpl, value: any, ...args: any[]): any;

                                                                                                                                                                                                                                                                                            interface Operators

                                                                                                                                                                                                                                                                                            interface Operators {}

                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                              [key: string]: (lhs: any, rhs: any, ctx: Context) => boolean;

                                                                                                                                                                                                                                                                                                interface TagImpl

                                                                                                                                                                                                                                                                                                interface TagImpl extends TagImplOptions {}

                                                                                                                                                                                                                                                                                                  property liquid

                                                                                                                                                                                                                                                                                                  liquid: Liquid;

                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                    [key: string]: any;

                                                                                                                                                                                                                                                                                                      interface TagImplOptions

                                                                                                                                                                                                                                                                                                      interface TagImplOptions {}

                                                                                                                                                                                                                                                                                                        property parse

                                                                                                                                                                                                                                                                                                        parse?: (
                                                                                                                                                                                                                                                                                                        this: TagImpl,
                                                                                                                                                                                                                                                                                                        token: TagToken,
                                                                                                                                                                                                                                                                                                        remainingTokens: TopLevelToken[]
                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                          property render

                                                                                                                                                                                                                                                                                                          render: (
                                                                                                                                                                                                                                                                                                          this: TagImpl,
                                                                                                                                                                                                                                                                                                          ctx: Context,
                                                                                                                                                                                                                                                                                                          emitter: Emitter,
                                                                                                                                                                                                                                                                                                          hash: HashValue
                                                                                                                                                                                                                                                                                                          ) =>
                                                                                                                                                                                                                                                                                                          | void
                                                                                                                                                                                                                                                                                                          | string
                                                                                                                                                                                                                                                                                                          | Promise<void | string>
                                                                                                                                                                                                                                                                                                          | Generator<unknown, void | string, unknown>;

                                                                                                                                                                                                                                                                                                            interface Template

                                                                                                                                                                                                                                                                                                            interface Template {}

                                                                                                                                                                                                                                                                                                              property token

                                                                                                                                                                                                                                                                                                              token: Token;

                                                                                                                                                                                                                                                                                                                method render

                                                                                                                                                                                                                                                                                                                render: (ctx: Context, emitter: Emitter) => any;

                                                                                                                                                                                                                                                                                                                  interface Trie

                                                                                                                                                                                                                                                                                                                  interface Trie {}

                                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                                    [key: string]: any;


                                                                                                                                                                                                                                                                                                                      enum TokenKind

                                                                                                                                                                                                                                                                                                                      enum TokenKind {
                                                                                                                                                                                                                                                                                                                      Number = 1,
                                                                                                                                                                                                                                                                                                                      Literal = 2,
                                                                                                                                                                                                                                                                                                                      Tag = 4,
                                                                                                                                                                                                                                                                                                                      Output = 8,
                                                                                                                                                                                                                                                                                                                      HTML = 16,
                                                                                                                                                                                                                                                                                                                      Filter = 32,
                                                                                                                                                                                                                                                                                                                      Hash = 64,
                                                                                                                                                                                                                                                                                                                      PropertyAccess = 128,
                                                                                                                                                                                                                                                                                                                      Word = 256,
                                                                                                                                                                                                                                                                                                                      Range = 512,
                                                                                                                                                                                                                                                                                                                      Quoted = 1024,
                                                                                                                                                                                                                                                                                                                      Operator = 2048,
                                                                                                                                                                                                                                                                                                                      Delimited = 12,

                                                                                                                                                                                                                                                                                                                        member Delimited

                                                                                                                                                                                                                                                                                                                        Delimited = 12

                                                                                                                                                                                                                                                                                                                          member Filter

                                                                                                                                                                                                                                                                                                                          Filter = 32

                                                                                                                                                                                                                                                                                                                            member Hash

                                                                                                                                                                                                                                                                                                                            Hash = 64

                                                                                                                                                                                                                                                                                                                              member HTML

                                                                                                                                                                                                                                                                                                                              HTML = 16

                                                                                                                                                                                                                                                                                                                                member Literal

                                                                                                                                                                                                                                                                                                                                Literal = 2

                                                                                                                                                                                                                                                                                                                                  member Number

                                                                                                                                                                                                                                                                                                                                  Number = 1

                                                                                                                                                                                                                                                                                                                                    member Operator

                                                                                                                                                                                                                                                                                                                                    Operator = 2048

                                                                                                                                                                                                                                                                                                                                      member Output

                                                                                                                                                                                                                                                                                                                                      Output = 8

                                                                                                                                                                                                                                                                                                                                        member PropertyAccess

                                                                                                                                                                                                                                                                                                                                        PropertyAccess = 128

                                                                                                                                                                                                                                                                                                                                          member Quoted

                                                                                                                                                                                                                                                                                                                                          Quoted = 1024

                                                                                                                                                                                                                                                                                                                                            member Range

                                                                                                                                                                                                                                                                                                                                            Range = 512

                                                                                                                                                                                                                                                                                                                                              member Tag

                                                                                                                                                                                                                                                                                                                                              Tag = 4

                                                                                                                                                                                                                                                                                                                                                member Word

                                                                                                                                                                                                                                                                                                                                                Word = 256

                                                                                                                                                                                                                                                                                                                                                  Type Aliases

                                                                                                                                                                                                                                                                                                                                                  type TopLevelToken

                                                                                                                                                                                                                                                                                                                                                  type TopLevelToken = TagToken | OutputToken | HTMLToken;


                                                                                                                                                                                                                                                                                                                                                    namespace TypeGuards

                                                                                                                                                                                                                                                                                                                                                    module 'dist/util/type-guards.d.ts' {}

                                                                                                                                                                                                                                                                                                                                                      function isDelimitedToken

                                                                                                                                                                                                                                                                                                                                                      isDelimitedToken: (val: any) => val is DelimitedToken;

                                                                                                                                                                                                                                                                                                                                                        function isHTMLToken

                                                                                                                                                                                                                                                                                                                                                        isHTMLToken: (val: any) => val is HTMLToken;

                                                                                                                                                                                                                                                                                                                                                          function isLiteralToken

                                                                                                                                                                                                                                                                                                                                                          isLiteralToken: (val: any) => val is LiteralToken;

                                                                                                                                                                                                                                                                                                                                                            function isNumberToken

                                                                                                                                                                                                                                                                                                                                                            isNumberToken: (val: any) => val is NumberToken;

                                                                                                                                                                                                                                                                                                                                                              function isOperatorToken

                                                                                                                                                                                                                                                                                                                                                              isOperatorToken: (val: any) => val is OperatorToken;

                                                                                                                                                                                                                                                                                                                                                                function isOutputToken

                                                                                                                                                                                                                                                                                                                                                                isOutputToken: (val: any) => val is OutputToken;

                                                                                                                                                                                                                                                                                                                                                                  function isPropertyAccessToken

                                                                                                                                                                                                                                                                                                                                                                  isPropertyAccessToken: (val: any) => val is PropertyAccessToken;

                                                                                                                                                                                                                                                                                                                                                                    function isQuotedToken

                                                                                                                                                                                                                                                                                                                                                                    isQuotedToken: (val: any) => val is QuotedToken;

                                                                                                                                                                                                                                                                                                                                                                      function isRangeToken

                                                                                                                                                                                                                                                                                                                                                                      isRangeToken: (val: any) => val is RangeToken;

                                                                                                                                                                                                                                                                                                                                                                        function isTagToken

                                                                                                                                                                                                                                                                                                                                                                        isTagToken: (val: any) => val is TagToken;

                                                                                                                                                                                                                                                                                                                                                                          function isWordToken

                                                                                                                                                                                                                                                                                                                                                                          isWordToken: (val: any) => val is IdentifierToken;

                                                                                                                                                                                                                                                                                                                                                                            Package Files (25)

                                                                                                                                                                                                                                                                                                                                                                            Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                            No dependencies.

                                                                                                                                                                                                                                                                                                                                                                            Dev Dependencies (51)

                                                                                                                                                                                                                                                                                                                                                                            Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                            No peer dependencies.


                                                                                                                                                                                                                                                                                                                                                                            To add a badge like this badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                            You may also use to create a custom badge linking to

                                                                                                                                                                                                                                                                                                                                                                            • Markdown
                                                                                                                                                                                                                                                                                                                                                                            • HTML
                                                                                                                                                                                                                                                                                                                                                                              <a href=""><img src="" alt=""></a>