func interpretCommandCheck(path string) bool {
	if strings.HasSuffix(path, fract.Extension) {
		return true
	}
	info, err := os.Stat(path + fract.Extension)
	return err == nil && !info.IsDir()
}
interpretCommandCheck is check command is valid source code path or not.
package main
import (
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"github.com/fract-lang/fract/parser"
	"github.com/fract-lang/fract/pkg/fract"
	"github.com/fract-lang/fract/pkg/obj"
	"github.com/fract-lang/fract/pkg/str"
	"github.com/mertcandav/dinogo/keyboard"
	"github.com/mertcandav/dinogo/shell"
	"github.com/mertcandav/dinogo/shell/utils"
)
var p *parser.Parser
var sh *shell.Shell
func getline(msg string) string {
	return string(sh.GetInput(msg))
}
func interpret() {
	for {
		p.Lex.File.Lines = []string{getline(">> ")}
	reTokenize:
		p.Tokens = nil
	reTokenizeUnNil:
		p.Lex.Finished = false
		p.Lex.Braces = 0
		p.Lex.Brackets = 0
		p.Lex.Parentheses = 0
		p.Lex.RangeComment = false
		p.Lex.Line = 1
		p.Lex.Column = 1
		for !p.Lex.Finished {
			tks := p.Lex.Next()
			if p.Lex.RangeComment {
				p.Lex.File.Lines = append(p.Lex.File.Lines, []string{getline(" | ")}...)
				goto reTokenizeUnNil
			}
			if tks == nil {
				continue
			}
			if p.Lex.Braces > 0 || p.Lex.Brackets > 0 || p.Lex.Parentheses > 0 {
				p.Lex.File.Lines = append(p.Lex.File.Lines, []string{getline(" | ")}...)
				goto reTokenize
			}
			p.Tokens = append(p.Tokens, tks)
		}
		p.Interpret()
	}
}
func catch(e obj.Panic) {
	if e.Msg == "" {
		return
	}
	fmt.Println(e.Msg)
}
func help(cmd string) {
	if cmd != "" {
		fmt.Println("This module can only be used!")
		return
	}
	helpMap := map[string]string{
		"version": "Show version.",
		"help":    "Show help.",
	}
	maxKeyLen := 0
	for k := range helpMap {
		if maxKeyLen < len(k) {
			maxKeyLen = len(k)
		}
	}
	maxKeyLen += 5
	for k := range helpMap {
		fmt.Println(k + " " + str.Full(maxKeyLen-len(k), ' ') + helpMap[k])
	}
}
func version(cmd string) {
	if cmd != "" {
		fmt.Println("This module can only be used!")
		return
	}
	fmt.Println("Fract Version [" + fract.Version + "]")
}
func interpretCommand(cmd string) {
	if cmd == "" {
		fmt.Println("This module cannot only be used!")
		return
	} else if !strings.HasSuffix(cmd, fract.Extension) {
		cmd += fract.Extension
	}
	if info, err := os.Stat(cmd); err != nil || info.IsDir() {
		fmt.Println("The Fract file is not exists: " + cmd)
		return
	}
	p := parser.New(cmd)
	p.AddBuiltin()
	block := &obj.Block{
		Try: p.Interpret,
		Catch: func(_ obj.Panic) {
			os.Exit(0)
		},
	}
	block.Do()
	block = nil
}