❤
npm
Sign UpSign In

zerolag
TypeScript icon, indicating that this package has built-in type declarations

1.1.0 • Public • Published

zerolag

a highly efficient text buffer for editors with very large buffers

npm i zerolag pnpm add zerolag yarn add zerolag

Examples

# basic
    # view source example/basic.ts 

    import { add, sub } from 'zerolag'

console.log(add(1, 2)) // => 3
console.log(sub(2, 5)) // => -3
# jsx
    # view source example/jsx.tsx 

    const h = (zerolag.args: unknown[]) => args

console.log(<foo bar="baz" />)
// => [ 'foo', { bar: 'baz' } ]

API

# Area

    # constructor(a)

      # new Area()

    # begin
    # end
    # height
    # addBottom(y)

      # y

        number

      addBottom(y)  =>

# addRight(x)

    # x

      number

    addRight(x)  =>

# beginLineEqual(a)

    # a

    beginLineEqual(a)  =>

      boolean
# copy()
# endLineEqual(a)

    # a

    endLineEqual(a)  =>

      boolean
# equal(a)

    # a

    equal(a)  =>

      boolean
# get()
# greaterThan(a)

    # a

    greaterThan(a)  =>

      boolean
# greaterThanOrEqual(a)

    # a

    greaterThanOrEqual(a)  =>

      boolean
# inside(a)

    # a

    inside(a)  =>

      any
# insideEqual(a)

    # a

    insideEqual(a)  =>

      any
# isEmpty()

    isEmpty()  =>

      boolean
# lessThan(a)

    # a

    lessThan(a)  =>

      boolean
# lessThanOrEqual(a)

    # a

    lessThanOrEqual(a)  =>

      boolean
# linesEqual(a)

    # a

    linesEqual(a)  =>

      any
# normalizeY()

    normalizeY()  =>

# outside(a)

    # a

    outside(a)  =>

      any
# outsideEqual(a)

    # a

    outsideEqual(a)  =>

      any
# sameLine(a)

    # a

    sameLine(a)  =>

      boolean
# set(area)

    # area

    set(area)  =>

      void
# setLeft(bx, ex)

    # bx

      number

    # ex

      number

    setLeft(bx, ex)  =>

# shiftByLines(y)

    # y

      number

    shiftByLines(y)  =>

# shortenByX(x)

    # x

      number

    shortenByX(x)  =>

# toString()

    toString()  =>

      string
# widenByX(x)

    # x

      number

    widenByX(x)  =>

# join(areas)
# offset(b, a)

    # b
    # a

    offset(b, a)  =>

      {

      # begin  =  ...

        {

        # x  =  ...

          number

        # y  =  ...

          number

        }

# end  =  ...

    {

    # x  =  ...

      number

    # y  =  ...

      number

    }
}
# offsetX(x, a)

    # x

      number

    # a

    offsetX(x, a)  =>

      {

      # begin  =  ...

        {

        # x  =  ...

          number

        # y  =  ...

          number

        }

# end  =  ...

    {

    # x  =  ...

      number

    # y  =  ...

      number

    }
}
# offsetY(y, a)

    # y

      number

    # a

    offsetY(y, a)  =>

      {

      # begin  =  ...

        {

        # x  =  ...

          number

        # y  =  ...

          number

        }

# end  =  ...

    {

    # x  =  ...

      number

    # y  =  ...

      number

    }
}
# sort(a, b)
# toPointSort(a, b)
# Buffer

    # constructor()
    # _handlers  =  {}

      Record<string, EventHandler []>

    # indexer
    # insert

      # (p, text, noLog)

        # p
        # text

          string

        # noLog

          boolean

        (p, text, noLog)  =>

          number

# log
# prefix
# raw  =  ''

    string

# remove

    # (o, noLog)

      # o

        Range

      # noLog

        boolean

      (o, noLog)  =>

        void

# segments
# silent

    boolean

# text
# tokens
# _getHandlers(name)

    # name

      string

    _getHandlers(name)  =>

      EventHandler []
