planning

node_modules/@iarna/toml/lib/create-date.js

@@ -0,0 +1,23 @@
+'use strict'
+const f = require('./format-num.js')
+const DateTime = global.Date
+
+class Date extends DateTime {
+  constructor (value) {
+    super(value)
+    this.isDate = true
+  }
+  toISOString () {
+    return `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`
+  }
+}
+
+module.exports = value => {
+  const date = new Date(value)
+  /* istanbul ignore if */
+  if (isNaN(date)) {
+    throw new TypeError('Invalid Datetime')
+  } else {
+    return date
+  }
+}

node_modules/@iarna/toml/lib/create-datetime-float.js

@@ -0,0 +1,24 @@
+'use strict'
+const f = require('./format-num.js')
+
+class FloatingDateTime extends Date {
+  constructor (value) {
+    super(value + 'Z')
+    this.isFloating = true
+  }
+  toISOString () {
+    const date = `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`
+    const time = `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`
+    return `${date}T${time}`
+  }
+}
+
+module.exports = value => {
+  const date = new FloatingDateTime(value)
+  /* istanbul ignore if */
+  if (isNaN(date)) {
+    throw new TypeError('Invalid Datetime')
+  } else {
+    return date
+  }
+}

node_modules/@iarna/toml/lib/create-datetime.js

@@ -0,0 +1,10 @@
+'use strict'
+module.exports = value => {
+  const date = new Date(value)
+  /* istanbul ignore if */
+  if (isNaN(date)) {
+    throw new TypeError('Invalid Datetime')
+  } else {
+    return date
+  }
+}

node_modules/@iarna/toml/lib/create-time.js

@@ -0,0 +1,22 @@
+'use strict'
+const f = require('./format-num.js')
+
+class Time extends Date {
+  constructor (value) {
+    super(`0000-01-01T${value}Z`)
+    this.isTime = true
+  }
+  toISOString () {
+    return `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`
+  }
+}
+
+module.exports = value => {
+  const date = new Time(value)
+  /* istanbul ignore if */
+  if (isNaN(date)) {
+    throw new TypeError('Invalid Datetime')
+  } else {
+    return date
+  }
+}

node_modules/@iarna/toml/lib/format-num.js

@@ -0,0 +1,6 @@
+'use strict'
+module.exports = (d, num) => {
+  num = String(num)
+  while (num.length < d) num = '0' + num
+  return num
+}

node_modules/@iarna/toml/lib/parser-debug.js

@@ -0,0 +1,60 @@
+'use strict'
+const Parser = require('./parser.js')
+const util = require('util')
+
+const dump = _ => util.inspect(_, {colors: true, depth: 10, breakLength: Infinity})
+class DebugParser extends Parser {
+  stateName (state) {
+    // istanbul ignore next
+    return (state.parser && state.parser.name) || state.name || ('anonymous')
+  }
+  runOne () {
+    const callStack = this.stack.concat(this.state).map(_ => this.stateName(_)).join(' <- ')
+    console.log('RUN', callStack, dump({line: this.line, col: this.col, char: this.char, ret: this.state.returned}))
+    return super.runOne()
+  }
+  finish () {
+    const obj = super.finish()
+    // istanbul ignore if
+    if (this.stack.length !== 0) {
+      throw new Parser.Error('All states did not return by end of stream')
+    }
+    return obj
+  }
+  callStack () {
+    const callStack = this.stack.map(_ => this.stateName(_)).join('    ').replace(/\S/g, ' ')
+    return callStack ? callStack + '    ' : ''
+  }
+  next (fn) {
+    console.log('  ', this.callStack(), 'NEXT', this.stateName(fn))
+    return super.next(fn)
+  }
+  goto (fn) {
+    console.log('  ', this.callStack(), 'GOTO', this.stateName(fn))
+    super.next(fn)
+    return false
+  }
+  call (fn, returnWith) {
+    console.log('  ', this.callStack(), 'CALL', fn.name, returnWith ? '-> ' + returnWith.name : '')
+    if (returnWith) super.next(returnWith)
+    this.stack.push(this.state)
+    this.state = {parser: fn, buf: '', returned: null}
+  }
+  callNow (fn, returnWith) {
+    console.log('  ', this.callStack(), 'CALLNOW', fn.name, returnWith ? '-> ' + returnWith.name : '')
+    if (returnWith) super.next(returnWith)
+    this.stack.push(this.state)
+    this.state = {parser: fn, buf: '', returned: null}
+    return false
+  }
+  return (value) {
+    console.log('  ', this.callStack(), 'RETURN')
+    return super.return(value)
+  }
+  returnNow (value) {
+    console.log('  ', this.callStack(), 'RETURNNOW')
+    super.return(value)
+    return false
+  }
+}
+module.exports = DebugParser

