2060 lines
58 KiB
JavaScript
2060 lines
58 KiB
JavaScript
layui.define(['jquery', 'element'], function(exports) {
|
|
"use strict";
|
|
|
|
var MOD_NAME = 'yaml',
|
|
$ = layui.jquery,
|
|
element = layui.element;
|
|
|
|
var yaml = new function() {
|
|
this.parse = function(str){
|
|
return YAML.parse(yamlString);
|
|
}
|
|
this.load = function(path){
|
|
return YAML.load(path);
|
|
}
|
|
}
|
|
exports(MOD_NAME, yaml);
|
|
});
|
|
|
|
|
|
(function() {
|
|
function r(e, n, t) {
|
|
function o(i, f) {
|
|
if (!n[i]) {
|
|
if (!e[i]) {
|
|
var c = "function" == typeof require && require;
|
|
if (!f && c) return c(i, !0);
|
|
if (u) return u(i, !0);
|
|
var a = new Error("Cannot find module '" + i + "'");
|
|
throw a.code = "MODULE_NOT_FOUND", a
|
|
}
|
|
var p = n[i] = {
|
|
exports: {}
|
|
};
|
|
e[i][0].call(p.exports, function(r) {
|
|
var n = e[i][1][r];
|
|
return o(n || r)
|
|
}, p, p.exports, r, e, n, t)
|
|
}
|
|
return n[i].exports
|
|
}
|
|
for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) o(t[i]);
|
|
return o
|
|
}
|
|
return r
|
|
})()({
|
|
1: [function(require, module, exports) {
|
|
var Dumper, Inline, Utils;
|
|
|
|
Utils = require('./Utils');
|
|
|
|
Inline = require('./Inline');
|
|
|
|
Dumper = (function() {
|
|
function Dumper() {}
|
|
|
|
Dumper.indentation = 4;
|
|
|
|
Dumper.prototype.dump = function(input, inline, indent, exceptionOnInvalidType, objectEncoder) {
|
|
var i, key, len, output, prefix, value, willBeInlined;
|
|
if (inline == null) {
|
|
inline = 0;
|
|
}
|
|
if (indent == null) {
|
|
indent = 0;
|
|
}
|
|
if (exceptionOnInvalidType == null) {
|
|
exceptionOnInvalidType = false;
|
|
}
|
|
if (objectEncoder == null) {
|
|
objectEncoder = null;
|
|
}
|
|
output = '';
|
|
if (typeof input === 'function') {
|
|
return output;
|
|
}
|
|
prefix = (indent ? Utils.strRepeat(' ', indent) : '');
|
|
if (inline <= 0 || typeof input !== 'object' || input instanceof Date || Utils.isEmpty(input)) {
|
|
output += prefix + Inline.dump(input, exceptionOnInvalidType, objectEncoder);
|
|
} else {
|
|
if (input instanceof Array) {
|
|
for (i = 0, len = input.length; i < len; i++) {
|
|
value = input[i];
|
|
willBeInlined = inline - 1 <= 0 || typeof value !== 'object' || Utils.isEmpty(value);
|
|
output += prefix + '-' + (willBeInlined ? ' ' : "\n") + this.dump(value, inline - 1, (willBeInlined ? 0 :
|
|
indent + this.indentation), exceptionOnInvalidType, objectEncoder) + (willBeInlined ? "\n" : '');
|
|
}
|
|
} else {
|
|
for (key in input) {
|
|
value = input[key];
|
|
willBeInlined = inline - 1 <= 0 || typeof value !== 'object' || Utils.isEmpty(value);
|
|
output += prefix + Inline.dump(key, exceptionOnInvalidType, objectEncoder) + ':' + (willBeInlined ? ' ' :
|
|
"\n") + this.dump(value, inline - 1, (willBeInlined ? 0 : indent + this.indentation),
|
|
exceptionOnInvalidType, objectEncoder) + (willBeInlined ? "\n" : '');
|
|
}
|
|
}
|
|
}
|
|
return output;
|
|
};
|
|
|
|
return Dumper;
|
|
|
|
})();
|
|
|
|
module.exports = Dumper;
|
|
|
|
|
|
}, {
|
|
"./Inline": 6,
|
|
"./Utils": 10
|
|
}],
|
|
2: [function(require, module, exports) {
|
|
var Escaper, Pattern;
|
|
|
|
Pattern = require('./Pattern');
|
|
|
|
Escaper = (function() {
|
|
var ch;
|
|
|
|
function Escaper() {}
|
|
|
|
Escaper.LIST_ESCAPEES = ['\\', '\\\\', '\\"', '"', "\x00", "\x01", "\x02", "\x03", "\x04", "\x05", "\x06",
|
|
"\x07", "\x08", "\x09", "\x0a", "\x0b", "\x0c", "\x0d", "\x0e", "\x0f", "\x10", "\x11", "\x12", "\x13",
|
|
"\x14", "\x15", "\x16", "\x17", "\x18", "\x19", "\x1a", "\x1b", "\x1c", "\x1d", "\x1e", "\x1f", (ch = String.fromCharCode)
|
|
(0x0085), ch(0x00A0), ch(0x2028), ch(0x2029)
|
|
];
|
|
|
|
Escaper.LIST_ESCAPED = ['\\\\', '\\"', '\\"', '\\"', "\\0", "\\x01", "\\x02", "\\x03", "\\x04", "\\x05",
|
|
"\\x06", "\\a", "\\b", "\\t", "\\n", "\\v", "\\f", "\\r", "\\x0e", "\\x0f", "\\x10", "\\x11", "\\x12",
|
|
"\\x13", "\\x14", "\\x15", "\\x16", "\\x17", "\\x18", "\\x19", "\\x1a", "\\e", "\\x1c", "\\x1d", "\\x1e",
|
|
"\\x1f", "\\N", "\\_", "\\L", "\\P"
|
|
];
|
|
|
|
Escaper.MAPPING_ESCAPEES_TO_ESCAPED = (function() {
|
|
var i, j, mapping, ref;
|
|
mapping = {};
|
|
for (i = j = 0, ref = Escaper.LIST_ESCAPEES.length; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) {
|
|
mapping[Escaper.LIST_ESCAPEES[i]] = Escaper.LIST_ESCAPED[i];
|
|
}
|
|
return mapping;
|
|
})();
|
|
|
|
Escaper.PATTERN_CHARACTERS_TO_ESCAPE = new Pattern('[\\x00-\\x1f]|\xc2\x85|\xc2\xa0|\xe2\x80\xa8|\xe2\x80\xa9');
|
|
|
|
Escaper.PATTERN_MAPPING_ESCAPEES = new Pattern(Escaper.LIST_ESCAPEES.join('|').split('\\').join('\\\\'));
|
|
|
|
Escaper.PATTERN_SINGLE_QUOTING = new Pattern('[\\s\'":{}[\\],&*#?]|^[-?|<>=!%@`]');
|
|
|
|
Escaper.requiresDoubleQuoting = function(value) {
|
|
return this.PATTERN_CHARACTERS_TO_ESCAPE.test(value);
|
|
};
|
|
|
|
Escaper.escapeWithDoubleQuotes = function(value) {
|
|
var result;
|
|
result = this.PATTERN_MAPPING_ESCAPEES.replace(value, (function(_this) {
|
|
return function(str) {
|
|
return _this.MAPPING_ESCAPEES_TO_ESCAPED[str];
|
|
};
|
|
})(this));
|
|
return '"' + result + '"';
|
|
};
|
|
|
|
Escaper.requiresSingleQuoting = function(value) {
|
|
return this.PATTERN_SINGLE_QUOTING.test(value);
|
|
};
|
|
|
|
Escaper.escapeWithSingleQuotes = function(value) {
|
|
return "'" + value.replace(/'/g, "''") + "'";
|
|
};
|
|
|
|
return Escaper;
|
|
|
|
})();
|
|
|
|
module.exports = Escaper;
|
|
|
|
|
|
}, {
|
|
"./Pattern": 8
|
|
}],
|
|
3: [function(require, module, exports) {
|
|
var DumpException,
|
|
extend = function(child, parent) {
|
|
for (var key in parent) {
|
|
if (hasProp.call(parent, key)) child[key] = parent[key];
|
|
}
|
|
|
|
function ctor() {
|
|
this.constructor = child;
|
|
}
|
|
ctor.prototype = parent.prototype;
|
|
child.prototype = new ctor();
|
|
child.__super__ = parent.prototype;
|
|
return child;
|
|
},
|
|
hasProp = {}.hasOwnProperty;
|
|
|
|
DumpException = (function(superClass) {
|
|
extend(DumpException, superClass);
|
|
|
|
function DumpException(message, parsedLine, snippet) {
|
|
DumpException.__super__.constructor.call(this, message);
|
|
this.message = message;
|
|
this.parsedLine = parsedLine;
|
|
this.snippet = snippet;
|
|
}
|
|
|
|
DumpException.prototype.toString = function() {
|
|
if ((this.parsedLine != null) && (this.snippet != null)) {
|
|
return '<DumpException> ' + this.message + ' (line ' + this.parsedLine + ': \'' + this.snippet + '\')';
|
|
} else {
|
|
return '<DumpException> ' + this.message;
|
|
}
|
|
};
|
|
|
|
return DumpException;
|
|
|
|
})(Error);
|
|
|
|
module.exports = DumpException;
|
|
|
|
|
|
}, {}],
|
|
4: [function(require, module, exports) {
|
|
var ParseException,
|
|
extend = function(child, parent) {
|
|
for (var key in parent) {
|
|
if (hasProp.call(parent, key)) child[key] = parent[key];
|
|
}
|
|
|
|
function ctor() {
|
|
this.constructor = child;
|
|
}
|
|
ctor.prototype = parent.prototype;
|
|
child.prototype = new ctor();
|
|
child.__super__ = parent.prototype;
|
|
return child;
|
|
},
|
|
hasProp = {}.hasOwnProperty;
|
|
|
|
ParseException = (function(superClass) {
|
|
extend(ParseException, superClass);
|
|
|
|
function ParseException(message, parsedLine, snippet) {
|
|
ParseException.__super__.constructor.call(this, message);
|
|
this.message = message;
|
|
this.parsedLine = parsedLine;
|
|
this.snippet = snippet;
|
|
}
|
|
|
|
ParseException.prototype.toString = function() {
|
|
if ((this.parsedLine != null) && (this.snippet != null)) {
|
|
return '<ParseException> ' + this.message + ' (line ' + this.parsedLine + ': \'' + this.snippet + '\')';
|
|
} else {
|
|
return '<ParseException> ' + this.message;
|
|
}
|
|
};
|
|
|
|
return ParseException;
|
|
|
|
})(Error);
|
|
|
|
module.exports = ParseException;
|
|
|
|
|
|
}, {}],
|
|
5: [function(require, module, exports) {
|
|
var ParseMore,
|
|
extend = function(child, parent) {
|
|
for (var key in parent) {
|
|
if (hasProp.call(parent, key)) child[key] = parent[key];
|
|
}
|
|
|
|
function ctor() {
|
|
this.constructor = child;
|
|
}
|
|
ctor.prototype = parent.prototype;
|
|
child.prototype = new ctor();
|
|
child.__super__ = parent.prototype;
|
|
return child;
|
|
},
|
|
hasProp = {}.hasOwnProperty;
|
|
|
|
ParseMore = (function(superClass) {
|
|
extend(ParseMore, superClass);
|
|
|
|
function ParseMore(message, parsedLine, snippet) {
|
|
ParseMore.__super__.constructor.call(this, message);
|
|
this.message = message;
|
|
this.parsedLine = parsedLine;
|
|
this.snippet = snippet;
|
|
}
|
|
|
|
ParseMore.prototype.toString = function() {
|
|
if ((this.parsedLine != null) && (this.snippet != null)) {
|
|
return '<ParseMore> ' + this.message + ' (line ' + this.parsedLine + ': \'' + this.snippet + '\')';
|
|
} else {
|
|
return '<ParseMore> ' + this.message;
|
|
}
|
|
};
|
|
|
|
return ParseMore;
|
|
|
|
})(Error);
|
|
|
|
module.exports = ParseMore;
|
|
|
|
|
|
}, {}],
|
|
6: [function(require, module, exports) {
|
|
var DumpException, Escaper, Inline, ParseException, ParseMore, Pattern, Unescaper, Utils,
|
|
indexOf = [].indexOf || function(item) {
|
|
for (var i = 0, l = this.length; i < l; i++) {
|
|
if (i in this && this[i] === item) return i;
|
|
}
|
|
return -1;
|
|
};
|
|
|
|
Pattern = require('./Pattern');
|
|
|
|
Unescaper = require('./Unescaper');
|
|
|
|
Escaper = require('./Escaper');
|
|
|
|
Utils = require('./Utils');
|
|
|
|
ParseException = require('./Exception/ParseException');
|
|
|
|
ParseMore = require('./Exception/ParseMore');
|
|
|
|
DumpException = require('./Exception/DumpException');
|
|
|
|
Inline = (function() {
|
|
function Inline() {}
|
|
|
|
Inline.REGEX_QUOTED_STRING = '(?:"(?:[^"\\\\]*(?:\\\\.[^"\\\\]*)*)"|\'(?:[^\']*(?:\'\'[^\']*)*)\')';
|
|
|
|
Inline.PATTERN_TRAILING_COMMENTS = new Pattern('^\\s*#.*$');
|
|
|
|
Inline.PATTERN_QUOTED_SCALAR = new Pattern('^' + Inline.REGEX_QUOTED_STRING);
|
|
|
|
Inline.PATTERN_THOUSAND_NUMERIC_SCALAR = new Pattern('^(-|\\+)?[0-9,]+(\\.[0-9]+)?$');
|
|
|
|
Inline.PATTERN_SCALAR_BY_DELIMITERS = {};
|
|
|
|
Inline.settings = {};
|
|
|
|
Inline.configure = function(exceptionOnInvalidType, objectDecoder) {
|
|
if (exceptionOnInvalidType == null) {
|
|
exceptionOnInvalidType = null;
|
|
}
|
|
if (objectDecoder == null) {
|
|
objectDecoder = null;
|
|
}
|
|
this.settings.exceptionOnInvalidType = exceptionOnInvalidType;
|
|
this.settings.objectDecoder = objectDecoder;
|
|
};
|
|
|
|
Inline.parse = function(value, exceptionOnInvalidType, objectDecoder) {
|
|
var context, result;
|
|
if (exceptionOnInvalidType == null) {
|
|
exceptionOnInvalidType = false;
|
|
}
|
|
if (objectDecoder == null) {
|
|
objectDecoder = null;
|
|
}
|
|
this.settings.exceptionOnInvalidType = exceptionOnInvalidType;
|
|
this.settings.objectDecoder = objectDecoder;
|
|
if (value == null) {
|
|
return '';
|
|
}
|
|
value = Utils.trim(value);
|
|
if (0 === value.length) {
|
|
return '';
|
|
}
|
|
context = {
|
|
exceptionOnInvalidType: exceptionOnInvalidType,
|
|
objectDecoder: objectDecoder,
|
|
i: 0
|
|
};
|
|
switch (value.charAt(0)) {
|
|
case '[':
|
|
result = this.parseSequence(value, context);
|
|
++context.i;
|
|
break;
|
|
case '{':
|
|
result = this.parseMapping(value, context);
|
|
++context.i;
|
|
break;
|
|
default:
|
|
result = this.parseScalar(value, null, ['"', "'"], context);
|
|
}
|
|
if (this.PATTERN_TRAILING_COMMENTS.replace(value.slice(context.i), '') !== '') {
|
|
throw new ParseException('Unexpected characters near "' + value.slice(context.i) + '".');
|
|
}
|
|
return result;
|
|
};
|
|
|
|
Inline.dump = function(value, exceptionOnInvalidType, objectEncoder) {
|
|
var ref, result, type;
|
|
if (exceptionOnInvalidType == null) {
|
|
exceptionOnInvalidType = false;
|
|
}
|
|
if (objectEncoder == null) {
|
|
objectEncoder = null;
|
|
}
|
|
if (value == null) {
|
|
return 'null';
|
|
}
|
|
type = typeof value;
|
|
if (type === 'object') {
|
|
if (value instanceof Date) {
|
|
return value.toISOString();
|
|
} else if (objectEncoder != null) {
|
|
result = objectEncoder(value);
|
|
if (typeof result === 'string' || (result != null)) {
|
|
return result;
|
|
}
|
|
}
|
|
return this.dumpObject(value);
|
|
}
|
|
if (type === 'boolean') {
|
|
return (value ? 'true' : 'false');
|
|
}
|
|
if (Utils.isDigits(value)) {
|
|
return (type === 'string' ? "'" + value + "'" : String(parseInt(value)));
|
|
}
|
|
if (Utils.isNumeric(value)) {
|
|
return (type === 'string' ? "'" + value + "'" : String(parseFloat(value)));
|
|
}
|
|
if (type === 'number') {
|
|
return (value === Infinity ? '.Inf' : (value === -Infinity ? '-.Inf' : (isNaN(value) ? '.NaN' : value)));
|
|
}
|
|
if (Escaper.requiresDoubleQuoting(value)) {
|
|
return Escaper.escapeWithDoubleQuotes(value);
|
|
}
|
|
if (Escaper.requiresSingleQuoting(value)) {
|
|
return Escaper.escapeWithSingleQuotes(value);
|
|
}
|
|
if ('' === value) {
|
|
return '""';
|
|
}
|
|
if (Utils.PATTERN_DATE.test(value)) {
|
|
return "'" + value + "'";
|
|
}
|
|
if ((ref = value.toLowerCase()) === 'null' || ref === '~' || ref === 'true' || ref === 'false') {
|
|
return "'" + value + "'";
|
|
}
|
|
return value;
|
|
};
|
|
|
|
Inline.dumpObject = function(value, exceptionOnInvalidType, objectSupport) {
|
|
var j, key, len1, output, val;
|
|
if (objectSupport == null) {
|
|
objectSupport = null;
|
|
}
|
|
if (value instanceof Array) {
|
|
output = [];
|
|
for (j = 0, len1 = value.length; j < len1; j++) {
|
|
val = value[j];
|
|
output.push(this.dump(val));
|
|
}
|
|
return '[' + output.join(', ') + ']';
|
|
} else {
|
|
output = [];
|
|
for (key in value) {
|
|
val = value[key];
|
|
output.push(this.dump(key) + ': ' + this.dump(val));
|
|
}
|
|
return '{' + output.join(', ') + '}';
|
|
}
|
|
};
|
|
|
|
Inline.parseScalar = function(scalar, delimiters, stringDelimiters, context, evaluate) {
|
|
var i, joinedDelimiters, match, output, pattern, ref, ref1, strpos, tmp;
|
|
if (delimiters == null) {
|
|
delimiters = null;
|
|
}
|
|
if (stringDelimiters == null) {
|
|
stringDelimiters = ['"', "'"];
|
|
}
|
|
if (context == null) {
|
|
context = null;
|
|
}
|
|
if (evaluate == null) {
|
|
evaluate = true;
|
|
}
|
|
if (context == null) {
|
|
context = {
|
|
exceptionOnInvalidType: this.settings.exceptionOnInvalidType,
|
|
objectDecoder: this.settings.objectDecoder,
|
|
i: 0
|
|
};
|
|
}
|
|
i = context.i;
|
|
if (ref = scalar.charAt(i), indexOf.call(stringDelimiters, ref) >= 0) {
|
|
output = this.parseQuotedScalar(scalar, context);
|
|
i = context.i;
|
|
if (delimiters != null) {
|
|
tmp = Utils.ltrim(scalar.slice(i), ' ');
|
|
if (!(ref1 = tmp.charAt(0), indexOf.call(delimiters, ref1) >= 0)) {
|
|
throw new ParseException('Unexpected characters (' + scalar.slice(i) + ').');
|
|
}
|
|
}
|
|
} else {
|
|
if (!delimiters) {
|
|
output = scalar.slice(i);
|
|
i += output.length;
|
|
strpos = output.indexOf(' #');
|
|
if (strpos !== -1) {
|
|
output = Utils.rtrim(output.slice(0, strpos));
|
|
}
|
|
} else {
|
|
joinedDelimiters = delimiters.join('|');
|
|
pattern = this.PATTERN_SCALAR_BY_DELIMITERS[joinedDelimiters];
|
|
if (pattern == null) {
|
|
pattern = new Pattern('^(.+?)(' + joinedDelimiters + ')');
|
|
this.PATTERN_SCALAR_BY_DELIMITERS[joinedDelimiters] = pattern;
|
|
}
|
|
if (match = pattern.exec(scalar.slice(i))) {
|
|
output = match[1];
|
|
i += output.length;
|
|
} else {
|
|
throw new ParseException('Malformed inline YAML string (' + scalar + ').');
|
|
}
|
|
}
|
|
if (evaluate) {
|
|
output = this.evaluateScalar(output, context);
|
|
}
|
|
}
|
|
context.i = i;
|
|
return output;
|
|
};
|
|
|
|
Inline.parseQuotedScalar = function(scalar, context) {
|
|
var i, match, output;
|
|
i = context.i;
|
|
if (!(match = this.PATTERN_QUOTED_SCALAR.exec(scalar.slice(i)))) {
|
|
throw new ParseMore('Malformed inline YAML string (' + scalar.slice(i) + ').');
|
|
}
|
|
output = match[0].substr(1, match[0].length - 2);
|
|
if ('"' === scalar.charAt(i)) {
|
|
output = Unescaper.unescapeDoubleQuotedString(output);
|
|
} else {
|
|
output = Unescaper.unescapeSingleQuotedString(output);
|
|
}
|
|
i += match[0].length;
|
|
context.i = i;
|
|
return output;
|
|
};
|
|
|
|
Inline.parseSequence = function(sequence, context) {
|
|
var e, error, i, isQuoted, len, output, ref, value;
|
|
output = [];
|
|
len = sequence.length;
|
|
i = context.i;
|
|
i += 1;
|
|
while (i < len) {
|
|
context.i = i;
|
|
switch (sequence.charAt(i)) {
|
|
case '[':
|
|
output.push(this.parseSequence(sequence, context));
|
|
i = context.i;
|
|
break;
|
|
case '{':
|
|
output.push(this.parseMapping(sequence, context));
|
|
i = context.i;
|
|
break;
|
|
case ']':
|
|
return output;
|
|
case ',':
|
|
case ' ':
|
|
case "\n":
|
|
break;
|
|
default:
|
|
isQuoted = ((ref = sequence.charAt(i)) === '"' || ref === "'");
|
|
value = this.parseScalar(sequence, [',', ']'], ['"', "'"], context);
|
|
i = context.i;
|
|
if (!isQuoted && typeof value === 'string' && (value.indexOf(': ') !== -1 || value.indexOf(":\n") !== -1)) {
|
|
try {
|
|
value = this.parseMapping('{' + value + '}');
|
|
} catch (error) {
|
|
e = error;
|
|
}
|
|
}
|
|
output.push(value);
|
|
--i;
|
|
}
|
|
++i;
|
|
}
|
|
throw new ParseMore('Malformed inline YAML string ' + sequence);
|
|
};
|
|
|
|
Inline.parseMapping = function(mapping, context) {
|
|
var done, i, key, len, output, shouldContinueWhileLoop, value;
|
|
output = {};
|
|
len = mapping.length;
|
|
i = context.i;
|
|
i += 1;
|
|
shouldContinueWhileLoop = false;
|
|
while (i < len) {
|
|
context.i = i;
|
|
switch (mapping.charAt(i)) {
|
|
case ' ':
|
|
case ',':
|
|
case "\n":
|
|
++i;
|
|
context.i = i;
|
|
shouldContinueWhileLoop = true;
|
|
break;
|
|
case '}':
|
|
return output;
|
|
}
|
|
if (shouldContinueWhileLoop) {
|
|
shouldContinueWhileLoop = false;
|
|
continue;
|
|
}
|
|
key = this.parseScalar(mapping, [':', ' ', "\n"], ['"', "'"], context, false);
|
|
i = context.i;
|
|
done = false;
|
|
while (i < len) {
|
|
context.i = i;
|
|
switch (mapping.charAt(i)) {
|
|
case '[':
|
|
value = this.parseSequence(mapping, context);
|
|
i = context.i;
|
|
if (output[key] === void 0) {
|
|
output[key] = value;
|
|
}
|
|
done = true;
|
|
break;
|
|
case '{':
|
|
value = this.parseMapping(mapping, context);
|
|
i = context.i;
|
|
if (output[key] === void 0) {
|
|
output[key] = value;
|
|
}
|
|
done = true;
|
|
break;
|
|
case ':':
|
|
case ' ':
|
|
case "\n":
|
|
break;
|
|
default:
|
|
value = this.parseScalar(mapping, [',', '}'], ['"', "'"], context);
|
|
i = context.i;
|
|
if (output[key] === void 0) {
|
|
output[key] = value;
|
|
}
|
|
done = true;
|
|
--i;
|
|
}
|
|
++i;
|
|
if (done) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
throw new ParseMore('Malformed inline YAML string ' + mapping);
|
|
};
|
|
|
|
Inline.evaluateScalar = function(scalar, context) {
|
|
var cast, date, exceptionOnInvalidType, firstChar, firstSpace, firstWord, objectDecoder, raw, scalarLower,
|
|
subValue, trimmedScalar;
|
|
scalar = Utils.trim(scalar);
|
|
scalarLower = scalar.toLowerCase();
|
|
switch (scalarLower) {
|
|
case 'null':
|
|
case '':
|
|
case '~':
|
|
return null;
|
|
case 'true':
|
|
return true;
|
|
case 'false':
|
|
return false;
|
|
case '.inf':
|
|
return Infinity;
|
|
case '.nan':
|
|
return NaN;
|
|
case '-.inf':
|
|
return Infinity;
|
|
default:
|
|
firstChar = scalarLower.charAt(0);
|
|
switch (firstChar) {
|
|
case '!':
|
|
firstSpace = scalar.indexOf(' ');
|
|
if (firstSpace === -1) {
|
|
firstWord = scalarLower;
|
|
} else {
|
|
firstWord = scalarLower.slice(0, firstSpace);
|
|
}
|
|
switch (firstWord) {
|
|
case '!':
|
|
if (firstSpace !== -1) {
|
|
return parseInt(this.parseScalar(scalar.slice(2)));
|
|
}
|
|
return null;
|
|
case '!str':
|
|
return Utils.ltrim(scalar.slice(4));
|
|
case '!!str':
|
|
return Utils.ltrim(scalar.slice(5));
|
|
case '!!int':
|
|
return parseInt(this.parseScalar(scalar.slice(5)));
|
|
case '!!bool':
|
|
return Utils.parseBoolean(this.parseScalar(scalar.slice(6)), false);
|
|
case '!!float':
|
|
return parseFloat(this.parseScalar(scalar.slice(7)));
|
|
case '!!timestamp':
|
|
return Utils.stringToDate(Utils.ltrim(scalar.slice(11)));
|
|
default:
|
|
if (context == null) {
|
|
context = {
|
|
exceptionOnInvalidType: this.settings.exceptionOnInvalidType,
|
|
objectDecoder: this.settings.objectDecoder,
|
|
i: 0
|
|
};
|
|
}
|
|
objectDecoder = context.objectDecoder, exceptionOnInvalidType = context.exceptionOnInvalidType;
|
|
if (objectDecoder) {
|
|
trimmedScalar = Utils.rtrim(scalar);
|
|
firstSpace = trimmedScalar.indexOf(' ');
|
|
if (firstSpace === -1) {
|
|
return objectDecoder(trimmedScalar, null);
|
|
} else {
|
|
subValue = Utils.ltrim(trimmedScalar.slice(firstSpace + 1));
|
|
if (!(subValue.length > 0)) {
|
|
subValue = null;
|
|
}
|
|
return objectDecoder(trimmedScalar.slice(0, firstSpace), subValue);
|
|
}
|
|
}
|
|
if (exceptionOnInvalidType) {
|
|
throw new ParseException('Custom object support when parsing a YAML file has been disabled.');
|
|
}
|
|
return null;
|
|
}
|
|
break;
|
|
case '0':
|
|
if ('0x' === scalar.slice(0, 2)) {
|
|
return Utils.hexDec(scalar);
|
|
} else if (Utils.isDigits(scalar)) {
|
|
return Utils.octDec(scalar);
|
|
} else if (Utils.isNumeric(scalar)) {
|
|
return parseFloat(scalar);
|
|
} else {
|
|
return scalar;
|
|
}
|
|
break;
|
|
case '+':
|
|
if (Utils.isDigits(scalar)) {
|
|
raw = scalar;
|
|
cast = parseInt(raw);
|
|
if (raw === String(cast)) {
|
|
return cast;
|
|
} else {
|
|
return raw;
|
|
}
|
|
} else if (Utils.isNumeric(scalar)) {
|
|
return parseFloat(scalar);
|
|
} else if (this.PATTERN_THOUSAND_NUMERIC_SCALAR.test(scalar)) {
|
|
return parseFloat(scalar.replace(',', ''));
|
|
}
|
|
return scalar;
|
|
case '-':
|
|
if (Utils.isDigits(scalar.slice(1))) {
|
|
if ('0' === scalar.charAt(1)) {
|
|
return -Utils.octDec(scalar.slice(1));
|
|
} else {
|
|
raw = scalar.slice(1);
|
|
cast = parseInt(raw);
|
|
if (raw === String(cast)) {
|
|
return -cast;
|
|
} else {
|
|
return -raw;
|
|
}
|
|
}
|
|
} else if (Utils.isNumeric(scalar)) {
|
|
return parseFloat(scalar);
|
|
} else if (this.PATTERN_THOUSAND_NUMERIC_SCALAR.test(scalar)) {
|
|
return parseFloat(scalar.replace(',', ''));
|
|
}
|
|
return scalar;
|
|
default:
|
|
if (date = Utils.stringToDate(scalar)) {
|
|
return date;
|
|
} else if (Utils.isNumeric(scalar)) {
|
|
return parseFloat(scalar);
|
|
} else if (this.PATTERN_THOUSAND_NUMERIC_SCALAR.test(scalar)) {
|
|
return parseFloat(scalar.replace(',', ''));
|
|
}
|
|
return scalar;
|
|
}
|
|
}
|
|
};
|
|
|
|
return Inline;
|
|
|
|
})();
|
|
|
|
module.exports = Inline;
|
|
|
|
|
|
}, {
|
|
"./Escaper": 2,
|
|
"./Exception/DumpException": 3,
|
|
"./Exception/ParseException": 4,
|
|
"./Exception/ParseMore": 5,
|
|
"./Pattern": 8,
|
|
"./Unescaper": 9,
|
|
"./Utils": 10
|
|
}],
|
|
7: [function(require, module, exports) {
|
|
var Inline, ParseException, ParseMore, Parser, Pattern, Utils;
|
|
|
|
Inline = require('./Inline');
|
|
|
|
Pattern = require('./Pattern');
|
|
|
|
Utils = require('./Utils');
|
|
|
|
ParseException = require('./Exception/ParseException');
|
|
|
|
ParseMore = require('./Exception/ParseMore');
|
|
|
|
Parser = (function() {
|
|
Parser.prototype.PATTERN_FOLDED_SCALAR_ALL = new Pattern(
|
|
'^(?:(?<type>![^\\|>]*)\\s+)?(?<separator>\\||>)(?<modifiers>\\+|\\-|\\d+|\\+\\d+|\\-\\d+|\\d+\\+|\\d+\\-)?(?<comments> +#.*)?$'
|
|
);
|
|
|
|
Parser.prototype.PATTERN_FOLDED_SCALAR_END = new Pattern(
|
|
'(?<separator>\\||>)(?<modifiers>\\+|\\-|\\d+|\\+\\d+|\\-\\d+|\\d+\\+|\\d+\\-)?(?<comments> +#.*)?$');
|
|
|
|
Parser.prototype.PATTERN_SEQUENCE_ITEM = new Pattern('^\\-((?<leadspaces>\\s+)(?<value>.+?))?\\s*$');
|
|
|
|
Parser.prototype.PATTERN_ANCHOR_VALUE = new Pattern('^&(?<ref>[^ ]+) *(?<value>.*)');
|
|
|
|
Parser.prototype.PATTERN_COMPACT_NOTATION = new Pattern('^(?<key>' + Inline.REGEX_QUOTED_STRING +
|
|
'|[^ \'"\\{\\[].*?) *\\:(\\s+(?<value>.+?))?\\s*$');
|
|
|
|
Parser.prototype.PATTERN_MAPPING_ITEM = new Pattern('^(?<key>' + Inline.REGEX_QUOTED_STRING +
|
|
'|[^ \'"\\[\\{].*?) *\\:(\\s+(?<value>.+?))?\\s*$');
|
|
|
|
Parser.prototype.PATTERN_DECIMAL = new Pattern('\\d+');
|
|
|
|
Parser.prototype.PATTERN_INDENT_SPACES = new Pattern('^ +');
|
|
|
|
Parser.prototype.PATTERN_TRAILING_LINES = new Pattern('(\n*)$');
|
|
|
|
Parser.prototype.PATTERN_YAML_HEADER = new Pattern('^\\%YAML[: ][\\d\\.]+.*\n', 'm');
|
|
|
|
Parser.prototype.PATTERN_LEADING_COMMENTS = new Pattern('^(\\#.*?\n)+', 'm');
|
|
|
|
Parser.prototype.PATTERN_DOCUMENT_MARKER_START = new Pattern('^\\-\\-\\-.*?\n', 'm');
|
|
|
|
Parser.prototype.PATTERN_DOCUMENT_MARKER_END = new Pattern('^\\.\\.\\.\\s*$', 'm');
|
|
|
|
Parser.prototype.PATTERN_FOLDED_SCALAR_BY_INDENTATION = {};
|
|
|
|
Parser.prototype.CONTEXT_NONE = 0;
|
|
|
|
Parser.prototype.CONTEXT_SEQUENCE = 1;
|
|
|
|
Parser.prototype.CONTEXT_MAPPING = 2;
|
|
|
|
function Parser(offset) {
|
|
this.offset = offset != null ? offset : 0;
|
|
this.lines = [];
|
|
this.currentLineNb = -1;
|
|
this.currentLine = '';
|
|
this.refs = {};
|
|
}
|
|
|
|
Parser.prototype.parse = function(value, exceptionOnInvalidType, objectDecoder) {
|
|
var alias, allowOverwrite, block, c, context, data, e, error, error1, error2, first, i, indent, isRef, j, k,
|
|
key, l, lastKey, len, len1, len2, len3, lineCount, m, matches, mergeNode, n, name, parsed, parsedItem,
|
|
parser, ref, ref1, ref2, refName, refValue, val, values;
|
|
if (exceptionOnInvalidType == null) {
|
|
exceptionOnInvalidType = false;
|
|
}
|
|
if (objectDecoder == null) {
|
|
objectDecoder = null;
|
|
}
|
|
this.currentLineNb = -1;
|
|
this.currentLine = '';
|
|
this.lines = this.cleanup(value).split("\n");
|
|
data = null;
|
|
context = this.CONTEXT_NONE;
|
|
allowOverwrite = false;
|
|
while (this.moveToNextLine()) {
|
|
if (this.isCurrentLineEmpty()) {
|
|
continue;
|
|
}
|
|
if ("\t" === this.currentLine[0]) {
|
|
throw new ParseException('A YAML file cannot contain tabs as indentation.', this.getRealCurrentLineNb() + 1,
|
|
this.currentLine);
|
|
}
|
|
isRef = mergeNode = false;
|
|
if (values = this.PATTERN_SEQUENCE_ITEM.exec(this.currentLine)) {
|
|
if (this.CONTEXT_MAPPING === context) {
|
|
throw new ParseException('You cannot define a sequence item when in a mapping');
|
|
}
|
|
context = this.CONTEXT_SEQUENCE;
|
|
if (data == null) {
|
|
data = [];
|
|
}
|
|
if ((values.value != null) && (matches = this.PATTERN_ANCHOR_VALUE.exec(values.value))) {
|
|
isRef = matches.ref;
|
|
values.value = matches.value;
|
|
}
|
|
if (!(values.value != null) || '' === Utils.trim(values.value, ' ') || Utils.ltrim(values.value, ' ').indexOf(
|
|
'#') === 0) {
|
|
if (this.currentLineNb < this.lines.length - 1 && !this.isNextLineUnIndentedCollection()) {
|
|
c = this.getRealCurrentLineNb() + 1;
|
|
parser = new Parser(c);
|
|
parser.refs = this.refs;
|
|
data.push(parser.parse(this.getNextEmbedBlock(null, true), exceptionOnInvalidType, objectDecoder));
|
|
} else {
|
|
data.push(null);
|
|
}
|
|
} else {
|
|
if (((ref = values.leadspaces) != null ? ref.length : void 0) && (matches = this.PATTERN_COMPACT_NOTATION.exec(
|
|
values.value))) {
|
|
c = this.getRealCurrentLineNb();
|
|
parser = new Parser(c);
|
|
parser.refs = this.refs;
|
|
block = values.value;
|
|
indent = this.getCurrentLineIndentation();
|
|
if (this.isNextLineIndented(false)) {
|
|
block += "\n" + this.getNextEmbedBlock(indent + values.leadspaces.length + 1, true);
|
|
}
|
|
data.push(parser.parse(block, exceptionOnInvalidType, objectDecoder));
|
|
} else {
|
|
data.push(this.parseValue(values.value, exceptionOnInvalidType, objectDecoder));
|
|
}
|
|
}
|
|
} else if ((values = this.PATTERN_MAPPING_ITEM.exec(this.currentLine)) && values.key.indexOf(' #') === -1) {
|
|
if (this.CONTEXT_SEQUENCE === context) {
|
|
throw new ParseException('You cannot define a mapping item when in a sequence');
|
|
}
|
|
context = this.CONTEXT_MAPPING;
|
|
if (data == null) {
|
|
data = {};
|
|
}
|
|
Inline.configure(exceptionOnInvalidType, objectDecoder);
|
|
try {
|
|
key = Inline.parseScalar(values.key);
|
|
} catch (error) {
|
|
e = error;
|
|
e.parsedLine = this.getRealCurrentLineNb() + 1;
|
|
e.snippet = this.currentLine;
|
|
throw e;
|
|
}
|
|
if ('<<' === key) {
|
|
mergeNode = true;
|
|
allowOverwrite = true;
|
|
if (((ref1 = values.value) != null ? ref1.indexOf('*') : void 0) === 0) {
|
|
refName = values.value.slice(1);
|
|
if (this.refs[refName] == null) {
|
|
throw new ParseException('Reference "' + refName + '" does not exist.', this.getRealCurrentLineNb() + 1,
|
|
this.currentLine);
|
|
}
|
|
refValue = this.refs[refName];
|
|
if (typeof refValue !== 'object') {
|
|
throw new ParseException('YAML merge keys used with a scalar value instead of an object.', this.getRealCurrentLineNb() +
|
|
1, this.currentLine);
|
|
}
|
|
if (refValue instanceof Array) {
|
|
for (i = j = 0, len = refValue.length; j < len; i = ++j) {
|
|
value = refValue[i];
|
|
if (data[name = String(i)] == null) {
|
|
data[name] = value;
|
|
}
|
|
}
|
|
} else {
|
|
for (key in refValue) {
|
|
value = refValue[key];
|
|
if (data[key] == null) {
|
|
data[key] = value;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if ((values.value != null) && values.value !== '') {
|
|
value = values.value;
|
|
} else {
|
|
value = this.getNextEmbedBlock();
|
|
}
|
|
c = this.getRealCurrentLineNb() + 1;
|
|
parser = new Parser(c);
|
|
parser.refs = this.refs;
|
|
parsed = parser.parse(value, exceptionOnInvalidType);
|
|
if (typeof parsed !== 'object') {
|
|
throw new ParseException('YAML merge keys used with a scalar value instead of an object.', this.getRealCurrentLineNb() +
|
|
1, this.currentLine);
|
|
}
|
|
if (parsed instanceof Array) {
|
|
for (l = 0, len1 = parsed.length; l < len1; l++) {
|
|
parsedItem = parsed[l];
|
|
if (typeof parsedItem !== 'object') {
|
|
throw new ParseException('Merge items must be objects.', this.getRealCurrentLineNb() + 1, parsedItem);
|
|
}
|
|
if (parsedItem instanceof Array) {
|
|
for (i = m = 0, len2 = parsedItem.length; m < len2; i = ++m) {
|
|
value = parsedItem[i];
|
|
k = String(i);
|
|
if (!data.hasOwnProperty(k)) {
|
|
data[k] = value;
|
|
}
|
|
}
|
|
} else {
|
|
for (key in parsedItem) {
|
|
value = parsedItem[key];
|
|
if (!data.hasOwnProperty(key)) {
|
|
data[key] = value;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for (key in parsed) {
|
|
value = parsed[key];
|
|
if (!data.hasOwnProperty(key)) {
|
|
data[key] = value;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if ((values.value != null) && (matches = this.PATTERN_ANCHOR_VALUE.exec(values.value))) {
|
|
isRef = matches.ref;
|
|
values.value = matches.value;
|
|
}
|
|
if (mergeNode) {
|
|
|
|
} else if (!(values.value != null) || '' === Utils.trim(values.value, ' ') || Utils.ltrim(values.value, ' ')
|
|
.indexOf('#') === 0) {
|
|
if (!(this.isNextLineIndented()) && !(this.isNextLineUnIndentedCollection())) {
|
|
if (allowOverwrite || data[key] === void 0) {
|
|
data[key] = null;
|
|
}
|
|
} else {
|
|
c = this.getRealCurrentLineNb() + 1;
|
|
parser = new Parser(c);
|
|
parser.refs = this.refs;
|
|
val = parser.parse(this.getNextEmbedBlock(), exceptionOnInvalidType, objectDecoder);
|
|
if (allowOverwrite || data[key] === void 0) {
|
|
data[key] = val;
|
|
}
|
|
}
|
|
} else {
|
|
val = this.parseValue(values.value, exceptionOnInvalidType, objectDecoder);
|
|
if (allowOverwrite || data[key] === void 0) {
|
|
data[key] = val;
|
|
}
|
|
}
|
|
} else {
|
|
lineCount = this.lines.length;
|
|
if (1 === lineCount || (2 === lineCount && Utils.isEmpty(this.lines[1]))) {
|
|
try {
|
|
value = Inline.parse(this.lines[0], exceptionOnInvalidType, objectDecoder);
|
|
} catch (error1) {
|
|
e = error1;
|
|
e.parsedLine = this.getRealCurrentLineNb() + 1;
|
|
e.snippet = this.currentLine;
|
|
throw e;
|
|
}
|
|
if (typeof value === 'object') {
|
|
if (value instanceof Array) {
|
|
first = value[0];
|
|
} else {
|
|
for (key in value) {
|
|
first = value[key];
|
|
break;
|
|
}
|
|
}
|
|
if (typeof first === 'string' && first.indexOf('*') === 0) {
|
|
data = [];
|
|
for (n = 0, len3 = value.length; n < len3; n++) {
|
|
alias = value[n];
|
|
data.push(this.refs[alias.slice(1)]);
|
|
}
|
|
value = data;
|
|
}
|
|
}
|
|
return value;
|
|
} else if ((ref2 = Utils.ltrim(value).charAt(0)) === '[' || ref2 === '{') {
|
|
try {
|
|
return Inline.parse(value, exceptionOnInvalidType, objectDecoder);
|
|
} catch (error2) {
|
|
e = error2;
|
|
e.parsedLine = this.getRealCurrentLineNb() + 1;
|
|
e.snippet = this.currentLine;
|
|
throw e;
|
|
}
|
|
}
|
|
throw new ParseException('Unable to parse.', this.getRealCurrentLineNb() + 1, this.currentLine);
|
|
}
|
|
if (isRef) {
|
|
if (data instanceof Array) {
|
|
this.refs[isRef] = data[data.length - 1];
|
|
} else {
|
|
lastKey = null;
|
|
for (key in data) {
|
|
lastKey = key;
|
|
}
|
|
this.refs[isRef] = data[lastKey];
|
|
}
|
|
}
|
|
}
|
|
if (Utils.isEmpty(data)) {
|
|
return null;
|
|
} else {
|
|
return data;
|
|
}
|
|
};
|
|
|
|
Parser.prototype.getRealCurrentLineNb = function() {
|
|
return this.currentLineNb + this.offset;
|
|
};
|
|
|
|
Parser.prototype.getCurrentLineIndentation = function() {
|
|
return this.currentLine.length - Utils.ltrim(this.currentLine, ' ').length;
|
|
};
|
|
|
|
Parser.prototype.getNextEmbedBlock = function(indentation, includeUnindentedCollection) {
|
|
var data, indent, isItUnindentedCollection, newIndent, removeComments, removeCommentsPattern,
|
|
unindentedEmbedBlock;
|
|
if (indentation == null) {
|
|
indentation = null;
|
|
}
|
|
if (includeUnindentedCollection == null) {
|
|
includeUnindentedCollection = false;
|
|
}
|
|
this.moveToNextLine();
|
|
if (indentation == null) {
|
|
newIndent = this.getCurrentLineIndentation();
|
|
unindentedEmbedBlock = this.isStringUnIndentedCollectionItem(this.currentLine);
|
|
if (!(this.isCurrentLineEmpty()) && 0 === newIndent && !unindentedEmbedBlock) {
|
|
throw new ParseException('Indentation problem.', this.getRealCurrentLineNb() + 1, this.currentLine);
|
|
}
|
|
} else {
|
|
newIndent = indentation;
|
|
}
|
|
data = [this.currentLine.slice(newIndent)];
|
|
if (!includeUnindentedCollection) {
|
|
isItUnindentedCollection = this.isStringUnIndentedCollectionItem(this.currentLine);
|
|
}
|
|
removeCommentsPattern = this.PATTERN_FOLDED_SCALAR_END;
|
|
removeComments = !removeCommentsPattern.test(this.currentLine);
|
|
while (this.moveToNextLine()) {
|
|
indent = this.getCurrentLineIndentation();
|
|
if (indent === newIndent) {
|
|
removeComments = !removeCommentsPattern.test(this.currentLine);
|
|
}
|
|
if (removeComments && this.isCurrentLineComment()) {
|
|
continue;
|
|
}
|
|
if (this.isCurrentLineBlank()) {
|
|
data.push(this.currentLine.slice(newIndent));
|
|
continue;
|
|
}
|
|
if (isItUnindentedCollection && !this.isStringUnIndentedCollectionItem(this.currentLine) && indent ===
|
|
newIndent) {
|
|
this.moveToPreviousLine();
|
|
break;
|
|
}
|
|
if (indent >= newIndent) {
|
|
data.push(this.currentLine.slice(newIndent));
|
|
} else if (Utils.ltrim(this.currentLine).charAt(0) === '#') {
|
|
|
|
} else if (0 === indent) {
|
|
this.moveToPreviousLine();
|
|
break;
|
|
} else {
|
|
throw new ParseException('Indentation problem.', this.getRealCurrentLineNb() + 1, this.currentLine);
|
|
}
|
|
}
|
|
return data.join("\n");
|
|
};
|
|
|
|
Parser.prototype.moveToNextLine = function() {
|
|
if (this.currentLineNb >= this.lines.length - 1) {
|
|
return false;
|
|
}
|
|
this.currentLine = this.lines[++this.currentLineNb];
|
|
return true;
|
|
};
|
|
|
|
Parser.prototype.moveToPreviousLine = function() {
|
|
this.currentLine = this.lines[--this.currentLineNb];
|
|
};
|
|
|
|
Parser.prototype.parseValue = function(value, exceptionOnInvalidType, objectDecoder) {
|
|
var e, error, foldedIndent, matches, modifiers, pos, ref, ref1, val;
|
|
if (0 === value.indexOf('*')) {
|
|
pos = value.indexOf('#');
|
|
if (pos !== -1) {
|
|
value = value.substr(1, pos - 2);
|
|
} else {
|
|
value = value.slice(1);
|
|
}
|
|
if (this.refs[value] === void 0) {
|
|
throw new ParseException('Reference "' + value + '" does not exist.', this.currentLine);
|
|
}
|
|
return this.refs[value];
|
|
}
|
|
if (matches = this.PATTERN_FOLDED_SCALAR_ALL.exec(value)) {
|
|
modifiers = (ref = matches.modifiers) != null ? ref : '';
|
|
foldedIndent = Math.abs(parseInt(modifiers));
|
|
if (isNaN(foldedIndent)) {
|
|
foldedIndent = 0;
|
|
}
|
|
val = this.parseFoldedScalar(matches.separator, this.PATTERN_DECIMAL.replace(modifiers, ''), foldedIndent);
|
|
if (matches.type != null) {
|
|
Inline.configure(exceptionOnInvalidType, objectDecoder);
|
|
return Inline.parseScalar(matches.type + ' ' + val);
|
|
} else {
|
|
return val;
|
|
}
|
|
}
|
|
if ((ref1 = value.charAt(0)) === '[' || ref1 === '{' || ref1 === '"' || ref1 === "'") {
|
|
while (true) {
|
|
try {
|
|
return Inline.parse(value, exceptionOnInvalidType, objectDecoder);
|
|
} catch (error) {
|
|
e = error;
|
|
if (e instanceof ParseMore && this.moveToNextLine()) {
|
|
value += "\n" + Utils.trim(this.currentLine, ' ');
|
|
} else {
|
|
e.parsedLine = this.getRealCurrentLineNb() + 1;
|
|
e.snippet = this.currentLine;
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (this.isNextLineIndented()) {
|
|
value += "\n" + this.getNextEmbedBlock();
|
|
}
|
|
return Inline.parse(value, exceptionOnInvalidType, objectDecoder);
|
|
}
|
|
};
|
|
|
|
Parser.prototype.parseFoldedScalar = function(separator, indicator, indentation) {
|
|
var isCurrentLineBlank, j, len, line, matches, newText, notEOF, pattern, ref, text;
|
|
if (indicator == null) {
|
|
indicator = '';
|
|
}
|
|
if (indentation == null) {
|
|
indentation = 0;
|
|
}
|
|
notEOF = this.moveToNextLine();
|
|
if (!notEOF) {
|
|
return '';
|
|
}
|
|
isCurrentLineBlank = this.isCurrentLineBlank();
|
|
text = '';
|
|
while (notEOF && isCurrentLineBlank) {
|
|
if (notEOF = this.moveToNextLine()) {
|
|
text += "\n";
|
|
isCurrentLineBlank = this.isCurrentLineBlank();
|
|
}
|
|
}
|
|
if (0 === indentation) {
|
|
if (matches = this.PATTERN_INDENT_SPACES.exec(this.currentLine)) {
|
|
indentation = matches[0].length;
|
|
}
|
|
}
|
|
if (indentation > 0) {
|
|
pattern = this.PATTERN_FOLDED_SCALAR_BY_INDENTATION[indentation];
|
|
if (pattern == null) {
|
|
pattern = new Pattern('^ {' + indentation + '}(.*)$');
|
|
Parser.prototype.PATTERN_FOLDED_SCALAR_BY_INDENTATION[indentation] = pattern;
|
|
}
|
|
while (notEOF && (isCurrentLineBlank || (matches = pattern.exec(this.currentLine)))) {
|
|
if (isCurrentLineBlank) {
|
|
text += this.currentLine.slice(indentation);
|
|
} else {
|
|
text += matches[1];
|
|
}
|
|
if (notEOF = this.moveToNextLine()) {
|
|
text += "\n";
|
|
isCurrentLineBlank = this.isCurrentLineBlank();
|
|
}
|
|
}
|
|
} else if (notEOF) {
|
|
text += "\n";
|
|
}
|
|
if (notEOF) {
|
|
this.moveToPreviousLine();
|
|
}
|
|
if ('>' === separator) {
|
|
newText = '';
|
|
ref = text.split("\n");
|
|
for (j = 0, len = ref.length; j < len; j++) {
|
|
line = ref[j];
|
|
if (line.length === 0 || line.charAt(0) === ' ') {
|
|
newText = Utils.rtrim(newText, ' ') + line + "\n";
|
|
} else {
|
|
newText += line + ' ';
|
|
}
|
|
}
|
|
text = newText;
|
|
}
|
|
if ('+' !== indicator) {
|
|
text = Utils.rtrim(text);
|
|
}
|
|
if ('' === indicator) {
|
|
text = this.PATTERN_TRAILING_LINES.replace(text, "\n");
|
|
} else if ('-' === indicator) {
|
|
text = this.PATTERN_TRAILING_LINES.replace(text, '');
|
|
}
|
|
return text;
|
|
};
|
|
|
|
Parser.prototype.isNextLineIndented = function(ignoreComments) {
|
|
var EOF, currentIndentation, ret;
|
|
if (ignoreComments == null) {
|
|
ignoreComments = true;
|
|
}
|
|
currentIndentation = this.getCurrentLineIndentation();
|
|
EOF = !this.moveToNextLine();
|
|
if (ignoreComments) {
|
|
while (!EOF && this.isCurrentLineEmpty()) {
|
|
EOF = !this.moveToNextLine();
|
|
}
|
|
} else {
|
|
while (!EOF && this.isCurrentLineBlank()) {
|
|
EOF = !this.moveToNextLine();
|
|
}
|
|
}
|
|
if (EOF) {
|
|
return false;
|
|
}
|
|
ret = false;
|
|
if (this.getCurrentLineIndentation() > currentIndentation) {
|
|
ret = true;
|
|
}
|
|
this.moveToPreviousLine();
|
|
return ret;
|
|
};
|
|
|
|
Parser.prototype.isCurrentLineEmpty = function() {
|
|
var trimmedLine;
|
|
trimmedLine = Utils.trim(this.currentLine, ' ');
|
|
return trimmedLine.length === 0 || trimmedLine.charAt(0) === '#';
|
|
};
|
|
|
|
Parser.prototype.isCurrentLineBlank = function() {
|
|
return '' === Utils.trim(this.currentLine, ' ');
|
|
};
|
|
|
|
Parser.prototype.isCurrentLineComment = function() {
|
|
var ltrimmedLine;
|
|
ltrimmedLine = Utils.ltrim(this.currentLine, ' ');
|
|
return ltrimmedLine.charAt(0) === '#';
|
|
};
|
|
|
|
Parser.prototype.cleanup = function(value) {
|
|
var count, i, indent, j, l, len, len1, line, lines, ref, ref1, ref2, smallestIndent, trimmedValue;
|
|
if (value.indexOf("\r") !== -1) {
|
|
value = value.split("\r\n").join("\n").split("\r").join("\n");
|
|
}
|
|
count = 0;
|
|
ref = this.PATTERN_YAML_HEADER.replaceAll(value, ''), value = ref[0], count = ref[1];
|
|
this.offset += count;
|
|
ref1 = this.PATTERN_LEADING_COMMENTS.replaceAll(value, '', 1), trimmedValue = ref1[0], count = ref1[1];
|
|
if (count === 1) {
|
|
this.offset += Utils.subStrCount(value, "\n") - Utils.subStrCount(trimmedValue, "\n");
|
|
value = trimmedValue;
|
|
}
|
|
ref2 = this.PATTERN_DOCUMENT_MARKER_START.replaceAll(value, '', 1), trimmedValue = ref2[0], count = ref2[1];
|
|
if (count === 1) {
|
|
this.offset += Utils.subStrCount(value, "\n") - Utils.subStrCount(trimmedValue, "\n");
|
|
value = trimmedValue;
|
|
value = this.PATTERN_DOCUMENT_MARKER_END.replace(value, '');
|
|
}
|
|
lines = value.split("\n");
|
|
smallestIndent = -1;
|
|
for (j = 0, len = lines.length; j < len; j++) {
|
|
line = lines[j];
|
|
if (Utils.trim(line, ' ').length === 0) {
|
|
continue;
|
|
}
|
|
indent = line.length - Utils.ltrim(line).length;
|
|
if (smallestIndent === -1 || indent < smallestIndent) {
|
|
smallestIndent = indent;
|
|
}
|
|
}
|
|
if (smallestIndent > 0) {
|
|
for (i = l = 0, len1 = lines.length; l < len1; i = ++l) {
|
|
line = lines[i];
|
|
lines[i] = line.slice(smallestIndent);
|
|
}
|
|
value = lines.join("\n");
|
|
}
|
|
return value;
|
|
};
|
|
|
|
Parser.prototype.isNextLineUnIndentedCollection = function(currentIndentation) {
|
|
var notEOF, ret;
|
|
if (currentIndentation == null) {
|
|
currentIndentation = null;
|
|
}
|
|
if (currentIndentation == null) {
|
|
currentIndentation = this.getCurrentLineIndentation();
|
|
}
|
|
notEOF = this.moveToNextLine();
|
|
while (notEOF && this.isCurrentLineEmpty()) {
|
|
notEOF = this.moveToNextLine();
|
|
}
|
|
if (false === notEOF) {
|
|
return false;
|
|
}
|
|
ret = false;
|
|
if (this.getCurrentLineIndentation() === currentIndentation && this.isStringUnIndentedCollectionItem(this.currentLine)) {
|
|
ret = true;
|
|
}
|
|
this.moveToPreviousLine();
|
|
return ret;
|
|
};
|
|
|
|
Parser.prototype.isStringUnIndentedCollectionItem = function() {
|
|
return this.currentLine === '-' || this.currentLine.slice(0, 2) === '- ';
|
|
};
|
|
|
|
return Parser;
|
|
|
|
})();
|
|
|
|
module.exports = Parser;
|
|
|
|
|
|
}, {
|
|
"./Exception/ParseException": 4,
|
|
"./Exception/ParseMore": 5,
|
|
"./Inline": 6,
|
|
"./Pattern": 8,
|
|
"./Utils": 10
|
|
}],
|
|
8: [function(require, module, exports) {
|
|
var Pattern;
|
|
|
|
Pattern = (function() {
|
|
Pattern.prototype.regex = null;
|
|
|
|
Pattern.prototype.rawRegex = null;
|
|
|
|
Pattern.prototype.cleanedRegex = null;
|
|
|
|
Pattern.prototype.mapping = null;
|
|
|
|
function Pattern(rawRegex, modifiers) {
|
|
var _char, capturingBracketNumber, cleanedRegex, i, len, mapping, name, part, subChar;
|
|
if (modifiers == null) {
|
|
modifiers = '';
|
|
}
|
|
cleanedRegex = '';
|
|
len = rawRegex.length;
|
|
mapping = null;
|
|
capturingBracketNumber = 0;
|
|
i = 0;
|
|
while (i < len) {
|
|
_char = rawRegex.charAt(i);
|
|
if (_char === '\\') {
|
|
cleanedRegex += rawRegex.slice(i, +(i + 1) + 1 || 9e9);
|
|
i++;
|
|
} else if (_char === '(') {
|
|
if (i < len - 2) {
|
|
part = rawRegex.slice(i, +(i + 2) + 1 || 9e9);
|
|
if (part === '(?:') {
|
|
i += 2;
|
|
cleanedRegex += part;
|
|
} else if (part === '(?<') {
|
|
capturingBracketNumber++;
|
|
i += 2;
|
|
name = '';
|
|
while (i + 1 < len) {
|
|
subChar = rawRegex.charAt(i + 1);
|
|
if (subChar === '>') {
|
|
cleanedRegex += '(';
|
|
i++;
|
|
if (name.length > 0) {
|
|
if (mapping == null) {
|
|
mapping = {};
|
|
}
|
|
mapping[name] = capturingBracketNumber;
|
|
}
|
|
break;
|
|
} else {
|
|
name += subChar;
|
|
}
|
|
i++;
|
|
}
|
|
} else {
|
|
cleanedRegex += _char;
|
|
capturingBracketNumber++;
|
|
}
|
|
} else {
|
|
cleanedRegex += _char;
|
|
}
|
|
} else {
|
|
cleanedRegex += _char;
|
|
}
|
|
i++;
|
|
}
|
|
this.rawRegex = rawRegex;
|
|
this.cleanedRegex = cleanedRegex;
|
|
this.regex = new RegExp(this.cleanedRegex, 'g' + modifiers.replace('g', ''));
|
|
this.mapping = mapping;
|
|
}
|
|
|
|
Pattern.prototype.exec = function(str) {
|
|
var index, matches, name, ref;
|
|
this.regex.lastIndex = 0;
|
|
matches = this.regex.exec(str);
|
|
if (matches == null) {
|
|
return null;
|
|
}
|
|
if (this.mapping != null) {
|
|
ref = this.mapping;
|
|
for (name in ref) {
|
|
index = ref[name];
|
|
matches[name] = matches[index];
|
|
}
|
|
}
|
|
return matches;
|
|
};
|
|
|
|
Pattern.prototype.test = function(str) {
|
|
this.regex.lastIndex = 0;
|
|
return this.regex.test(str);
|
|
};
|
|
|
|
Pattern.prototype.replace = function(str, replacement) {
|
|
this.regex.lastIndex = 0;
|
|
return str.replace(this.regex, replacement);
|
|
};
|
|
|
|
Pattern.prototype.replaceAll = function(str, replacement, limit) {
|
|
var count;
|
|
if (limit == null) {
|
|
limit = 0;
|
|
}
|
|
this.regex.lastIndex = 0;
|
|
count = 0;
|
|
while (this.regex.test(str) && (limit === 0 || count < limit)) {
|
|
this.regex.lastIndex = 0;
|
|
str = str.replace(this.regex, replacement);
|
|
count++;
|
|
}
|
|
return [str, count];
|
|
};
|
|
|
|
return Pattern;
|
|
|
|
})();
|
|
|
|
module.exports = Pattern;
|
|
|
|
|
|
}, {}],
|
|
9: [function(require, module, exports) {
|
|
var Pattern, Unescaper, Utils;
|
|
|
|
Utils = require('./Utils');
|
|
|
|
Pattern = require('./Pattern');
|
|
|
|
Unescaper = (function() {
|
|
function Unescaper() {}
|
|
|
|
Unescaper.PATTERN_ESCAPED_CHARACTER = new Pattern(
|
|
'\\\\([0abt\tnvfre "\\/\\\\N_LP]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8})');
|
|
|
|
Unescaper.unescapeSingleQuotedString = function(value) {
|
|
return value.replace(/\'\'/g, '\'');
|
|
};
|
|
|
|
Unescaper.unescapeDoubleQuotedString = function(value) {
|
|
if (this._unescapeCallback == null) {
|
|
this._unescapeCallback = (function(_this) {
|
|
return function(str) {
|
|
return _this.unescapeCharacter(str);
|
|
};
|
|
})(this);
|
|
}
|
|
return this.PATTERN_ESCAPED_CHARACTER.replace(value, this._unescapeCallback);
|
|
};
|
|
|
|
Unescaper.unescapeCharacter = function(value) {
|
|
var ch;
|
|
ch = String.fromCharCode;
|
|
switch (value.charAt(1)) {
|
|
case '0':
|
|
return ch(0);
|
|
case 'a':
|
|
return ch(7);
|
|
case 'b':
|
|
return ch(8);
|
|
case 't':
|
|
return "\t";
|
|
case "\t":
|
|
return "\t";
|
|
case 'n':
|
|
return "\n";
|
|
case 'v':
|
|
return ch(11);
|
|
case 'f':
|
|
return ch(12);
|
|
case 'r':
|
|
return ch(13);
|
|
case 'e':
|
|
return ch(27);
|
|
case ' ':
|
|
return ' ';
|
|
case '"':
|
|
return '"';
|
|
case '/':
|
|
return '/';
|
|
case '\\':
|
|
return '\\';
|
|
case 'N':
|
|
return ch(0x0085);
|
|
case '_':
|
|
return ch(0x00A0);
|
|
case 'L':
|
|
return ch(0x2028);
|
|
case 'P':
|
|
return ch(0x2029);
|
|
case 'x':
|
|
return Utils.utf8chr(Utils.hexDec(value.substr(2, 2)));
|
|
case 'u':
|
|
return Utils.utf8chr(Utils.hexDec(value.substr(2, 4)));
|
|
case 'U':
|
|
return Utils.utf8chr(Utils.hexDec(value.substr(2, 8)));
|
|
default:
|
|
return '';
|
|
}
|
|
};
|
|
|
|
return Unescaper;
|
|
|
|
})();
|
|
|
|
module.exports = Unescaper;
|
|
|
|
|
|
}, {
|
|
"./Pattern": 8,
|
|
"./Utils": 10
|
|
}],
|
|
10: [function(require, module, exports) {
|
|
var Pattern, Utils,
|
|
hasProp = {}.hasOwnProperty;
|
|
|
|
Pattern = require('./Pattern');
|
|
|
|
Utils = (function() {
|
|
function Utils() {}
|
|
|
|
Utils.REGEX_LEFT_TRIM_BY_CHAR = {};
|
|
|
|
Utils.REGEX_RIGHT_TRIM_BY_CHAR = {};
|
|
|
|
Utils.REGEX_SPACES = /\s+/g;
|
|
|
|
Utils.REGEX_DIGITS = /^\d+$/;
|
|
|
|
Utils.REGEX_OCTAL = /[^0-7]/gi;
|
|
|
|
Utils.REGEX_HEXADECIMAL = /[^a-f0-9]/gi;
|
|
|
|
Utils.PATTERN_DATE = new Pattern('^' + '(?<year>[0-9][0-9][0-9][0-9])' + '-(?<month>[0-9][0-9]?)' +
|
|
'-(?<day>[0-9][0-9]?)' + '(?:(?:[Tt]|[ \t]+)' + '(?<hour>[0-9][0-9]?)' + ':(?<minute>[0-9][0-9])' +
|
|
':(?<second>[0-9][0-9])' + '(?:\.(?<fraction>[0-9]*))?' +
|
|
'(?:[ \t]*(?<tz>Z|(?<tz_sign>[-+])(?<tz_hour>[0-9][0-9]?)' + '(?::(?<tz_minute>[0-9][0-9]))?))?)?' + '$', 'i'
|
|
);
|
|
|
|
Utils.LOCAL_TIMEZONE_OFFSET = new Date().getTimezoneOffset() * 60 * 1000;
|
|
|
|
Utils.trim = function(str, _char) {
|
|
var regexLeft, regexRight;
|
|
if (_char == null) {
|
|
_char = '\\s';
|
|
}
|
|
regexLeft = this.REGEX_LEFT_TRIM_BY_CHAR[_char];
|
|
if (regexLeft == null) {
|
|
this.REGEX_LEFT_TRIM_BY_CHAR[_char] = regexLeft = new RegExp('^' + _char + '' + _char + '*');
|
|
}
|
|
regexLeft.lastIndex = 0;
|
|
regexRight = this.REGEX_RIGHT_TRIM_BY_CHAR[_char];
|
|
if (regexRight == null) {
|
|
this.REGEX_RIGHT_TRIM_BY_CHAR[_char] = regexRight = new RegExp(_char + '' + _char + '*$');
|
|
}
|
|
regexRight.lastIndex = 0;
|
|
return str.replace(regexLeft, '').replace(regexRight, '');
|
|
};
|
|
|
|
Utils.ltrim = function(str, _char) {
|
|
var regexLeft;
|
|
if (_char == null) {
|
|
_char = '\\s';
|
|
}
|
|
regexLeft = this.REGEX_LEFT_TRIM_BY_CHAR[_char];
|
|
if (regexLeft == null) {
|
|
this.REGEX_LEFT_TRIM_BY_CHAR[_char] = regexLeft = new RegExp('^' + _char + '' + _char + '*');
|
|
}
|
|
regexLeft.lastIndex = 0;
|
|
return str.replace(regexLeft, '');
|
|
};
|
|
|
|
Utils.rtrim = function(str, _char) {
|
|
var regexRight;
|
|
if (_char == null) {
|
|
_char = '\\s';
|
|
}
|
|
regexRight = this.REGEX_RIGHT_TRIM_BY_CHAR[_char];
|
|
if (regexRight == null) {
|
|
this.REGEX_RIGHT_TRIM_BY_CHAR[_char] = regexRight = new RegExp(_char + '' + _char + '*$');
|
|
}
|
|
regexRight.lastIndex = 0;
|
|
return str.replace(regexRight, '');
|
|
};
|
|
|
|
Utils.isEmpty = function(value) {
|
|
return !value || value === '' || value === '0' || (value instanceof Array && value.length === 0) || this.isEmptyObject(
|
|
value);
|
|
};
|
|
|
|
Utils.isEmptyObject = function(value) {
|
|
var k;
|
|
return value instanceof Object && ((function() {
|
|
var results;
|
|
results = [];
|
|
for (k in value) {
|
|
if (!hasProp.call(value, k)) continue;
|
|
results.push(k);
|
|
}
|
|
return results;
|
|
})()).length === 0;
|
|
};
|
|
|
|
Utils.subStrCount = function(string, subString, start, length) {
|
|
var c, i, j, len, ref, sublen;
|
|
c = 0;
|
|
string = '' + string;
|
|
subString = '' + subString;
|
|
if (start != null) {
|
|
string = string.slice(start);
|
|
}
|
|
if (length != null) {
|
|
string = string.slice(0, length);
|
|
}
|
|
len = string.length;
|
|
sublen = subString.length;
|
|
for (i = j = 0, ref = len; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) {
|
|
if (subString === string.slice(i, sublen)) {
|
|
c++;
|
|
i += sublen - 1;
|
|
}
|
|
}
|
|
return c;
|
|
};
|
|
|
|
Utils.isDigits = function(input) {
|
|
this.REGEX_DIGITS.lastIndex = 0;
|
|
return this.REGEX_DIGITS.test(input);
|
|
};
|
|
|
|
Utils.octDec = function(input) {
|
|
this.REGEX_OCTAL.lastIndex = 0;
|
|
return parseInt((input + '').replace(this.REGEX_OCTAL, ''), 8);
|
|
};
|
|
|
|
Utils.hexDec = function(input) {
|
|
this.REGEX_HEXADECIMAL.lastIndex = 0;
|
|
input = this.trim(input);
|
|
if ((input + '').slice(0, 2) === '0x') {
|
|
input = (input + '').slice(2);
|
|
}
|
|
return parseInt((input + '').replace(this.REGEX_HEXADECIMAL, ''), 16);
|
|
};
|
|
|
|
Utils.utf8chr = function(c) {
|
|
var ch;
|
|
ch = String.fromCharCode;
|
|
if (0x80 > (c %= 0x200000)) {
|
|
return ch(c);
|
|
}
|
|
if (0x800 > c) {
|
|
return ch(0xC0 | c >> 6) + ch(0x80 | c & 0x3F);
|
|
}
|
|
if (0x10000 > c) {
|
|
return ch(0xE0 | c >> 12) + ch(0x80 | c >> 6 & 0x3F) + ch(0x80 | c & 0x3F);
|
|
}
|
|
return ch(0xF0 | c >> 18) + ch(0x80 | c >> 12 & 0x3F) + ch(0x80 | c >> 6 & 0x3F) + ch(0x80 | c & 0x3F);
|
|
};
|
|
|
|
Utils.parseBoolean = function(input, strict) {
|
|
var lowerInput;
|
|
if (strict == null) {
|
|
strict = true;
|
|
}
|
|
if (typeof input === 'string') {
|
|
lowerInput = input.toLowerCase();
|
|
if (!strict) {
|
|
if (lowerInput === 'no') {
|
|
return false;
|
|
}
|
|
}
|
|
if (lowerInput === '0') {
|
|
return false;
|
|
}
|
|
if (lowerInput === 'false') {
|
|
return false;
|
|
}
|
|
if (lowerInput === '') {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
return !!input;
|
|
};
|
|
|
|
Utils.isNumeric = function(input) {
|
|
this.REGEX_SPACES.lastIndex = 0;
|
|
return typeof input === 'number' || typeof input === 'string' && !isNaN(input) && input.replace(this.REGEX_SPACES,
|
|
'') !== '';
|
|
};
|
|
|
|
Utils.stringToDate = function(str) {
|
|
var date, day, fraction, hour, info, minute, month, second, tz_hour, tz_minute, tz_offset, year;
|
|
if (!(str != null ? str.length : void 0)) {
|
|
return null;
|
|
}
|
|
info = this.PATTERN_DATE.exec(str);
|
|
if (!info) {
|
|
return null;
|
|
}
|
|
year = parseInt(info.year, 10);
|
|
month = parseInt(info.month, 10) - 1;
|
|
day = parseInt(info.day, 10);
|
|
if (info.hour == null) {
|
|
date = new Date(Date.UTC(year, month, day));
|
|
return date;
|
|
}
|
|
hour = parseInt(info.hour, 10);
|
|
minute = parseInt(info.minute, 10);
|
|
second = parseInt(info.second, 10);
|
|
if (info.fraction != null) {
|
|
fraction = info.fraction.slice(0, 3);
|
|
while (fraction.length < 3) {
|
|
fraction += '0';
|
|
}
|
|
fraction = parseInt(fraction, 10);
|
|
} else {
|
|
fraction = 0;
|
|
}
|
|
if (info.tz != null) {
|
|
tz_hour = parseInt(info.tz_hour, 10);
|
|
if (info.tz_minute != null) {
|
|
tz_minute = parseInt(info.tz_minute, 10);
|
|
} else {
|
|
tz_minute = 0;
|
|
}
|
|
tz_offset = (tz_hour * 60 + tz_minute) * 60000;
|
|
if ('-' === info.tz_sign) {
|
|
tz_offset *= -1;
|
|
}
|
|
}
|
|
date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
|
|
if (tz_offset) {
|
|
date.setTime(date.getTime() - tz_offset);
|
|
}
|
|
return date;
|
|
};
|
|
|
|
Utils.strRepeat = function(str, number) {
|
|
var i, res;
|
|
res = '';
|
|
i = 0;
|
|
while (i < number) {
|
|
res += str;
|
|
i++;
|
|
}
|
|
return res;
|
|
};
|
|
|
|
Utils.getStringFromFile = function(path, callback) {
|
|
var data, fs, j, len1, name, ref, req, xhr;
|
|
if (callback == null) {
|
|
callback = null;
|
|
}
|
|
xhr = null;
|
|
if (typeof window !== "undefined" && window !== null) {
|
|
if (window.XMLHttpRequest) {
|
|
xhr = new XMLHttpRequest();
|
|
} else if (window.ActiveXObject) {
|
|
ref = ["Msxml2.XMLHTTP.6.0", "Msxml2.XMLHTTP.3.0", "Msxml2.XMLHTTP", "Microsoft.XMLHTTP"];
|
|
for (j = 0, len1 = ref.length; j < len1; j++) {
|
|
name = ref[j];
|
|
try {
|
|
xhr = new ActiveXObject(name);
|
|
} catch (undefined) {}
|
|
}
|
|
}
|
|
}
|
|
if (xhr != null) {
|
|
if (callback != null) {
|
|
xhr.onreadystatechange = function() {
|
|
if (xhr.readyState === 4) {
|
|
if (xhr.status === 200 || xhr.status === 0) {
|
|
return callback(xhr.responseText);
|
|
} else {
|
|
return callback(null);
|
|
}
|
|
}
|
|
};
|
|
xhr.open('GET', path, true);
|
|
return xhr.send(null);
|
|
} else {
|
|
xhr.open('GET', path, false);
|
|
xhr.send(null);
|
|
if (xhr.status === 200 || xhr.status === 0) {
|
|
return xhr.responseText;
|
|
}
|
|
return null;
|
|
}
|
|
} else {
|
|
req = require;
|
|
fs = req('fs');
|
|
if (callback != null) {
|
|
return fs.readFile(path, function(err, data) {
|
|
if (err) {
|
|
return callback(null);
|
|
} else {
|
|
return callback(String(data));
|
|
}
|
|
});
|
|
} else {
|
|
data = fs.readFileSync(path);
|
|
if (data != null) {
|
|
return String(data);
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
};
|
|
|
|
return Utils;
|
|
|
|
})();
|
|
|
|
module.exports = Utils;
|
|
|
|
|
|
}, {
|
|
"./Pattern": 8
|
|
}],
|
|
11: [function(require, module, exports) {
|
|
var Dumper, Parser, Utils, Yaml;
|
|
|
|
Parser = require('./Parser');
|
|
|
|
Dumper = require('./Dumper');
|
|
|
|
Utils = require('./Utils');
|
|
|
|
Yaml = (function() {
|
|
function Yaml() {}
|
|
|
|
Yaml.parse = function(input, exceptionOnInvalidType, objectDecoder) {
|
|
if (exceptionOnInvalidType == null) {
|
|
exceptionOnInvalidType = false;
|
|
}
|
|
if (objectDecoder == null) {
|
|
objectDecoder = null;
|
|
}
|
|
return new Parser().parse(input, exceptionOnInvalidType, objectDecoder);
|
|
};
|
|
|
|
Yaml.parseFile = function(path, callback, exceptionOnInvalidType, objectDecoder) {
|
|
var input;
|
|
if (callback == null) {
|
|
callback = null;
|
|
}
|
|
if (exceptionOnInvalidType == null) {
|
|
exceptionOnInvalidType = false;
|
|
}
|
|
if (objectDecoder == null) {
|
|
objectDecoder = null;
|
|
}
|
|
if (callback != null) {
|
|
return Utils.getStringFromFile(path, (function(_this) {
|
|
return function(input) {
|
|
var result;
|
|
result = null;
|
|
if (input != null) {
|
|
result = _this.parse(input, exceptionOnInvalidType, objectDecoder);
|
|
}
|
|
callback(result);
|
|
};
|
|
})(this));
|
|
} else {
|
|
input = Utils.getStringFromFile(path);
|
|
if (input != null) {
|
|
return this.parse(input, exceptionOnInvalidType, objectDecoder);
|
|
}
|
|
return null;
|
|
}
|
|
};
|
|
|
|
Yaml.dump = function(input, inline, indent, exceptionOnInvalidType, objectEncoder) {
|
|
var yaml;
|
|
if (inline == null) {
|
|
inline = 2;
|
|
}
|
|
if (indent == null) {
|
|
indent = 4;
|
|
}
|
|
if (exceptionOnInvalidType == null) {
|
|
exceptionOnInvalidType = false;
|
|
}
|
|
if (objectEncoder == null) {
|
|
objectEncoder = null;
|
|
}
|
|
yaml = new Dumper();
|
|
yaml.indentation = indent;
|
|
return yaml.dump(input, inline, 0, exceptionOnInvalidType, objectEncoder);
|
|
};
|
|
|
|
Yaml.stringify = function(input, inline, indent, exceptionOnInvalidType, objectEncoder) {
|
|
return this.dump(input, inline, indent, exceptionOnInvalidType, objectEncoder);
|
|
};
|
|
|
|
Yaml.load = function(path, callback, exceptionOnInvalidType, objectDecoder) {
|
|
return this.parseFile(path, callback, exceptionOnInvalidType, objectDecoder);
|
|
};
|
|
|
|
return Yaml;
|
|
|
|
})();
|
|
|
|
if (typeof window !== "undefined" && window !== null) {
|
|
window.YAML = Yaml;
|
|
}
|
|
|
|
if (typeof window === "undefined" || window === null) {
|
|
this.YAML = Yaml;
|
|
}
|
|
|
|
module.exports = Yaml;
|
|
|
|
|
|
}, {
|
|
"./Dumper": 1,
|
|
"./Parser": 7,
|
|
"./Utils": 10
|
|
}]
|
|
}, {}, [11]);
|