# appendLog(type, offsets, text)

    # type

      "insert" | "remove"

    # offsets

      Range

    # text

      string

    appendLog(type, offsets, text)  =>

      void
# charAt(offset)

    # offset

      number

    charAt(offset)  =>

      string
# copy()
# emit(name, a, b, c, d)

    # name

      string

    # a

      any

    # b

      any

    # c

      any

    # d

      any

    emit(name, a, b, c, d)  =>

      void
# getAreaOffsetRange(area)

    # area

    getAreaOffsetRange(area)  =>

      Range
# getAreaText(area)

    # area

    getAreaText(area)  =>

      string
# getLine(y)

    # y

      number

    getLine(y)  =>

# getLineLength(line)

    # line

      number

    getLineLength(line)  =>

      number
# getLineOffset(y)

    # y

      number

    getLineOffset(y)  =>

      number
# getLineRangeOffsets(range)

    # range

      [ number, number ]

    getLineRangeOffsets(range)  =>

      [ number, number ]
# getLineRangeText(range)

    # range

      [ number, number ]

    getLineRangeText(range)  =>

      string
# getLineText(y)

    # y

      number

    getLineText(y)  =>

      string
# getLongestLine()

    getLongestLine()  =>

      number | {

      # length  =  ...

        number

      # lineNumber  =  ...

        number

      }
# getLongestLineLength(withLineNumber)

    # withLineNumber

      boolean

    getLongestLineLength(withLineNumber)  =>

      number | {

      # length  =  ...

        number

      # lineNumber  =  ...

        number

      }
# getOffsetPoint(offset)

    # offset

      number

    getOffsetPoint(offset)  =>

# getOffsetRangeText(offsetRange)

    # offsetRange

      [ number, number ]

    getOffsetRangeText(offsetRange)  =>

      string
# getPoint(p)

    # p

    getPoint(p)  =>

      BufferPoint
# insertTextAtPoint(p, text, noLog)

    # p
    # text

      string

    # noLog

      boolean

    insertTextAtPoint(p, text, noLog)  =>

      number
# loc()

    loc()  =>

      number
# moveAreaByLines(dy, area)

    # dy

      number

    # area

    moveAreaByLines(dy, area)  =>

      boolean
# off(name, handler)

    # name

      string

    # handler

      EventHandler

    off(name, handler)  =>

      void
# on(name, newHandlers)

    # name

      string

    # newHandlers

      EventHandler []

    on(name, newHandlers)  =>

      void
# once(name, fn)

    # name

      string

    # fn

      EventHandler

    once(name, fn)  =>

      void
# removeArea(area, noLog)

    # area
    # noLog

      boolean

    removeArea(area, noLog)  =>

      void
# removeCharAtPoint(p)

    # p

    removeCharAtPoint(p)  =>

      void
# removeOffsetRange(o, noLog)

    # o

      Range

    # noLog

      boolean

    removeOffsetRange(o, noLog)  =>

      void
# replace(data)

    # data

    replace(data)  =>

      void
# setText(text)

    # text

      string

    setText(text)  =>

      void
# toString()

    toString()  =>

      string
# updateRaw()

    updateRaw()  =>

      void
# wordAreaAtPoint(p, inclusive)

    # p

      BufferPoint

    # inclusive

      boolean

    wordAreaAtPoint(p, inclusive)  =>

# Event

    # constructor()
    # _handlers  =  {}

      Record<string, EventHandler []>

    # silent

      boolean

    # _getHandlers(name)

      # name

        string

      _getHandlers(name)  =>

        EventHandler []

# emit(name, a, b, c, d)

    # name

      string

    # a

      any

    # b

      any

    # c

      any

    # d

      any

    emit(name, a, b, c, d)  =>

      void
# off(name, handler)

    # name

      string

    # handler

      EventHandler

    off(name, handler)  =>

      void
# on(name, newHandlers)

    # name

      string

    # newHandlers

      EventHandler []

    on(name, newHandlers)  =>

      void
# once(name, fn)

    # name

      string

    # fn

      EventHandler

    once(name, fn)  =>

      void
