projen 0.80.6 → 0.80.7

package/node_modules/@iarna/toml/package.json

@@ -1,82 +0,0 @@
-{
-  "name": "@iarna/toml",
-  "version": "2.2.5",
-  "main": "toml.js",
-  "scripts": {
-    "test": "tap -J --100 test/*.js test/toml-stream/*.js",
-    "benchmark": "node benchmark.js && node benchmark-per-file.js && node results2table.js",
-    "prerelease": "npm t",
-    "prepack": "rm -f *~",
-    "postpublish": "git push --follow-tags",
-    "pretest": "iarna-standard",
-    "update-coc": "weallbehave -o . && git add CODE_OF_CONDUCT.md && git commit -m 'docs(coc): updated CODE_OF_CONDUCT.md'",
-    "update-contrib": "weallcontribute -o . && git add CONTRIBUTING.md && git commit -m 'docs(contributing): updated CONTRIBUTING.md'",
-    "setup-burntsushi-toml-suite": "[ -d test/burntsushi-toml-test ] || (git clone https://github.com/BurntSushi/toml-test test/burntsushi-toml-test; rimraf test/burntsushi-toml-test/.git/hooks/*); cd test/burntsushi-toml-test; git pull",
-    "setup-iarna-toml-suite": "[ -d test/spec-test ] || (git clone https://github.com/iarna/toml-spec-tests -b 0.5.0 test/spec-test; rimraf test/spec-test/.git/hooks/*); cd test/spec-test; git pull",
-    "prepare": "npm run setup-burntsushi-toml-suite && npm run setup-iarna-toml-suite"
-  },
-  "keywords": [
-    "toml",
-    "toml-parser",
-    "toml-stringifier",
-    "parser",
-    "stringifer",
-    "emitter",
-    "ini",
-    "tomlify",
-    "encoder",
-    "decoder"
-  ],
-  "author": "Rebecca Turner <me@re-becca.org> (http://re-becca.org/)",
-  "license": "ISC",
-  "description": "Better TOML parsing and stringifying all in that familiar JSON interface.",
-  "dependencies": {},
-  "devDependencies": {
-    "@iarna/standard": "^2.0.2",
-    "@ltd/j-toml": "^0.5.107",
-    "@perl/qx": "^1.1.0",
-    "@sgarciac/bombadil": "^2.3.0",
-    "ansi": "^0.3.1",
-    "approximate-number": "^2.0.0",
-    "benchmark": "^2.1.4",
-    "fast-toml": "^0.5.4",
-    "funstream": "^4.2.0",
-    "glob": "^7.1.6",
-    "js-yaml": "^3.13.1",
-    "rimraf": "^3.0.2",
-    "tap": "^12.0.1",
-    "toml": "^3.0.0",
-    "toml-j0.4": "^1.1.1",
-    "weallbehave": "*",
-    "weallcontribute": "*"
-  },
-  "files": [
-    "toml.js",
-    "stringify.js",
-    "parse.js",
-    "parse-string.js",
-    "parse-stream.js",
-    "parse-async.js",
-    "parse-pretty-error.js",
-    "lib/parser.js",
-    "lib/parser-debug.js",
-    "lib/toml-parser.js",
-    "lib/create-datetime.js",
-    "lib/create-date.js",
-    "lib/create-datetime-float.js",
-    "lib/create-time.js",
-    "lib/format-num.js",
-    "index.d.ts"
-  ],
-  "directories": {
-    "test": "test"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/iarna/iarna-toml.git"
-  },
-  "bugs": {
-    "url": "https://github.com/iarna/iarna-toml/issues"
-  },
-  "homepage": "https://github.com/iarna/iarna-toml#readme"
-}

package/node_modules/@iarna/toml/parse-async.js

@@ -1,30 +0,0 @@
-'use strict'
-module.exports = parseAsync
-
-const TOMLParser = require('./lib/toml-parser.js')
-const prettyError = require('./parse-pretty-error.js')
-
-function parseAsync (str, opts) {
-  if (!opts) opts = {}
-  const index = 0
-  const blocksize = opts.blocksize || 40960
-  const parser = new TOMLParser()
-  return new Promise((resolve, reject) => {
-    setImmediate(parseAsyncNext, index, blocksize, resolve, reject)
-  })
-  function parseAsyncNext (index, blocksize, resolve, reject) {
-    if (index >= str.length) {
-      try {
-        return resolve(parser.finish())
-      } catch (err) {
-        return reject(prettyError(err, str))
-      }
-    }
-    try {
-      parser.parse(str.slice(index, index + blocksize))
-      setImmediate(parseAsyncNext, index + blocksize, blocksize, resolve, reject)
-    } catch (err) {
-      reject(prettyError(err, str))
-    }
-  }
-}

