{{ message | capitalize }}

export const transformFilter: NodeTransform = (node, context) => {
  if (!isCompatEnabled(CompilerDeprecationTypes.COMPILER_FILTERS, context)) {
    return
  }

  if (node.type === NodeTypes.INTERPOLATION) {
    rewriteFilter(node.content, context)
  } else if (node.type === NodeTypes.ELEMENT) {
    node.props.forEach((prop) => {
      if (
        prop.type === NodeTypes.DIRECTIVE &&
        prop.name !== 'for' &&
        prop.exp
      ) {
        rewriteFilter(prop.exp, context)
      }
    })
  }
}

function rewriteFilter(node: ExpressionNode, context: TransformContext) {
  if (node.type === NodeTypes.SIMPLE_EXPRESSION) {
    parseFilter(node, context)
  } else {
    for (let child of node.children) {
      if (typeof child !== 'object') continue
      if (child.type === NodeTypes.SIMPLE_EXPRESSION) {
        parseFilter(child, context)
      } else if (child.type === NodeTypes.COMPOUND_EXPRESSION) {
        rewriteFilter(node, context)
      } else if (child.type === NodeTypes.INTERPOLATION) {
        rewriteFilter(child.content, context)
      }
    }
  }
}

function parseFilter(node: SimpleExpressionNode, context: TransformContext) {
  const exp = node.content
  let inSingle = false, inDouble = false, inTemplateString = false
  let inRegex = false
  let curly = 0, square = 0, paren = 0
  let lastFilterIndex = 0
  let expression, filters: string[] = []

  for (let i = 0; i < exp.length; i++) {
    const c = exp.charCodeAt(i)
    ...
    if (c === 0x7c && !curly && !square && !paren) {
      if (expression === undefined) {
        lastFilterIndex = i + 1
        expression = exp.slice(0, i).trim()
      } else {
        pushFilter()
      }
    }
  }

  if (expression === undefined) {
    expression = exp.trim()
  } else if (lastFilterIndex !== 0) {
    pushFilter()
  }

  if (filters.length) {
    for (let f of filters) {
      expression = wrapFilter(expression, f, context)
    }
    node.content = expression
  }
}

expression = "message"
filters = ["capitalize", "trim(10)"]

toValidAssetId('capitalize', 'filter')(
  toValidAssetId('trim', 'filter')(message)
)

function wrapFilter(exp: string, filter: string, context: TransformContext) {
  context.helper(RESOLVE_FILTER)
  const i = filter.indexOf('(')
  if (i < 0) {
    context.filters!.add(filter)
    return `${toValidAssetId(filter, 'filter')}(${exp})`
  } else {
    const name = filter.slice(0, i)
    const args = filter.slice(i + 1)
    context.filters!.add(name)
    return `${toValidAssetId(name, 'filter')}(${exp}${args !== ')' ? ',' + args : args}`
  }
}

// 輸入模板
{{ message | capitalize | append('!') }}

// 編譯后表達(dá)式
_append(
  _capitalize(message),
  '!'
)