refactor: Tag class support in registerTag()

src/parser/filter-arg.ts

@@ -5,6 +5,6 @@ type KeyValuePair = [string?, ValueToken?]
 
 export type FilterArg = ValueToken | KeyValuePair
 
-export function isKeyValuePair (arr: FilterArg): arr is KeyValuePair { // TODO check
+export function isKeyValuePair (arr: FilterArg): arr is KeyValuePair {
   return isArray(arr)
 }

src/parser/index.ts

@@ -0,0 +1,5 @@
+export * from './tokenizer'
+export * from './parser'
+export * from './parse-stream'
+export * from './parse-string-literal'
+export * from './token-kind'

src/parser/match-operator.ts

@@ -1,8 +1,7 @@
-import { IDENTIFIER, TYPES } from '../util/character'
-import { Trie } from '../util/operator-trie'
+import { Trie, TrieNode, IDENTIFIER, TYPES } from '../util'
 
 export function matchOperator (str: string, begin: number, trie: Trie, end = str.length) {
-  let node = trie
+  let node: TrieNode = trie
   let i = begin
   let info
   while (node[str[i]] && i < end) {

src/parser/parse-stream.ts

@@ -1,13 +1,12 @@
-import { Token } from '../tokens/token'
-import { Template } from '../template/template'
-import { isTagToken } from '../util/type-guards'
-import { TopLevelToken } from '../tokens/toplevel-token'
+import { Token, TopLevelToken } from '../tokens'
+import { Template } from '../template'
+import { isTagToken } from '../util'
 
 type ParseToken<T extends Token> = ((token: T, remainTokens: T[]) => Template)
 
 export class ParseStream<T extends Token = TopLevelToken> {
   private tokens: T[]
-  private handlers: {[key: string]: (arg: any) => void} = {}
+  private handlers: Record<string, (arg: any) => void> = {}
   private stopRequested = false
   private parseToken: ParseToken<T>
 

src/parser/parser.ts

@@ -1,19 +1,13 @@
-import { ParseError } from '../util/error'
-import { Liquid, Tokenizer } from '../liquid'
+import { toPromise, assert, isTagToken, isOutputToken, ParseError } from '../util'
+import { Tokenizer } from './tokenizer'
 import { ParseStream } from './parse-stream'
-import { isTagToken, isOutputToken } from '../util/type-guards'
-import { OutputToken } from '../tokens/output-token'
-import { Tag } from '../template/tag/tag'
-import { Output } from '../template/output'
-import { HTML } from '../template/html'
-import { Template } from '../template/template'
-import { TopLevelToken } from '../tokens/toplevel-token'
-import { LiquidCache } from '../cache/cache'
-import { Loader, LookupType } from '../fs/loader'
-import { toPromise } from '../util/async'
-import { FS } from '../fs/fs'
+import { TopLevelToken, OutputToken } from '../tokens'
+import { Template, Output, HTML } from '../template'
+import { LiquidCache } from '../cache'
+import { FS, Loader, LookupType } from '../fs'
+import type { Liquid } from '../liquid'
 
-export default class Parser {
+export class Parser {
   public parseFile: (file: string, sync?: boolean, type?: LookupType, currentFile?: string) => Generator<unknown, Template[], Template[] | string>
 
   private liquid: Liquid
@@ -44,7 +38,9 @@ export default class Parser {
   public parseToken (token: TopLevelToken, remainTokens: TopLevelToken[]) {
     try {
       if (isTagToken(token)) {
-        return new Tag(token, remainTokens, this.liquid)
+        const TagClass = this.liquid.tags[token.name]
+        assert(TagClass, `tag "${token.name}" not found`)
+        return new TagClass(token, remainTokens, this.liquid)
       }
       if (isOutputToken(token)) {
         return new Output(token as OutputToken, this.liquid)

src/parser/tokenizer.ts

@@ -1,31 +1,10 @@
-import { whiteSpaceCtrl } from './whitespace-ctrl'
-import { NumberToken } from '../tokens/number-token'
-import { IdentifierToken } from '../tokens/identifier-token'
-import { literalValues } from '../util/literal'
-import { LiteralToken } from '../tokens/literal-token'
-import { OperatorToken } from '../tokens/operator-token'
-import { PropertyAccessToken } from '../tokens/property-access-token'
-import { assert } from '../util/assert'
-import { TopLevelToken } from '../tokens/toplevel-token'
-import { FilterArg } from './filter-arg'
-import { FilterToken } from '../tokens/filter-token'
-import { HashToken } from '../tokens/hash-token'
-import { QuotedToken } from '../tokens/quoted-token'
-import { ellipsis } from '../util/underscore'
-import { HTMLToken } from '../tokens/html-token'
-import { TagToken } from '../tokens/tag-token'
-import { Token } from '../tokens/token'
-import { RangeToken } from '../tokens/range-token'
-import { ValueToken } from '../tokens/value-token'
-import { OutputToken } from '../tokens/output-token'
-import { TokenizationError } from '../util/error'
+import { TagToken, HTMLToken, HashToken, QuotedToken, LiquidTagToken, OutputToken, ValueToken, Token, RangeToken, FilterToken, TopLevelToken, PropertyAccessToken, OperatorToken, LiteralToken, IdentifierToken, NumberToken } from '../tokens'
+import { Trie, createTrie, ellipsis, literalValues, assert, TokenizationError, TYPES, QUOTE, BLANK, IDENTIFIER } from '../util'
+import { Operators, Expression } from '../render'
 import { NormalizedFullOptions, defaultOptions } from '../liquid-options'
-import { TYPES, QUOTE, BLANK, IDENTIFIER } from '../util/character'
+import { FilterArg } from './filter-arg'
 import { matchOperator } from './match-operator'
-import { Trie, createTrie } from '../util/operator-trie'
-import { Expression } from '../render/expression'
-import { Operators } from '../render/operator'
-import { LiquidTagToken } from '../tokens/liquid-tag-token'
+import { whiteSpaceCtrl } from './whitespace-ctrl'
 
 export class Tokenizer {
   p = 0
@@ -36,7 +15,7 @@ export class Tokenizer {
   constructor (
     public input: string,
     operators: Operators = defaultOptions.operators,
-    public file: string = ''
+    public file?: string
   ) {
     this.N = input.length
     this.opTrie = createTrie(operators)

src/parser/whitespace-ctrl.ts

@@ -1,7 +1,6 @@
-import { Token } from '../tokens/token'
-import { isTagToken, isHTMLToken, isDelimitedToken } from '../util/type-guards'
+import { Token } from '../tokens'
 import { NormalizedFullOptions } from '../liquid-options'
-import { TYPES, INLINE_BLANK, BLANK } from '../util/character'
+import { isTagToken, isHTMLToken, isDelimitedToken, TYPES, INLINE_BLANK, BLANK } from '../util'
 
 export function whiteSpaceCtrl (tokens: Token[], options: NormalizedFullOptions) {
   let inRaw = false