package/node_modules/@iarna/toml/parse-pretty-error.js

@@ -1,33 +0,0 @@
-'use strict'
-module.exports = prettyError
-
-function prettyError (err, buf) {
-  /* istanbul ignore if */
-  if (err.pos == null || err.line == null) return err
-  let msg = err.message
-  msg += ` at row ${err.line + 1}, col ${err.col + 1}, pos ${err.pos}:\n`
-
-  /* istanbul ignore else */
-  if (buf && buf.split) {
-    const lines = buf.split(/\n/)
-    const lineNumWidth = String(Math.min(lines.length, err.line + 3)).length
-    let linePadding = ' '
-    while (linePadding.length < lineNumWidth) linePadding += ' '
-    for (let ii = Math.max(0, err.line - 1); ii < Math.min(lines.length, err.line + 2); ++ii) {
-      let lineNum = String(ii + 1)
-      if (lineNum.length < lineNumWidth) lineNum = ' ' + lineNum
-      if (err.line === ii) {
-        msg += lineNum + '> ' + lines[ii] + '\n'
-        msg += linePadding + '  '
-        for (let hh = 0; hh < err.col; ++hh) {
-          msg += ' '
-        }
-        msg += '^\n'
-      } else {
-        msg += lineNum + ': ' + lines[ii] + '\n'
-      }
-    }
-  }
-  err.message = msg + '\n'
-  return err
-}

package/node_modules/@iarna/toml/parse-stream.js

@@ -1,80 +0,0 @@
-'use strict'
-module.exports = parseStream
-
-const stream = require('stream')
-const TOMLParser = require('./lib/toml-parser.js')
-
-function parseStream (stm) {
-  if (stm) {
-    return parseReadable(stm)
-  } else {
-    return parseTransform(stm)
-  }
-}
-
-function parseReadable (stm) {
-  const parser = new TOMLParser()
-  stm.setEncoding('utf8')
-  return new Promise((resolve, reject) => {
-    let readable
-    let ended = false
-    let errored = false
-    function finish () {
-      ended = true
-      if (readable) return
-      try {
-        resolve(parser.finish())
-      } catch (err) {
-        reject(err)
-      }
-    }
-    function error (err) {
-      errored = true
-      reject(err)
-    }
-    stm.once('end', finish)
-    stm.once('error', error)
-    readNext()
-
-    function readNext () {
-      readable = true
-      let data
-      while ((data = stm.read()) !== null) {
-        try {
-          parser.parse(data)
-        } catch (err) {
-          return error(err)
-        }
-      }
-      readable = false
-      /* istanbul ignore if */
-      if (ended) return finish()
-      /* istanbul ignore if */
-      if (errored) return
-      stm.once('readable', readNext)
-    }
-  })
-}
-
-function parseTransform () {
-  const parser = new TOMLParser()
-  return new stream.Transform({
-    objectMode: true,
-    transform (chunk, encoding, cb) {
-      try {
-        parser.parse(chunk.toString(encoding))
-      } catch (err) {
-        this.emit('error', err)
-      }
-      cb()
-    },
-    flush (cb) {
-      try {
-        this.push(parser.finish())
-      } catch (err) {
-        this.emit('error', err)
-      }
-      cb()
-    }
-  })
-}

package/node_modules/@iarna/toml/parse-string.js

@@ -1,18 +0,0 @@
-'use strict'
-module.exports = parseString
-
-const TOMLParser = require('./lib/toml-parser.js')
-const prettyError = require('./parse-pretty-error.js')
-
-function parseString (str) {
-  if (global.Buffer && global.Buffer.isBuffer(str)) {
-    str = str.toString('utf8')
-  }
-  const parser = new TOMLParser()
-  try {
-    parser.parse(str)
-    return parser.finish()
-  } catch (err) {
-    throw prettyError(err, str)
-  }
-}

package/node_modules/@iarna/toml/parse.js

@@ -1,5 +0,0 @@
-'use strict'
-module.exports = require('./parse-string.js')
-module.exports.async = require('./parse-async.js')
-module.exports.stream = require('./parse-stream.js')
-module.exports.prettyError = require('./parse-pretty-error.js')

package/node_modules/@iarna/toml/stringify.js

