ACIL FM

Pilih semua

Nama	Ukuran	Aksi
schema	-	Open
type	-	Open
common.js	1.15 MB	View DL Edit
dumper.js	31.15 MB	View DL Edit
exception.js	1.27 MB	View DL Edit
loader.js	46.04 MB	View DL Edit
schema.js	3.3 MB	View DL Edit
snippet.js	3.02 MB	View DL Edit
type.js	1.81 MB	View DL Edit

Edit file: /home/benbot/bot/server/node_modules/js-yaml/lib/schema.js

'use strict';

/*eslint-disable max-len*/

var YAMLException = require('./exception');
var Type          = require('./type');

function compileList(schema, name) {
  var result = [];

schema[name].forEach(function (currentType) {
    var 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... */) {
  var result = {
        scalar: {},
        sequence: {},
        mapping: {},
        fallback: {},
        multi: {
          scalar: [],
          sequence: [],
          mapping: [],
          fallback: []
        }
      }, index, length;

for (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) {
  var implicit = [];
  var 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.');
    }
  });

var 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;

Batal

Isi Zip:

Create