%PDF-
%PDF-
Mini Shell
Mini Shell
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({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 = '';
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) {
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) {
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) {
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]);
Zerion Mini Shell 1.0