@@ -1,296 +0,0 @@
-'use strict'
-module.exports = stringify
-module.exports.value = stringifyInline
-
-function stringify (obj) {
-  if (obj === null) throw typeError('null')
-  if (obj === void (0)) throw typeError('undefined')
-  if (typeof obj !== 'object') throw typeError(typeof obj)
-
-  if (typeof obj.toJSON === 'function') obj = obj.toJSON()
-  if (obj == null) return null
-  const type = tomlType(obj)
-  if (type !== 'table') throw typeError(type)
-  return stringifyObject('', '', obj)
-}
-
-function typeError (type) {
-  return new Error('Can only stringify objects, not ' + type)
-}
-
-function arrayOneTypeError () {
-  return new Error("Array values can't have mixed types")
-}
-
-function getInlineKeys (obj) {
-  return Object.keys(obj).filter(key => isInline(obj[key]))
-}
-function getComplexKeys (obj) {
-  return Object.keys(obj).filter(key => !isInline(obj[key]))
-}
-
-function toJSON (obj) {
-  let nobj = Array.isArray(obj) ? [] : Object.prototype.hasOwnProperty.call(obj, '__proto__') ? {['__proto__']: undefined} : {}
-  for (let prop of Object.keys(obj)) {
-    if (obj[prop] && typeof obj[prop].toJSON === 'function' && !('toISOString' in obj[prop])) {
-      nobj[prop] = obj[prop].toJSON()
-    } else {
-      nobj[prop] = obj[prop]
-    }
-  }
-  return nobj
-}
-
-function stringifyObject (prefix, indent, obj) {
-  obj = toJSON(obj)
-  var inlineKeys
-  var complexKeys
-  inlineKeys = getInlineKeys(obj)
-  complexKeys = getComplexKeys(obj)
-  var result = []
-  var inlineIndent = indent || ''
-  inlineKeys.forEach(key => {
-    var type = tomlType(obj[key])
-    if (type !== 'undefined' && type !== 'null') {
-      result.push(inlineIndent + stringifyKey(key) + ' = ' + stringifyAnyInline(obj[key], true))
-    }
-  })
-  if (result.length > 0) result.push('')
-  var complexIndent = prefix && inlineKeys.length > 0 ? indent + '  ' : ''
-  complexKeys.forEach(key => {
-    result.push(stringifyComplex(prefix, complexIndent, key, obj[key]))
-  })
-  return result.join('\n')
-}
-
-function isInline (value) {
-  switch (tomlType(value)) {
-    case 'undefined':
-    case 'null':
-    case 'integer':
-    case 'nan':
-    case 'float':
-    case 'boolean':
-    case 'string':
-    case 'datetime':
-      return true
-    case 'array':
-      return value.length === 0 || tomlType(value[0]) !== 'table'
-    case 'table':
-      return Object.keys(value).length === 0
-    /* istanbul ignore next */
-    default:
-      return false
-  }
-}
-
-function tomlType (value) {
-  if (value === undefined) {
-    return 'undefined'
-  } else if (value === null) {
-    return 'null'
-  /* eslint-disable valid-typeof */
-  } else if (typeof value === 'bigint' || (Number.isInteger(value) && !Object.is(value, -0))) {
-    return 'integer'
-  } else if (typeof value === 'number') {
-    return 'float'
-  } else if (typeof value === 'boolean') {
-    return 'boolean'
-  } else if (typeof value === 'string') {
-    return 'string'
-  } else if ('toISOString' in value) {
-    return isNaN(value) ? 'undefined' : 'datetime'
-  } else if (Array.isArray(value)) {
-    return 'array'
-  } else {
-    return 'table'
-  }
-}
-
-function stringifyKey (key) {
-  var keyStr = String(key)
-  if (/^[-A-Za-z0-9_]+$/.test(keyStr)) {
-    return keyStr
-  } else {
-    return stringifyBasicString(keyStr)
-  }
-}
-
-function stringifyBasicString (str) {
-  return '"' + escapeString(str).replace(/"/g, '\\"') + '"'
-}
-
-function stringifyLiteralString (str) {
-  return "'" + str + "'"
-}
-
-function numpad (num, str) {
-  while (str.length < num) str = '0' + str
-  return str
-}
-
-function escapeString (str) {
-  return str.replace(/\\/g, '\\\\')
-    .replace(/[\b]/g, '\\b')
-    .replace(/\t/g, '\\t')
-    .replace(/\n/g, '\\n')
-    .replace(/\f/g, '\\f')
-    .replace(/\r/g, '\\r')
-    /* eslint-disable no-control-regex */
-    .replace(/([\u0000-\u001f\u007f])/, c => '\\u' + numpad(4, c.codePointAt(0).toString(16)))
-    /* eslint-enable no-control-regex */
-}
-
-function stringifyMultilineString (str) {
-  let escaped = str.split(/\n/).map(str => {
-    return escapeString(str).replace(/"(?="")/g, '\\"')
-  }).join('\n')
-  if (escaped.slice(-1) === '"') escaped += '\\\n'
-  return '"""\n' + escaped + '"""'
-}
-
-function stringifyAnyInline (value, multilineOk) {
-  let type = tomlType(value)
-  if (type === 'string') {
-    if (multilineOk && /\n/.test(value)) {
-      type = 'string-multiline'
-    } else if (!/[\b\t\n\f\r']/.test(value) && /"/.test(value)) {
-      type = 'string-literal'
-    }
-  }
-  return stringifyInline(value, type)
-}
-
-function stringifyInline (value, type) {
-  /* istanbul ignore if */
-  if (!type) type = tomlType(value)
-  switch (type) {
-    case 'string-multiline':
-      return stringifyMultilineString(value)
-    case 'string':
-      return stringifyBasicString(value)
-    case 'string-literal':
-      return stringifyLiteralString(value)
-    case 'integer':
-      return stringifyInteger(value)
-    case 'float':
-      return stringifyFloat(value)
-    case 'boolean':
-      return stringifyBoolean(value)
-    case 'datetime':
-      return stringifyDatetime(value)
-    case 'array':
-      return stringifyInlineArray(value.filter(_ => tomlType(_) !== 'null' && tomlType(_) !== 'undefined' && tomlType(_) !== 'nan'))
-    case 'table':
-      return stringifyInlineTable(value)
-    /* istanbul ignore next */
-    default:
-      throw typeError(type)
-  }
-}
-
-function stringifyInteger (value) {
-  /* eslint-disable security/detect-unsafe-regex */
-  return String(value).replace(/\B(?=(\d{3})+(?!\d))/g, '_')
-}
-
-function stringifyFloat (value) {
-  if (value === Infinity) {
-    return 'inf'
-  } else if (value === -Infinity) {
-    return '-inf'
-  } else if (Object.is(value, NaN)) {
-    return 'nan'
-  } else if (Object.is(value, -0)) {
-    return '-0.0'
-  }
-  var chunks = String(value).split('.')
-  var int = chunks[0]
-  var dec = chunks[1] || 0
-  return stringifyInteger(int) + '.' + dec
-}
-
-function stringifyBoolean (value) {
-  return String(value)
-}
-
-function stringifyDatetime (value) {
-  return value.toISOString()
-}
-
-function isNumber (type) {
-  return type === 'float' || type === 'integer'
-}
-function arrayType (values) {
-  var contentType = tomlType(values[0])
-  if (values.every(_ => tomlType(_) === contentType)) return contentType
-  // mixed integer/float, emit as floats
-  if (values.every(_ => isNumber(tomlType(_)))) return 'float'
-  return 'mixed'
-}
-function validateArray (values) {
-  const type = arrayType(values)
-  if (type === 'mixed') {
-    throw arrayOneTypeError()
-  }
-  return type
-}
-
-function stringifyInlineArray (values) {
-  values = toJSON(values)
-  const type = validateArray(values)
-  var result = '['
-  var stringified = values.map(_ => stringifyInline(_, type))
-  if (stringified.join(', ').length > 60 || /\n/.test(stringified)) {
-    result += '\n  ' + stringified.join(',\n  ') + '\n'
-  } else {
-    result += ' ' + stringified.join(', ') + (stringified.length > 0 ? ' ' : '')
-  }
-  return result + ']'
-}
-
-function stringifyInlineTable (value) {
-  value = toJSON(value)
-  var result = []
-  Object.keys(value).forEach(key => {
-    result.push(stringifyKey(key) + ' = ' + stringifyAnyInline(value[key], false))
-  })
-  return '{ ' + result.join(', ') + (result.length > 0 ? ' ' : '') + '}'
-}
-
-function stringifyComplex (prefix, indent, key, value) {
-  var valueType = tomlType(value)
-  /* istanbul ignore else */
-  if (valueType === 'array') {
-    return stringifyArrayOfTables(prefix, indent, key, value)
-  } else if (valueType === 'table') {
-    return stringifyComplexTable(prefix, indent, key, value)
-  } else {
-    throw typeError(valueType)
-  }
-}
-
-function stringifyArrayOfTables (prefix, indent, key, values) {
-  values = toJSON(values)
-  validateArray(values)
-  var firstValueType = tomlType(values[0])
-  /* istanbul ignore if */
-  if (firstValueType !== 'table') throw typeError(firstValueType)
-  var fullKey = prefix + stringifyKey(key)
-  var result = ''
-  values.forEach(table => {
-    if (result.length > 0) result += '\n'
-    result += indent + '[[' + fullKey + ']]\n'
-    result += stringifyObject(fullKey + '.', indent, table)
-  })
-  return result
-}
-
-function stringifyComplexTable (prefix, indent, key, value) {
-  var fullKey = prefix + stringifyKey(key)
-  var result = ''
-  if (getInlineKeys(value).length > 0) {
-    result += indent + '[' + fullKey + ']\n'
-  }
-  return result + stringifyObject(fullKey + '.', indent, value)
-}

package/node_modules/@iarna/toml/toml.js

@@ -1,3 +0,0 @@
-'use strict'
-exports.parse = require('./parse.js')
-exports.stringify = require('./stringify.js')