@ai-workbench/connect 0.0.0-stage → 0.7.6

package/node_modules/js-yaml/lib/schema/core.js

@@ -0,0 +1,9 @@
+// Standard YAML's Core schema.
+// http://www.yaml.org/spec/1.2/spec.html#id2804923
+//
+// NOTE: JS-YAML does not support schema-specific tag resolution restrictions.
+// So, Core schema has no distinctions from JSON schema is JS-YAML.
+
+'use strict'
+
+module.exports = require('./json')

package/node_modules/js-yaml/lib/schema/default.js

@@ -0,0 +1,20 @@
+// JS-YAML's default schema for `safeLoad` function.
+// It is not described in the YAML specification.
+//
+// This schema is based on standard YAML's Core schema and includes most of
+// extra types described at YAML tag repository. (http://yaml.org/type/)
+
+'use strict'
+
+module.exports = require('./core').extend({
+  implicit: [
+    require('../type/timestamp'),
+    require('../type/merge')
+  ],
+  explicit: [
+    require('../type/binary'),
+    require('../type/omap'),
+    require('../type/pairs'),
+    require('../type/set')
+  ]
+})

package/node_modules/js-yaml/lib/schema/failsafe.js

@@ -0,0 +1,14 @@
+// Standard YAML's Failsafe schema.
+// http://www.yaml.org/spec/1.2/spec.html#id2802346
+
+'use strict'
+
+const Schema = require('../schema')
+
+module.exports = new Schema({
+  explicit: [
+    require('../type/str'),
+    require('../type/seq'),
+    require('../type/map')
+  ]
+})

package/node_modules/js-yaml/lib/schema/json.js

@@ -0,0 +1,17 @@
+// Standard YAML's JSON schema.
+// http://www.yaml.org/spec/1.2/spec.html#id2803231
+//
+// NOTE: JS-YAML does not support schema-specific tag resolution restrictions.
+// So, this schema is not such strict as defined in the YAML specification.
+// It allows numbers in binary notaion, use `Null` and `NULL` as `null`, etc.
+
+'use strict'
+
+module.exports = require('./failsafe').extend({
+  implicit: [
+    require('../type/null'),
+    require('../type/bool'),
+    require('../type/int'),
+    require('../type/float')
+  ]
+})

package/node_modules/js-yaml/lib/schema.js

@@ -0,0 +1,109 @@
+'use strict'
+
+const YAMLException = require('./exception')
+const Type = require('./type')
+
+function compileList (schema, name) {
+  const result = []
+
+  schema[name].forEach(function (currentType) {
+    let newIndex = result.length
+
+    result.forEach(function (previousType, previousIndex) {
+      if (previousType.tag === currentType.tag &&
+          previousType.kind === currentType.kind &&
+          previousType.multi === currentType.multi) {
+        newIndex = previousIndex
+      }
+    })
+
+    result[newIndex] = currentType
+  })
+
+  return result
+}
+
+function compileMap (/* lists... */) {
+  const result = {
+    scalar: {},
+    sequence: {},
+    mapping: {},
+    fallback: {},
+    multi: {
+      scalar: [],
+      sequence: [],
+      mapping: [],
+      fallback: []
+    }
+  }
+  function collectType (type) {
+    if (type.multi) {
+      result.multi[type.kind].push(type)
+      result.multi['fallback'].push(type)
+    } else {
+      result[type.kind][type.tag] = result['fallback'][type.tag] = type
+    }
+  }
+
+  for (let index = 0, length = arguments.length; index < length; index += 1) {
+    arguments[index].forEach(collectType)
+  }
+  return result
+}
+
+function Schema (definition) {
+  return this.extend(definition)
+}
+
+Schema.prototype.extend = function extend (definition) {
+  let implicit = []
+  let explicit = []
+
+  if (definition instanceof Type) {
+    // Schema.extend(type)
+    explicit.push(definition)
+  } else if (Array.isArray(definition)) {
+    // Schema.extend([ type1, type2, ... ])
+    explicit = explicit.concat(definition)
+  } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
+    // Schema.extend({ explicit: [ type1, type2, ... ], implicit: [ type1, type2, ... ] })
+    if (definition.implicit) implicit = implicit.concat(definition.implicit)
+    if (definition.explicit) explicit = explicit.concat(definition.explicit)
+  } else {
+    throw new YAMLException('Schema.extend argument should be a Type, [ Type ], ' +
+      'or a schema definition ({ implicit: [...], explicit: [...] })')
+  }
+
+  implicit.forEach(function (type) {
+    if (!(type instanceof Type)) {
+      throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.')
+    }
+
+    if (type.loadKind && type.loadKind !== 'scalar') {
+      throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.')
+    }
+
+    if (type.multi) {
+      throw new YAMLException('There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.')
+    }
+  })
+
+  explicit.forEach(function (type) {
+    if (!(type instanceof Type)) {
+      throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.')
+    }
+  })
+
+  const result = Object.create(Schema.prototype)
+
+  result.implicit = (this.implicit || []).concat(implicit)
+  result.explicit = (this.explicit || []).concat(explicit)
+
+  result.compiledImplicit = compileList(result, 'implicit')
+  result.compiledExplicit = compileList(result, 'explicit')
+  result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit)
+
+  return result
+}
+
+module.exports = Schema