# Indexer

    # constructor(buffer)

      # new Indexer()

    # buffer

      TextBuffer

    # find(s)

      # s

        string

      find(s)  =>

        number []

# Line

    # constructor()
    # length  =  0

      number

    # offset  =  0

      number

    # offsetRange  =  ...

      Range

    # point  =  ...

# Parts

    # constructor(minSize)

      # new Parts()

    # length

      number

    # minSize

      number

    # parts

      Part []

    # append(items)

      # items

        number []

      append(items)  =>

        void

# find(offset)

    # offset

      number

    find(offset)  =>

      null | Find
# findOffsetInPart(offset, part)

    # offset

      number

    # part

      Part

    findOffsetInPart(offset, part)  =>

      {

      # index  =  0

        number

      # item  =  null

        null

      } | {

      # index  =  index

        number

      # item  =  item

        number

      }
# findPartByIndex(index)

    # index

      number

    findPartByIndex(index)  =>

      {

      # index  =  0

        number

      # item  =  null

        null

      } | {

      # index  =  index

        number

      # item  =  item

        Part

      }
# findPartByOffset(offset)

    # offset

      number

    findPartByOffset(offset)  =>

      {

      # index  =  0

        number

      # item  =  null

        null

      } | {

      # index  =  index

        number

      # item  =  item

        Part

      }
# get(index)

    # index

      number

    get(index)  =>

      number
# insert(offset, array)

    # offset

      number

    # array

      number []

    insert(offset, array)  =>

      void
# push(item)

    # item

      number

    push(item)  =>

      void
# removeBelowOffset(offset, part)

    # offset

      number

    # part

      Part

    removeBelowOffset(offset, part)  =>

      void
# removeRange(range)

    # range

      [ number, number ]

    removeRange(range)  =>

      void
# shiftIndex(startIndex, shift)

    # startIndex

      number

    # shift

      number

    shiftIndex(startIndex, shift)  =>

      void
# shiftOffset(offset, shift)

    # offset

      number

    # shift

      number

    shiftOffset(offset, shift)  =>

      void
# slice()
# toArray()

    toArray()  =>

      Part []
# Point

    # constructor(p)

      # new Point()

    # *

      # (p)

        # p

          PointLike

        (p)  =>

# +

    # (p)

      # p

        PointLike

      (p)  =>

# -

    # (p)

      # p

        PointLike

      (p)  =>

# /

    # (p)

      # p

        PointLike

      (p)  =>

# ^*

    # (p)

      # p

        PointLike

      (p)  =>

# ^/

    # (p)

      # p

        PointLike

      (p)  =>

# _*

    # (p)

      # p

        PointLike

      (p)  =>

# _/

    # (p)

      # p

        PointLike

      (p)  =>

# minus

    # (p)

      # p

        PointLike

      (p)  =>

# o*

    # (p)

      # p

        PointLike

      (p)  =>

# o/

    # (p)

      # p

        PointLike

      (p)  =>

# plus

    # (p)

      # p

        PointLike

      (p)  =>

# x  =  0

    number

# y  =  0

    number

# abs()
# add(p)

    # p

      PointLike

    add(p)  =>

# addRight(x)

    # x

      number

    addRight(x)  =>

# ceilDiv(p)

    # p

      PointLike

    ceilDiv(p)  =>

# ceilMul(p)

    # p

      PointLike

    ceilMul(p)  =>

# clamp(area)

    # area

      AreaLike

    clamp(area)  =>

# copy()
# div(p)

    # p

      PointLike

    div(p)  =>

# equal(p)

    # p

      PointLike

    equal(p)  =>

      boolean
# floorDiv(p)

    # p

      PointLike

    floorDiv(p)  =>

# floorMul(p)

    # p

      PointLike

    floorMul(p)  =>

# isNotZero()

    isNotZero()  =>

      boolean
# lerp(p, a)

    # p

      PointLike

    # a

      number

    lerp(p, a)  =>

# mul(p)

    # p

      PointLike

    mul(p)  =>

