@prismer/sdk 2.0.7 → 2.2.55

package/node_modules/@iarna/toml/index.d.ts

@@ -0,0 +1,57 @@
+import { Transform } from "stream";
+
+type JsonArray = boolean[] | number[] | string[] | JsonMap[] | Date[]
+type AnyJson = boolean | number | string | JsonMap | Date | JsonArray | JsonArray[]
+
+interface JsonMap {
+  [key: string]: AnyJson;
+}
+
+interface ParseOptions {
+  /**
+   * The amount text to parser per pass through the event loop. Defaults to 40kb (`40000`).
+   */
+  blocksize: number
+}
+
+interface FuncParse {
+  /**
+   * Synchronously parse a TOML string and return an object.
+   */
+  (toml: string): JsonMap
+
+  /**
+   * Asynchronously parse a TOML string and return a promise of the resulting object.
+   */
+  async (toml: string, options?: ParseOptions): Promise<JsonMap>
+
+  /**
+   * Given a readable stream, parse it as it feeds us data. Return a promise of the resulting object.
+   */
+  stream (readable: NodeJS.ReadableStream): Promise<JsonMap>
+  stream (): Transform
+}
+
+interface FuncStringify {
+  /**
+   * Serialize an object as TOML.
+   *
+   * If an object `TOML.stringify` is serializing has a `toJSON` method
+   * then it will call it to transform the object before serializing it.
+   * This matches the behavior of JSON.stringify.
+   *
+   * The one exception to this is that `toJSON` is not called for `Date` objects
+   * because JSON represents dates as strings and TOML can represent them natively.
+   *
+   * `moment` objects are treated the same as native `Date` objects, in this respect.
+   */
+  (obj: JsonMap): string
+
+  /**
+   * Serialize a value as TOML would. This is a fragment and not a complete valid TOML document.
+   */
+  value (any: AnyJson): string
+}
+
+export const parse: FuncParse
+export const stringify: FuncStringify

package/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
+  }
+}

package/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
+  }
+}

package/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
+  }
+}

package/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
+  }
+}

package/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
+}

package/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

package/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