package/node_modules/js-yaml/lib/snippet.js

@@ -0,0 +1,96 @@
+'use strict'
+
+const common = require('./common')
+
+// get snippet for a single line, respecting maxLength
+function getLine (buffer, lineStart, lineEnd, position, maxLineLength) {
+  let head = ''
+  let tail = ''
+  const maxHalfLength = Math.floor(maxLineLength / 2) - 1
+
+  if (position - lineStart > maxHalfLength) {
+    head = ' ... '
+    lineStart = position - maxHalfLength + head.length
+  }
+
+  if (lineEnd - position > maxHalfLength) {
+    tail = ' ...'
+    lineEnd = position + maxHalfLength - tail.length
+  }
+
+  return {
+    str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, '→') + tail,
+    pos: position - lineStart + head.length // relative position
+  }
+}
+
+function padStart (string, max) {
+  return common.repeat(' ', max - string.length) + string
+}
+
+function makeSnippet (mark, options) {
+  options = Object.create(options || null)
+
+  if (!mark.buffer) return null
+
+  if (!options.maxLength) options.maxLength = 79
+  if (typeof options.indent !== 'number') options.indent = 1
+  if (typeof options.linesBefore !== 'number') options.linesBefore = 3
+  if (typeof options.linesAfter !== 'number') options.linesAfter = 2
+
+  const re = /\r?\n|\r|\0/g
+  const lineStarts = [0]
+  const lineEnds = []
+  let match
+  let foundLineNo = -1
+
+  while ((match = re.exec(mark.buffer))) {
+    lineEnds.push(match.index)
+    lineStarts.push(match.index + match[0].length)
+
+    if (mark.position <= match.index && foundLineNo < 0) {
+      foundLineNo = lineStarts.length - 2
+    }
+  }
+
+  if (foundLineNo < 0) foundLineNo = lineStarts.length - 1
+
+  let result = ''
+  const lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length
+  const maxLineLength = options.maxLength - (options.indent + lineNoLength + 3)
+
+  for (let i = 1; i <= options.linesBefore; i++) {
+    if (foundLineNo - i < 0) break
+    const line = getLine(
+      mark.buffer,
+      lineStarts[foundLineNo - i],
+      lineEnds[foundLineNo - i],
+      mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]),
+      maxLineLength
+    )
+    result = common.repeat(' ', options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) +
+      ' | ' + line.str + '\n' + result
+  }
+
+  const line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength)
+  result += common.repeat(' ', options.indent) + padStart((mark.line + 1).toString(), lineNoLength) +
+    ' | ' + line.str + '\n'
+  result += common.repeat('-', options.indent + lineNoLength + 3 + line.pos) + '^' + '\n'
+
+  for (let i = 1; i <= options.linesAfter; i++) {
+    if (foundLineNo + i >= lineEnds.length) break
+    const line = getLine(
+      mark.buffer,
+      lineStarts[foundLineNo + i],
+      lineEnds[foundLineNo + i],
+      mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]),
+      maxLineLength
+    )
+    result += common.repeat(' ', options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) +
+      ' | ' + line.str + '\n'
+  }
+
+  return result.replace(/\n$/, '')
+}
+
+module.exports = makeSnippet

