// package term

// import (
// 	"errors"
// 	"io"
// )

// // type controlRow [2]byte
// // type controlTable [16]controlRow

// type rangeLookup map[rune]*byte

// type ControlRange struct {
// 	table     controlTable
// 	set       rangeLookup
// 	colOffset uint8
// }

// func (r *ControlRange) Get(col, row int) (byte, error) {
// 	if col < int(r.colOffset) || col >= int(r.colOffset)+2 || row < 0 || row > 15 {
// 		return byte(0), errors.New("Coordinates Out Of Bounds")
// 	}
// 	return glTable[row][col-int(r.colOffset)], nil
// }

// func (r *ControlRange) Lookup(ru rune) *byte {
// 	if point, ok := r.set[ru]; ok {
// 		return point
// 	}
// 	return nil
// }

// // type graphicRow [6]byte
// // type graphicTable [16]graphicRow

// type GraphicRange struct {
// 	table        graphicTable
// 	set          rangeLookup
// 	colOffset    uint8
// 	lockShifts   map[GraphicRegister]ControlSequence
// 	singleShifts map[GraphicRegister]ControlSequence
// }

// func (r *GraphicRange) Get(col, row int) (byte, error) {
// 	if col < int(r.colOffset) || col >= int(r.colOffset)+6 || row < 0 || row > 15 {
// 		return byte(0), errors.New("Coordinates Out Of Bounds")
// 	}
// 	return r.table[row][col-int(r.colOffset)], nil
// }

// func (r *GraphicRange) Lookup(ru rune) *byte {
// 	if point, ok := r.set[ru]; ok {
// 		return point
// 	}
// 	return nil
// }

// func (r *GraphicRange) load(gOverlay *CharacterSet) {
// 	if r.set == nil {
// 		r.set = rangeLookup{}
// 	}
// 	for i, row := range gOverlay.table {
// 		for j, graph := range row {
// 			if graph == nil {
// 				continue
// 			}
// 			r.set[*graph] = &r.table[i][j]
// 		}
// 	}
// 	// fmt.Printf("%+v", r.set)
// }

// func (rg *GraphicRange) lockShift(register GraphicRegister, w io.Writer) error {
// 	if rg.lockShifts == nil {
// 		return errors.New("Register does not have defined Lock Shifts")
// 	}
// 	if _, ok := rg.lockShifts[register]; !ok {
// 		return errors.New("This register cannot be Lock Shifted into this Range.")
// 	}
// 	rg.lockShifts[register].Invoke(w)
// 	rg.load(register.register.set)
// 	return nil
// }

// func (rg *GraphicRange) singleShift(register GraphicRegister) ([]byte, error) {
// 	if rg.singleShifts == nil {
// 		return nil, errors.New("Register does not have defined Single Shifts")
// 	}
// 	if _, ok := rg.singleShifts[register]; !ok {
// 		return nil, errors.New("This register cannot be Single Shifted into this Range.")
// 	}
// 	return rg.singleShifts[register].Bytes(), nil
// }

// func (rg *GraphicRange) Load(register GraphicRegister) error {
// 	return rg.Load(register)
// }

// // Negative Question Mark.
// // var UNKNOWN = NewControlSequence(CSI, C03R07, C06R13, C03R15, CSI, C03R00, C06R13).Bytes()
// var UNKNOWN = append(append(SGR(SGRPs.Negative).Bytes(), C03R15), SGR(SGRPs.Positive).Bytes()...)