node_modules/@iarna/toml/lib/parser.js

@@ -0,0 +1,127 @@
+'use strict'
+const ParserEND = 0x110000
+class ParserError extends Error {
+  /* istanbul ignore next */
+  constructor (msg, filename, linenumber) {
+    super('[ParserError] ' + msg, filename, linenumber)
+    this.name = 'ParserError'
+    this.code = 'ParserError'
+    if (Error.captureStackTrace) Error.captureStackTrace(this, ParserError)
+  }
+}
+class State {
+  constructor (parser) {
+    this.parser = parser
+    this.buf = ''
+    this.returned = null
+    this.result = null
+    this.resultTable = null
+    this.resultArr = null
+  }
+}
+class Parser {
+  constructor () {
+    this.pos = 0
+    this.col = 0
+    this.line = 0
+    this.obj = {}
+    this.ctx = this.obj
+    this.stack = []
+    this._buf = ''
+    this.char = null
+    this.ii = 0
+    this.state = new State(this.parseStart)
+  }
+
+  parse (str) {
+    /* istanbul ignore next */
+    if (str.length === 0 || str.length == null) return
+
+    this._buf = String(str)
+    this.ii = -1
+    this.char = -1
+    let getNext
+    while (getNext === false || this.nextChar()) {
+      getNext = this.runOne()
+    }
+    this._buf = null
+  }
+  nextChar () {
+    if (this.char === 0x0A) {
+      ++this.line
+      this.col = -1
+    }
+    ++this.ii
+    this.char = this._buf.codePointAt(this.ii)
+    ++this.pos
+    ++this.col
+    return this.haveBuffer()
+  }
+  haveBuffer () {
+    return this.ii < this._buf.length
+  }
+  runOne () {
+    return this.state.parser.call(this, this.state.returned)
+  }
+  finish () {
+    this.char = ParserEND
+    let last
+    do {
+      last = this.state.parser
+      this.runOne()
+    } while (this.state.parser !== last)
+
+    this.ctx = null
+    this.state = null
+    this._buf = null
+
+    return this.obj
+  }
+  next (fn) {
+    /* istanbul ignore next */
+    if (typeof fn !== 'function') throw new ParserError('Tried to set state to non-existent state: ' + JSON.stringify(fn))
+    this.state.parser = fn
+  }
+  goto (fn) {
+    this.next(fn)
+    return this.runOne()
+  }
+  call (fn, returnWith) {
+    if (returnWith) this.next(returnWith)
+    this.stack.push(this.state)
+    this.state = new State(fn)
+  }
+  callNow (fn, returnWith) {
+    this.call(fn, returnWith)
+    return this.runOne()
+  }
+  return (value) {
+    /* istanbul ignore next */
+    if (this.stack.length === 0) throw this.error(new ParserError('Stack underflow'))
+    if (value === undefined) value = this.state.buf
+    this.state = this.stack.pop()
+    this.state.returned = value
+  }
+  returnNow (value) {
+    this.return(value)
+    return this.runOne()
+  }
+  consume () {
+    /* istanbul ignore next */
+    if (this.char === ParserEND) throw this.error(new ParserError('Unexpected end-of-buffer'))
+    this.state.buf += this._buf[this.ii]
+  }
+  error (err) {
+    err.line = this.line
+    err.col = this.col
+    err.pos = this.pos
+    return err
+  }
+  /* istanbul ignore next */
+  parseStart () {
+    throw new ParserError('Must declare a parseStart method')
+  }
+}
+Parser.END = ParserEND
+Parser.Error = ParserError
+module.exports = Parser