package/node_modules/js-yaml/lib/type/binary.js

@@ -0,0 +1,122 @@
+'use strict'
+
+const Type = require('../type')
+
+// [ 64, 65, 66 ] -> [ padding, CR, LF ]
+const BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r'
+
+function resolveYamlBinary (data) {
+  if (data === null) return false
+
+  let bitlen = 0
+  const max = data.length
+  const map = BASE64_MAP
+
+  // Convert one by one.
+  for (let idx = 0; idx < max; idx++) {
+    const code = map.indexOf(data.charAt(idx))
+
+    // Skip CR/LF
+    if (code > 64) continue
+
+    // Fail on illegal characters
+    if (code < 0) return false
+
+    bitlen += 6
+  }
+
+  // If there are any bits left, source was corrupted
+  return (bitlen % 8) === 0
+}
+
+function constructYamlBinary (data) {
+  const input = data.replace(/[\r\n=]/g, '') // remove CR/LF & padding to simplify scan
+  const max = input.length
+  const map = BASE64_MAP
+  let bits = 0
+  const result = []
+
+  // Collect by 6*4 bits (3 bytes)
+
+  for (let idx = 0; idx < max; idx++) {
+    if ((idx % 4 === 0) && idx) {
+      result.push((bits >> 16) & 0xFF)
+      result.push((bits >> 8) & 0xFF)
+      result.push(bits & 0xFF)
+    }
+
+    bits = (bits << 6) | map.indexOf(input.charAt(idx))
+  }
+
+  // Dump tail
+
+  const tailbits = (max % 4) * 6
+
+  if (tailbits === 0) {
+    result.push((bits >> 16) & 0xFF)
+    result.push((bits >> 8) & 0xFF)
+    result.push(bits & 0xFF)
+  } else if (tailbits === 18) {
+    result.push((bits >> 10) & 0xFF)
+    result.push((bits >> 2) & 0xFF)
+  } else if (tailbits === 12) {
+    result.push((bits >> 4) & 0xFF)
+  }
+
+  return new Uint8Array(result)
+}
+
+function representYamlBinary (object /*, style */) {
+  let result = ''
+  let bits = 0
+  const max = object.length
+  const map = BASE64_MAP
+
+  // Convert every three bytes to 4 ASCII characters.
+
+  for (let idx = 0; idx < max; idx++) {
+    if ((idx % 3 === 0) && idx) {
+      result += map[(bits >> 18) & 0x3F]
+      result += map[(bits >> 12) & 0x3F]
+      result += map[(bits >> 6) & 0x3F]
+      result += map[bits & 0x3F]
+    }
+
+    bits = (bits << 8) + object[idx]
+  }
+
+  // Dump tail
+
+  const tail = max % 3
+
+  if (tail === 0) {
+    result += map[(bits >> 18) & 0x3F]
+    result += map[(bits >> 12) & 0x3F]
+    result += map[(bits >> 6) & 0x3F]
+    result += map[bits & 0x3F]
+  } else if (tail === 2) {
+    result += map[(bits >> 10) & 0x3F]
+    result += map[(bits >> 4) & 0x3F]
+    result += map[(bits << 2) & 0x3F]
+    result += map[64]
+  } else if (tail === 1) {
+    result += map[(bits >> 2) & 0x3F]
+    result += map[(bits << 4) & 0x3F]
+    result += map[64]
+    result += map[64]
+  }
+
+  return result
+}
+
+function isBinary (obj) {
+  return Object.prototype.toString.call(obj) === '[object Uint8Array]'
+}
+
+module.exports = new Type('tag:yaml.org,2002:binary', {
+  kind: 'scalar',
+  resolve: resolveYamlBinary,
+  construct: constructYamlBinary,
+  predicate: isBinary,
+  represent: representYamlBinary
+})