# roundDiv(p)

    # p

      PointLike

    roundDiv(p)  =>

# roundMul(p)

    # p

      PointLike

    roundMul(p)  =>

# set(p)

    # p

      PointLike

    set(p)  =>

      void
# sign()
# sub(p)

    # p

      PointLike

    sub(p)  =>

# toString()

    toString()  =>

      string
# clamp(area, p)

    # area

      AreaLike & PointLike

    # p

      PointLike

    clamp(area, p)  =>

# gridRound(b, a)

    # b

      PointLike

    # a

      PointLike

    gridRound(b, a)  =>

      {

      # x  =  ...

        number

      # y  =  ...

        number

      }
# low(low, p)

    # low

      PointLike

    # p

      PointLike

    low(low, p)  =>

      {

      # x  =  ...

        number

      # y  =  ...

        number

      }
# offset(b, a)

    # b

      PointLike

    # a

      PointLike

    offset(b, a)  =>

      {

      # x  =  ...

        number

      # y  =  ...

        number

      }
# offsetX(x, p)

    # x

      number

    # p

      PointLike

    offsetX(x, p)  =>

      {

      # x  =  ...

        number

      # y  =  ...

        number

      }
# offsetY(y, p)

    # y

      number

    # p

      PointLike

    offsetY(y, p)  =>

      {

      # x  =  ...

        number

      # y  =  ...

        number

      }
# sort(a, b)

    # a

      PointLike

    # b

      PointLike

    sort(a, b)  =>

      number
# toLeftTop(p)

    # p

      PointLike

    toLeftTop(p)  =>

      {

      # left  =  p.x

        undefined | number

      # top  =  p.y

        undefined | number

      }
# PrefixTreeNode
# find(key)
# getChildren()
# index(s)

    # s

      string

    index(s)  =>

      void
# insert(s)

    # s

      string

    insert(s)  =>

      void
# Regexp

    # constructor()
    # types  =  ...

      Record<string, RegExp>

    # create(names, flags, fn)

      # names

        string []

      # flags  =  ''

        string

      # fn(s)

        # s

          string

        fn(s)  =>

          string

create(names, flags, fn)  =>

    RegExp
# join(regexps, flags)

    # regexps

      string | [ string, RegExp ] []

    # flags

      string

    join(regexps, flags)  =>

      RegExp
# parse(s, regexp, filter)

    # s

      string

    # regexp

      RegExp

    # filter(s)

      # s

        RegExpExecArray

      filter(s)  =>

        boolean

parse(s, regexp, filter)  =>

    RegExpExecArray []
# Segments

    # constructor(buffer)
    # buffer

      TextBuffer

    # cache

      {

      # offset

        Record<string | number, PointLike>

      # point

        Record<string, null | string>

      # range

        Record<string | number, boolean>

      # state

        Segment []

      }

# clearCache(offset)

    # offset

      number

    clearCache(offset)  =>

      void
# get(y)

    # y

      number

    get(y)  =>

      null | string
# getCacheState(y)

    # y

      number

    getCacheState(y)  =>

      null | {

      # index  =  0

        number

      # item  =  null

        null

      } | {

      # index  =  index

        number

      # item  =  item

        Segment

      }
# getOffsetPoint(offset)

    # offset

      number

    getOffsetPoint(offset)  =>

      PointLike
# isValid(text, offset, lastIndex)

    # text

      string

    # offset

      number

    # lastIndex

      number

    isValid(text, offset, lastIndex)  =>

      boolean
# isValidRange(range, segment, close)

    # range

      [ number, number ]

    # segment

      Segment

    # close

      number

    isValidRange(range, segment, close)  =>

      boolean
# reset()

    reset()  =>

      void
# SkipString

    # constructor(Options)
    # bias

      number

    # chunkSize

      number

    # head

      Node

    # levels

      number

    # length
    # copy()

# get(offset)

    # offset

      number

    get(offset)  =>

      Search
# getRange(range)

    # range  =  ...

      [ number, number ]

    getRange(range)  =>

      string