package/node_modules/js-yaml/lib/type/bool.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const Type = require('../type')
+
+function resolveYamlBoolean (data) {
+  if (data === null) return false
+
+  const max = data.length
+
+  return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) ||
+         (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'))
+}
+
+function constructYamlBoolean (data) {
+  return data === 'true' ||
+         data === 'True' ||
+         data === 'TRUE'
+}
+
+function isBoolean (object) {
+  return Object.prototype.toString.call(object) === '[object Boolean]'
+}
+
+module.exports = new Type('tag:yaml.org,2002:bool', {
+  kind: 'scalar',
+  resolve: resolveYamlBoolean,
+  construct: constructYamlBoolean,
+  predicate: isBoolean,
+  represent: {
+    lowercase: function (object) { return object ? 'true' : 'false' },
+    uppercase: function (object) { return object ? 'TRUE' : 'FALSE' },
+    camelcase: function (object) { return object ? 'True' : 'False' }
+  },
+  defaultStyle: 'lowercase'
+})

package/node_modules/js-yaml/lib/type/float.js

@@ -0,0 +1,99 @@
+'use strict'
+
+const common = require('../common')
+const Type = require('../type')
+
+const YAML_FLOAT_PATTERN = new RegExp(
+  // 2.5e4, 2.5 and integers
+  '^(?:[-+]?(?:[0-9]+)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?' +
+  // .2e4, .2
+  // special case, seems not from spec
+  '|\\.[0-9]+(?:[eE][-+]?[0-9]+)?' +
+  // .inf
+  '|[-+]?\\.(?:inf|Inf|INF)' +
+  // .nan
+  '|\\.(?:nan|NaN|NAN))$')
+
+const YAML_FLOAT_SPECIAL_PATTERN = new RegExp(
+  '^(?:' +
+  // .inf
+  '[-+]?\\.(?:inf|Inf|INF)' +
+  // .nan
+  '|\\.(?:nan|NaN|NAN))$')
+
+function resolveYamlFloat (data) {
+  if (data === null) return false
+
+  if (!YAML_FLOAT_PATTERN.test(data)) {
+    return false
+  }
+
+  if (isFinite(parseFloat(data, 10))) {
+    return true
+  }
+
+  return YAML_FLOAT_SPECIAL_PATTERN.test(data)
+}
+
+function constructYamlFloat (data) {
+  let value = data.toLowerCase()
+  const sign = value[0] === '-' ? -1 : 1
+
+  if ('+-'.indexOf(value[0]) >= 0) {
+    value = value.slice(1)
+  }
+
+  if (value === '.inf') {
+    return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY
+  } else if (value === '.nan') {
+    return NaN
+  }
+  return sign * parseFloat(value, 10)
+}
+
+const SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/
+
+function representYamlFloat (object, style) {
+  if (isNaN(object)) {
+    switch (style) {
+      case 'lowercase': return '.nan'
+      case 'uppercase': return '.NAN'
+      case 'camelcase': return '.NaN'
+    }
+  } else if (Number.POSITIVE_INFINITY === object) {
+    switch (style) {
+      case 'lowercase': return '.inf'
+      case 'uppercase': return '.INF'
+      case 'camelcase': return '.Inf'
+    }
+  } else if (Number.NEGATIVE_INFINITY === object) {
+    switch (style) {
+      case 'lowercase': return '-.inf'
+      case 'uppercase': return '-.INF'
+      case 'camelcase': return '-.Inf'
+    }
+  } else if (common.isNegativeZero(object)) {
+    return '-0.0'
+  }
+
+  const res = object.toString(10)
+
+  // JS stringifier can build scientific format without dots: 5e-100,
+  // while YAML requres dot: 5.e-100. Fix it with simple hack
+
+  return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res
+}
+
+function isFloat (object) {
+  return (Object.prototype.toString.call(object) === '[object Number]') &&
+         (object % 1 !== 0 || common.isNegativeZero(object))
+}
+
+module.exports = new Type('tag:yaml.org,2002:float', {
+  kind: 'scalar',
+  resolve: resolveYamlFloat,
+  construct: constructYamlFloat,
+  predicate: isFloat,
+  represent: representYamlFloat,
+  defaultStyle: 'lowercase'
+})

package/node_modules/js-yaml/lib/type/int.js