# insert(offset, value, level)

    # offset

      number

    # value

      string

    # level

      number

    insert(offset, value, level)  =>

      Node
# insertChunked(offset, text)

    # offset

      number

    # text

      string

    insertChunked(offset, text)  =>

      void
# joinString(delimiter)

    # delimiter

      string

    joinString(delimiter)  =>

      string
# randomLevel()

    randomLevel()  =>

      number
# remove(range)

    # range

      [ number, number ]

    remove(range)  =>

      void
# removeCharAt(offset)

    # offset

      number

    removeCharAt(offset)  =>

      void
# removeNode(steps, node)

    # steps

      Node []

    # node

      Node

    removeNode(steps, node)  =>

      number
# replace(steps, node, value)

    # steps

      Node []

    # node

      Node

    # value

      string

    replace(steps, node, value)  =>

      number
# search(offset, incl)

    # offset

      number

    # incl

      number | boolean

    search(offset, incl)  =>

      Search
# set(text)

    # text

      string

    set(text)  =>

      void
# splice(s, _offset, value, level)

    # s

      Search

    # _offset

      number

    # value

      string

    # level  =  ...

      number

    splice(s, _offset, value, level)  =>

      Node
# substring(a, b)

    # a

      number

    # b

      number

    substring(a, b)  =>

      string
# toString()

    toString()  =>

      string
# update(s, value)

    # s

      Search

    # value

      string

    update(s, value)  =>

      number
# Syntax

    # constructor(Options)
    # blockIndex

      number

    # blocks

      Block []

    # entities

      # (text)

        # text

          string

        (text)  =>

          string

# tab

    string

# createBlocks(code)

    # code

      string

    createBlocks(code)  =>

      string
# createIndents(code)

    # code

      string

    createIndents(code)  =>

      string
# highlight(code)

    # code

      string

    highlight(code)  =>

      Block []
# restoreBlocks(code)

    # code

      string

    restoreBlocks(code)  =>

      Block []
# Tokens

    # constructor(factory)

      # new Tokens()

# _handlers  =  {}

    Record<string, EventHandler []>

# collection

    Record<string, T>

# factory

    # ()

      ()  =>

# silent

    boolean

# tokens

    Record<string, T>

# Type  =  Type

    Record<string, string>

# _getHandlers(name)

    # name

      string

    _getHandlers(name)  =>

      EventHandler []
# copy()
# emit(name, a, b, c, d)

    # name

      string

    # a

      any

    # b

      any

    # c

      any

    # d

      any

    emit(name, a, b, c, d)  =>

      void
# getByIndex(type, index)

    # type

      string

    # index

      number

    getByIndex(type, index)  =>

      number
# getByOffset(type, offset)

    # type

      string

    # offset

      number

    getByOffset(type, offset)  =>

      null | Find
# getCollection(type)

    # type

      string

    getCollection(type)  =>

# index(text, offset)

    # text

      string

    # offset  =  0

      number

    index(text, offset)  =>

      void
# off(name, handler)

    # name

      string

    # handler

      EventHandler

    off(name, handler)  =>

      void
# on(name, newHandlers)

    # name

      string

    # newHandlers

      EventHandler []

    on(name, newHandlers)  =>

      void
# once(name, fn)

    # name

      string

    # fn

      EventHandler

    once(name, fn)  =>

      void
# update(range, text, shift)

    # range

      [ number, number ]

    # text

      string

    # shift

      number

    update(range, text, shift)  =>

      void
# LogEntry

    [ "insert" | "remove", Range, string ]

Contributing

Fork or edit and submit a PR.

All contributions are welcome!

License

MIT © 2022 stagas

Readme

Keywords

Package Sidebar

Install

npm i zerolag

Repository

github.com/stagas/zerolag

Homepage

github.com/stagas/zerolag#readme

Weekly Downloads

34

Version

1.1.0

License

MIT

Unpacked Size

880 kB

Total Files

73

Last publish

Collaborators

  • stagas
Try on RunKit
Report malware