@@ -0,0 +1,142 @@
+'use strict'
+
+const common = require('../common')
+const Type = require('../type')
+
+function isHexCode (c) {
+  return ((c >= 0x30/* 0 */) && (c <= 0x39/* 9 */)) ||
+         ((c >= 0x41/* A */) && (c <= 0x46/* F */)) ||
+         ((c >= 0x61/* a */) && (c <= 0x66/* f */))
+}
+
+function isOctCode (c) {
+  return ((c >= 0x30/* 0 */) && (c <= 0x37/* 7 */))
+}
+
+function isDecCode (c) {
+  return ((c >= 0x30/* 0 */) && (c <= 0x39/* 9 */))
+}
+
+function resolveYamlInteger (data) {
+  if (data === null) return false
+
+  const max = data.length
+  let index = 0
+  let hasDigits = false
+
+  if (!max) return false
+
+  let ch = data[index]
+
+  // sign
+  if (ch === '-' || ch === '+') {
+    ch = data[++index]
+  }
+
+  if (ch === '0') {
+    // 0
+    if (index + 1 === max) return true
+    ch = data[++index]
+
+    // base 2, base 8, base 16
+
+    if (ch === 'b') {
+      // base 2
+      index++
+
+      for (; index < max; index++) {
+        ch = data[index]
+        if (ch !== '0' && ch !== '1') return false
+        hasDigits = true
+      }
+      return hasDigits && isFinite(parseYamlInteger(data))
+    }
+
+    if (ch === 'x') {
+      // base 16
+      index++
+
+      for (; index < max; index++) {
+        if (!isHexCode(data.charCodeAt(index))) return false
+        hasDigits = true
+      }
+      return hasDigits && isFinite(parseYamlInteger(data))
+    }
+
+    if (ch === 'o') {
+      // base 8
+      index++
+
+      for (; index < max; index++) {
+        if (!isOctCode(data.charCodeAt(index))) return false
+        hasDigits = true
+      }
+      return hasDigits && isFinite(parseYamlInteger(data))
+    }
+  }
+
+  // base 10 (except 0)
+
+  for (; index < max; index++) {
+    if (!isDecCode(data.charCodeAt(index))) {
+      return false
+    }
+    hasDigits = true
+  }
+
+  if (!hasDigits) return false
+
+  return isFinite(parseYamlInteger(data))
+}
+
+function parseYamlInteger (data) {
+  let value = data
+  let sign = 1
+
+  let ch = value[0]
+
+  if (ch === '-' || ch === '+') {
+    if (ch === '-') sign = -1
+    value = value.slice(1)
+    ch = value[0]
+  }
+
+  if (value === '0') return 0
+
+  if (ch === '0') {
+    if (value[1] === 'b') return sign * parseInt(value.slice(2), 2)
+    if (value[1] === 'x') return sign * parseInt(value.slice(2), 16)
+    if (value[1] === 'o') return sign * parseInt(value.slice(2), 8)
+  }
+
+  return sign * parseInt(value, 10)
+}
+
+function constructYamlInteger (data) {
+  return parseYamlInteger(data)
+}
+
+function isInteger (object) {
+  return (Object.prototype.toString.call(object)) === '[object Number]' &&
+         (object % 1 === 0 && !common.isNegativeZero(object))
+}
+
+module.exports = new Type('tag:yaml.org,2002:int', {
+  kind: 'scalar',
+  resolve: resolveYamlInteger,
+  construct: constructYamlInteger,
+  predicate: isInteger,
+  represent: {
+    binary: function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1) },
+    octal: function (obj) { return obj >= 0 ? '0o' + obj.toString(8) : '-0o' + obj.toString(8).slice(1) },
+    decimal: function (obj) { return obj.toString(10) },
+    hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() : '-0x' + obj.toString(16).toUpperCase().slice(1) }
+  },
+  defaultStyle: 'decimal',
+  styleAliases: {
+    binary: [2, 'bin'],
+    octal: [8, 'oct'],
+    decimal: [10, 'dec'],
+    hexadecimal: [16, 'hex']
+  }
+})

package/node_modules/js-yaml/lib/type/map.js

@@ -0,0 +1,8 @@
+'use strict'
+
+const Type = require('../type')
+
+module.exports = new Type('tag:yaml.org,2002:map', {
+  kind: 'mapping',
+  construct: function (data) { return data !== null ? data : {} }
+})

package/node_modules/js-yaml/lib/type/merge.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const Type = require('../type')
+
+function resolveYamlMerge (data) {
+  return data === '<<' || data === null
+}
+
+module.exports = new Type('tag:yaml.org,2002:merge', {
+  kind: 'scalar',
+  resolve: resolveYamlMerge
+})