3353 lines
167 KiB
JavaScript
3353 lines
167 KiB
JavaScript
|
(function() {
|
|||
|
|
var root = this, modules, require_from, register, error;
|
|||
|
|
if (typeof global == "undefined") {
|
|||
|
|
var global;
|
|||
|
|
if (typeof window != "undefined") {
|
|||
|
|
global = window;
|
|||
|
|
} else {
|
|||
|
|
global = {};
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
modules = {};
|
|||
|
|
require_from = function(parent, from) {
|
|||
|
|
return function(name) {
|
|||
|
|
if (modules[from] && modules[from][name]) {
|
|||
|
|
modules[from][name].parent = parent;
|
|||
|
|
if (modules[from][name].initialize) {
|
|||
|
|
modules[from][name].initialize();
|
|||
|
|
}
|
|||
|
|
return modules[from][name].exports;
|
|||
|
|
} else {
|
|||
|
|
return error(name, from);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
};
|
|||
|
|
register = function(names, directory, callback) {
|
|||
|
|
var module = {
|
|||
|
|
exports: {},
|
|||
|
|
initialize: function() {
|
|||
|
|
callback.call(module.exports, global, module, module.exports, require_from(module, directory), undefined);
|
|||
|
|
delete module.initialize;
|
|||
|
|
},
|
|||
|
|
parent: null
|
|||
|
|
};
|
|||
|
|
for (var from in names) {
|
|||
|
|
modules[from] = modules[from] || {};
|
|||
|
|
for (var j in names[from]) {
|
|||
|
|
var name = names[from][j];
|
|||
|
|
modules[from][name] = module;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
error = function anonymous(name, from) {
|
|||
|
|
var message = "Warn: could not find module " + name;
|
|||
|
|
console.log(message);
|
|||
|
|
};
|
|||
|
|
register({
|
|||
|
|
"0": [ "./events" ]
|
|||
|
|
}, 0, function(global, module, exports, require, window) {
|
|||
|
|
(function() {
|
|||
|
|
var _ref, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6, __hasProp = {}.hasOwnProperty, __extends = 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;
|
|||
|
|
};
|
|||
|
|
this.Event = function() {
|
|||
|
|
function Event(start_mark, end_mark) {
|
|||
|
|
this.start_mark = start_mark;
|
|||
|
|
this.end_mark = end_mark;
|
|||
|
|
}
|
|||
|
|
return Event;
|
|||
|
|
}();
|
|||
|
|
this.NodeEvent = function(_super) {
|
|||
|
|
__extends(NodeEvent, _super);
|
|||
|
|
function NodeEvent(anchor, start_mark, end_mark) {
|
|||
|
|
this.anchor = anchor;
|
|||
|
|
this.start_mark = start_mark;
|
|||
|
|
this.end_mark = end_mark;
|
|||
|
|
}
|
|||
|
|
return NodeEvent;
|
|||
|
|
}(this.Event);
|
|||
|
|
this.CollectionStartEvent = function(_super) {
|
|||
|
|
__extends(CollectionStartEvent, _super);
|
|||
|
|
function CollectionStartEvent(anchor, tag, implicit, start_mark, end_mark) {
|
|||
|
|
this.anchor = anchor;
|
|||
|
|
this.tag = tag;
|
|||
|
|
this.implicit = implicit;
|
|||
|
|
this.start_mark = start_mark;
|
|||
|
|
this.end_mark = end_mark;
|
|||
|
|
}
|
|||
|
|
return CollectionStartEvent;
|
|||
|
|
}(this.NodeEvent);
|
|||
|
|
this.CollectionEndEvent = function(_super) {
|
|||
|
|
__extends(CollectionEndEvent, _super);
|
|||
|
|
function CollectionEndEvent() {
|
|||
|
|
_ref = CollectionEndEvent.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref;
|
|||
|
|
}
|
|||
|
|
return CollectionEndEvent;
|
|||
|
|
}(this.Event);
|
|||
|
|
this.StreamStartEvent = function(_super) {
|
|||
|
|
__extends(StreamStartEvent, _super);
|
|||
|
|
function StreamStartEvent(start_mark, end_mark, explicit, version, tags) {
|
|||
|
|
this.start_mark = start_mark;
|
|||
|
|
this.end_mark = end_mark;
|
|||
|
|
this.explicit = explicit;
|
|||
|
|
this.version = version;
|
|||
|
|
this.tags = tags;
|
|||
|
|
}
|
|||
|
|
return StreamStartEvent;
|
|||
|
|
}(this.Event);
|
|||
|
|
this.StreamEndEvent = function(_super) {
|
|||
|
|
__extends(StreamEndEvent, _super);
|
|||
|
|
function StreamEndEvent() {
|
|||
|
|
_ref1 = StreamEndEvent.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref1;
|
|||
|
|
}
|
|||
|
|
return StreamEndEvent;
|
|||
|
|
}(this.Event);
|
|||
|
|
this.DocumentStartEvent = function(_super) {
|
|||
|
|
__extends(DocumentStartEvent, _super);
|
|||
|
|
function DocumentStartEvent(start_mark, end_mark, explicit, version, tags) {
|
|||
|
|
this.start_mark = start_mark;
|
|||
|
|
this.end_mark = end_mark;
|
|||
|
|
this.explicit = explicit;
|
|||
|
|
this.version = version;
|
|||
|
|
this.tags = tags;
|
|||
|
|
}
|
|||
|
|
return DocumentStartEvent;
|
|||
|
|
}(this.Event);
|
|||
|
|
this.DocumentEndEvent = function(_super) {
|
|||
|
|
__extends(DocumentEndEvent, _super);
|
|||
|
|
function DocumentEndEvent(start_mark, end_mark, explicit) {
|
|||
|
|
this.start_mark = start_mark;
|
|||
|
|
this.end_mark = end_mark;
|
|||
|
|
this.explicit = explicit;
|
|||
|
|
}
|
|||
|
|
return DocumentEndEvent;
|
|||
|
|
}(this.Event);
|
|||
|
|
this.AliasEvent = function(_super) {
|
|||
|
|
__extends(AliasEvent, _super);
|
|||
|
|
function AliasEvent() {
|
|||
|
|
_ref2 = AliasEvent.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref2;
|
|||
|
|
}
|
|||
|
|
return AliasEvent;
|
|||
|
|
}(this.NodeEvent);
|
|||
|
|
this.ScalarEvent = function(_super) {
|
|||
|
|
__extends(ScalarEvent, _super);
|
|||
|
|
function ScalarEvent(anchor, tag, implicit, value, start_mark, end_mark, style) {
|
|||
|
|
this.anchor = anchor;
|
|||
|
|
this.tag = tag;
|
|||
|
|
this.implicit = implicit;
|
|||
|
|
this.value = value;
|
|||
|
|
this.start_mark = start_mark;
|
|||
|
|
this.end_mark = end_mark;
|
|||
|
|
this.style = style;
|
|||
|
|
}
|
|||
|
|
return ScalarEvent;
|
|||
|
|
}(this.NodeEvent);
|
|||
|
|
this.SequenceStartEvent = function(_super) {
|
|||
|
|
__extends(SequenceStartEvent, _super);
|
|||
|
|
function SequenceStartEvent() {
|
|||
|
|
_ref3 = SequenceStartEvent.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref3;
|
|||
|
|
}
|
|||
|
|
return SequenceStartEvent;
|
|||
|
|
}(this.CollectionStartEvent);
|
|||
|
|
this.SequenceEndEvent = function(_super) {
|
|||
|
|
__extends(SequenceEndEvent, _super);
|
|||
|
|
function SequenceEndEvent() {
|
|||
|
|
_ref4 = SequenceEndEvent.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref4;
|
|||
|
|
}
|
|||
|
|
return SequenceEndEvent;
|
|||
|
|
}(this.CollectionEndEvent);
|
|||
|
|
this.MappingStartEvent = function(_super) {
|
|||
|
|
__extends(MappingStartEvent, _super);
|
|||
|
|
function MappingStartEvent() {
|
|||
|
|
_ref5 = MappingStartEvent.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref5;
|
|||
|
|
}
|
|||
|
|
return MappingStartEvent;
|
|||
|
|
}(this.CollectionStartEvent);
|
|||
|
|
this.MappingEndEvent = function(_super) {
|
|||
|
|
__extends(MappingEndEvent, _super);
|
|||
|
|
function MappingEndEvent() {
|
|||
|
|
_ref6 = MappingEndEvent.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref6;
|
|||
|
|
}
|
|||
|
|
return MappingEndEvent;
|
|||
|
|
}(this.CollectionEndEvent);
|
|||
|
|
}).call(this);
|
|||
|
|
});
|
|||
|
|
register({
|
|||
|
|
"0": [ "./errors" ]
|
|||
|
|
}, 0, function(global, module, exports, require, window) {
|
|||
|
|
(function() {
|
|||
|
|
var __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;
|
|||
|
|
}, __hasProp = {}.hasOwnProperty, __extends = 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;
|
|||
|
|
};
|
|||
|
|
this.Mark = function() {
|
|||
|
|
function Mark(name, line, column, buffer, pointer) {
|
|||
|
|
this.name = name;
|
|||
|
|
this.line = line;
|
|||
|
|
this.column = column;
|
|||
|
|
this.buffer = buffer;
|
|||
|
|
this.pointer = pointer;
|
|||
|
|
}
|
|||
|
|
Mark.prototype.get_snippet = function(indent, max_length) {
|
|||
|
|
var break_chars, end, head, start, tail, _ref, _ref1;
|
|||
|
|
if (indent == null) {
|
|||
|
|
indent = 4;
|
|||
|
|
}
|
|||
|
|
if (max_length == null) {
|
|||
|
|
max_length = 75;
|
|||
|
|
}
|
|||
|
|
if (this.buffer == null) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
break_chars = "\0\r\n
\u2028\u2029";
|
|||
|
|
head = "";
|
|||
|
|
start = this.pointer;
|
|||
|
|
while (start > 0 && (_ref = this.buffer[start - 1], __indexOf.call(break_chars, _ref) < 0)) {
|
|||
|
|
start--;
|
|||
|
|
if (this.pointer - start > max_length / 2 - 1) {
|
|||
|
|
head = " ... ";
|
|||
|
|
start += 5;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
tail = "";
|
|||
|
|
end = this.pointer;
|
|||
|
|
while (end < this.buffer.length && (_ref1 = this.buffer[end], __indexOf.call(break_chars, _ref1) < 0)) {
|
|||
|
|
end++;
|
|||
|
|
if (end - this.pointer > max_length / 2 - 1) {
|
|||
|
|
tail = " ... ";
|
|||
|
|
end -= 5;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return "" + (new Array(indent)).join(" ") + head + this.buffer.slice(start, end) + tail + "\n" + (new Array(indent + this.pointer - start + head.length)).join(" ") + "^";
|
|||
|
|
};
|
|||
|
|
Mark.prototype.toString = function() {
|
|||
|
|
var snippet, where;
|
|||
|
|
snippet = this.get_snippet();
|
|||
|
|
where = ' in "' + this.name + '", line ' + (this.line + 1) + ", column " + (this.column + 1);
|
|||
|
|
if (snippet) {
|
|||
|
|
return where;
|
|||
|
|
} else {
|
|||
|
|
return "" + where + ":\n" + snippet;
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
return Mark;
|
|||
|
|
}();
|
|||
|
|
this.YAMLError = function(_super) {
|
|||
|
|
__extends(YAMLError, _super);
|
|||
|
|
function YAMLError() {
|
|||
|
|
YAMLError.__super__.constructor.call(this);
|
|||
|
|
this.stack = this.toString() + "\n" + (new Error).stack.split("\n").slice(1).join("\n");
|
|||
|
|
}
|
|||
|
|
return YAMLError;
|
|||
|
|
}(Error);
|
|||
|
|
this.MarkedYAMLError = function(_super) {
|
|||
|
|
__extends(MarkedYAMLError, _super);
|
|||
|
|
function MarkedYAMLError(context, context_mark, problem, problem_mark, note) {
|
|||
|
|
this.context = context;
|
|||
|
|
this.context_mark = context_mark;
|
|||
|
|
this.problem = problem;
|
|||
|
|
this.problem_mark = problem_mark;
|
|||
|
|
this.note = note;
|
|||
|
|
MarkedYAMLError.__super__.constructor.call(this);
|
|||
|
|
}
|
|||
|
|
MarkedYAMLError.prototype.toString = function() {
|
|||
|
|
var lines;
|
|||
|
|
lines = [];
|
|||
|
|
if (this.context != null) {
|
|||
|
|
lines.push(this.context);
|
|||
|
|
}
|
|||
|
|
if (this.context_mark != null && (this.problem == null || this.problem_mark == null || this.context_mark.name !== this.problem_mark.name || this.context_mark.line !== this.problem_mark.line || this.context_mark.column !== this.problem_mark.column)) {
|
|||
|
|
lines.push(this.context_mark.toString());
|
|||
|
|
}
|
|||
|
|
if (this.problem != null) {
|
|||
|
|
lines.push(this.problem);
|
|||
|
|
}
|
|||
|
|
if (this.problem_mark != null) {
|
|||
|
|
lines.push(this.problem_mark.toString());
|
|||
|
|
}
|
|||
|
|
if (this.note != null) {
|
|||
|
|
lines.push(this.note);
|
|||
|
|
}
|
|||
|
|
return lines.join("\n");
|
|||
|
|
};
|
|||
|
|
return MarkedYAMLError;
|
|||
|
|
}(this.YAMLError);
|
|||
|
|
}).call(this);
|
|||
|
|
});
|
|||
|
|
register({
|
|||
|
|
"0": [ "./nodes" ]
|
|||
|
|
}, 0, function(global, module, exports, require, window) {
|
|||
|
|
(function() {
|
|||
|
|
var unique_id, _ref, _ref1, __hasProp = {}.hasOwnProperty, __extends = 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;
|
|||
|
|
};
|
|||
|
|
unique_id = 0;
|
|||
|
|
this.Node = function() {
|
|||
|
|
function Node(tag, value, start_mark, end_mark) {
|
|||
|
|
this.tag = tag;
|
|||
|
|
this.value = value;
|
|||
|
|
this.start_mark = start_mark;
|
|||
|
|
this.end_mark = end_mark;
|
|||
|
|
this.unique_id = "node_" + unique_id++;
|
|||
|
|
}
|
|||
|
|
return Node;
|
|||
|
|
}();
|
|||
|
|
this.ScalarNode = function(_super) {
|
|||
|
|
__extends(ScalarNode, _super);
|
|||
|
|
ScalarNode.prototype.id = "scalar";
|
|||
|
|
function ScalarNode(tag, value, start_mark, end_mark, style) {
|
|||
|
|
this.tag = tag;
|
|||
|
|
this.value = value;
|
|||
|
|
this.start_mark = start_mark;
|
|||
|
|
this.end_mark = end_mark;
|
|||
|
|
this.style = style;
|
|||
|
|
ScalarNode.__super__.constructor.apply(this, arguments);
|
|||
|
|
}
|
|||
|
|
return ScalarNode;
|
|||
|
|
}(this.Node);
|
|||
|
|
this.CollectionNode = function(_super) {
|
|||
|
|
__extends(CollectionNode, _super);
|
|||
|
|
function CollectionNode(tag, value, start_mark, end_mark, flow_style) {
|
|||
|
|
this.tag = tag;
|
|||
|
|
this.value = value;
|
|||
|
|
this.start_mark = start_mark;
|
|||
|
|
this.end_mark = end_mark;
|
|||
|
|
this.flow_style = flow_style;
|
|||
|
|
CollectionNode.__super__.constructor.apply(this, arguments);
|
|||
|
|
}
|
|||
|
|
return CollectionNode;
|
|||
|
|
}(this.Node);
|
|||
|
|
this.SequenceNode = function(_super) {
|
|||
|
|
__extends(SequenceNode, _super);
|
|||
|
|
function SequenceNode() {
|
|||
|
|
_ref = SequenceNode.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref;
|
|||
|
|
}
|
|||
|
|
SequenceNode.prototype.id = "sequence";
|
|||
|
|
return SequenceNode;
|
|||
|
|
}(this.CollectionNode);
|
|||
|
|
this.MappingNode = function(_super) {
|
|||
|
|
__extends(MappingNode, _super);
|
|||
|
|
function MappingNode() {
|
|||
|
|
_ref1 = MappingNode.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref1;
|
|||
|
|
}
|
|||
|
|
MappingNode.prototype.id = "mapping";
|
|||
|
|
return MappingNode;
|
|||
|
|
}(this.CollectionNode);
|
|||
|
|
}).call(this);
|
|||
|
|
});
|
|||
|
|
register({
|
|||
|
|
"0": [ "./composer" ]
|
|||
|
|
}, 0, function(global, module, exports, require, window) {
|
|||
|
|
(function() {
|
|||
|
|
var MarkedYAMLError, events, nodes, _ref, __hasProp = {}.hasOwnProperty, __extends = 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;
|
|||
|
|
};
|
|||
|
|
events = require("./events");
|
|||
|
|
MarkedYAMLError = require("./errors").MarkedYAMLError;
|
|||
|
|
nodes = require("./nodes");
|
|||
|
|
this.ComposerError = function(_super) {
|
|||
|
|
__extends(ComposerError, _super);
|
|||
|
|
function ComposerError() {
|
|||
|
|
_ref = ComposerError.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref;
|
|||
|
|
}
|
|||
|
|
return ComposerError;
|
|||
|
|
}(MarkedYAMLError);
|
|||
|
|
this.Composer = function() {
|
|||
|
|
function Composer() {
|
|||
|
|
this.anchors = {};
|
|||
|
|
}
|
|||
|
|
Composer.prototype.check_node = function() {
|
|||
|
|
if (this.check_event(events.StreamStartEvent)) {
|
|||
|
|
this.get_event();
|
|||
|
|
}
|
|||
|
|
return !this.check_event(events.StreamEndEvent);
|
|||
|
|
};
|
|||
|
|
Composer.prototype.get_node = function() {
|
|||
|
|
if (!this.check_event(events.StreamEndEvent)) {
|
|||
|
|
return this.compose_document();
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
Composer.prototype.get_single_node = function() {
|
|||
|
|
var document, event;
|
|||
|
|
this.get_event();
|
|||
|
|
document = null;
|
|||
|
|
if (!this.check_event(events.StreamEndEvent)) {
|
|||
|
|
document = this.compose_document();
|
|||
|
|
}
|
|||
|
|
if (!this.check_event(events.StreamEndEvent)) {
|
|||
|
|
event = this.get_event();
|
|||
|
|
throw new exports.ComposerError("expected a single document in the stream", document.start_mark, "but found another document", event.start_mark);
|
|||
|
|
}
|
|||
|
|
this.get_event();
|
|||
|
|
return document;
|
|||
|
|
};
|
|||
|
|
Composer.prototype.compose_document = function() {
|
|||
|
|
var node;
|
|||
|
|
this.get_event();
|
|||
|
|
node = this.compose_node();
|
|||
|
|
this.get_event();
|
|||
|
|
this.anchors = {};
|
|||
|
|
return node;
|
|||
|
|
};
|
|||
|
|
Composer.prototype.compose_node = function(parent, index) {
|
|||
|
|
var anchor, event, node;
|
|||
|
|
if (this.check_event(events.AliasEvent)) {
|
|||
|
|
event = this.get_event();
|
|||
|
|
anchor = event.anchor;
|
|||
|
|
if (!(anchor in this.anchors)) {
|
|||
|
|
throw new exports.ComposerError(null, null, "found undefined alias " + anchor, event.start_mark);
|
|||
|
|
}
|
|||
|
|
return this.anchors[anchor];
|
|||
|
|
}
|
|||
|
|
event = this.peek_event();
|
|||
|
|
anchor = event.anchor;
|
|||
|
|
if (anchor !== null && anchor in this.anchors) {
|
|||
|
|
throw new exports.ComposerError("found duplicate anchor " + anchor + "; first occurence", this.anchors[anchor].start_mark, "second occurrence", event.start_mark);
|
|||
|
|
}
|
|||
|
|
this.descend_resolver(parent, index);
|
|||
|
|
if (this.check_event(events.ScalarEvent)) {
|
|||
|
|
node = this.compose_scalar_node(anchor);
|
|||
|
|
} else if (this.check_event(events.SequenceStartEvent)) {
|
|||
|
|
node = this.compose_sequence_node(anchor);
|
|||
|
|
} else if (this.check_event(events.MappingStartEvent)) {
|
|||
|
|
node = this.compose_mapping_node(anchor);
|
|||
|
|
}
|
|||
|
|
this.ascend_resolver();
|
|||
|
|
return node;
|
|||
|
|
};
|
|||
|
|
Composer.prototype.compose_scalar_node = function(anchor) {
|
|||
|
|
var event, node, tag;
|
|||
|
|
event = this.get_event();
|
|||
|
|
tag = event.tag;
|
|||
|
|
if (tag === null || tag === "!") {
|
|||
|
|
tag = this.resolve(nodes.ScalarNode, event.value, event.implicit);
|
|||
|
|
}
|
|||
|
|
node = new nodes.ScalarNode(tag, event.value, event.start_mark, event.end_mark, event.style);
|
|||
|
|
if (anchor !== null) {
|
|||
|
|
this.anchors[anchor] = node;
|
|||
|
|
}
|
|||
|
|
return node;
|
|||
|
|
};
|
|||
|
|
Composer.prototype.compose_sequence_node = function(anchor) {
|
|||
|
|
var end_event, index, node, start_event, tag;
|
|||
|
|
start_event = this.get_event();
|
|||
|
|
tag = start_event.tag;
|
|||
|
|
if (tag === null || tag === "!") {
|
|||
|
|
tag = this.resolve(nodes.SequenceNode, null, start_event.implicit);
|
|||
|
|
}
|
|||
|
|
node = new nodes.SequenceNode(tag, [], start_event.start_mark, null, start_event.flow_style);
|
|||
|
|
if (anchor !== null) {
|
|||
|
|
this.anchors[anchor] = node;
|
|||
|
|
}
|
|||
|
|
index = 0;
|
|||
|
|
while (!this.check_event(events.SequenceEndEvent)) {
|
|||
|
|
node.value.push(this.compose_node(node, index));
|
|||
|
|
index++;
|
|||
|
|
}
|
|||
|
|
end_event = this.get_event();
|
|||
|
|
node.end_mark = end_event.end_mark;
|
|||
|
|
return node;
|
|||
|
|
};
|
|||
|
|
Composer.prototype.compose_mapping_node = function(anchor) {
|
|||
|
|
var end_event, item_key, item_value, node, start_event, tag;
|
|||
|
|
start_event = this.get_event();
|
|||
|
|
tag = start_event.tag;
|
|||
|
|
if (tag === null || tag === "!") {
|
|||
|
|
tag = this.resolve(nodes.MappingNode, null, start_event.implicit);
|
|||
|
|
}
|
|||
|
|
node = new nodes.MappingNode(tag, [], start_event.start_mark, null, start_event.flow_style);
|
|||
|
|
if (anchor !== null) {
|
|||
|
|
this.anchors[anchor] = node;
|
|||
|
|
}
|
|||
|
|
while (!this.check_event(events.MappingEndEvent)) {
|
|||
|
|
item_key = this.compose_node(node);
|
|||
|
|
item_value = this.compose_node(node, item_key);
|
|||
|
|
node.value.push([ item_key, item_value ]);
|
|||
|
|
}
|
|||
|
|
end_event = this.get_event();
|
|||
|
|
node.end_mark = end_event.end_mark;
|
|||
|
|
return node;
|
|||
|
|
};
|
|||
|
|
return Composer;
|
|||
|
|
}();
|
|||
|
|
}).call(this);
|
|||
|
|
});
|
|||
|
|
register({
|
|||
|
|
"0": [ "./util" ]
|
|||
|
|
}, 0, function(global, module, exports, require, window) {
|
|||
|
|
(function() {
|
|||
|
|
var __slice = [].slice, __hasProp = {}.hasOwnProperty;
|
|||
|
|
this.extend = function() {
|
|||
|
|
var destination, k, source, sources, v, _i, _len;
|
|||
|
|
destination = arguments[0], sources = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
|
|||
|
|
for (_i = 0, _len = sources.length; _i < _len; _i++) {
|
|||
|
|
source = sources[_i];
|
|||
|
|
for (k in source) {
|
|||
|
|
v = source[k];
|
|||
|
|
destination[k] = v;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return destination;
|
|||
|
|
};
|
|||
|
|
this.is_empty = function(obj) {
|
|||
|
|
var key;
|
|||
|
|
if (Array.isArray(obj) || typeof obj === "string") {
|
|||
|
|
return obj.length === 0;
|
|||
|
|
}
|
|||
|
|
for (key in obj) {
|
|||
|
|
if (!__hasProp.call(obj, key)) continue;
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
return true;
|
|||
|
|
};
|
|||
|
|
}).call(this);
|
|||
|
|
});
|
|||
|
|
register({
|
|||
|
|
"0": [ "./constructor" ]
|
|||
|
|
}, 0, function(global, module, exports, require, window) {
|
|||
|
|
(function() {
|
|||
|
|
var MarkedYAMLError, nodes, util, _ref, _ref1, __hasProp = {}.hasOwnProperty, __extends = 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;
|
|||
|
|
}, __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;
|
|||
|
|
};
|
|||
|
|
MarkedYAMLError = require("./errors").MarkedYAMLError;
|
|||
|
|
nodes = require("./nodes");
|
|||
|
|
util = require("./util");
|
|||
|
|
this.ConstructorError = function(_super) {
|
|||
|
|
__extends(ConstructorError, _super);
|
|||
|
|
function ConstructorError() {
|
|||
|
|
_ref = ConstructorError.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref;
|
|||
|
|
}
|
|||
|
|
return ConstructorError;
|
|||
|
|
}(MarkedYAMLError);
|
|||
|
|
this.BaseConstructor = function() {
|
|||
|
|
BaseConstructor.prototype.yaml_constructors = {};
|
|||
|
|
BaseConstructor.prototype.yaml_multi_constructors = {};
|
|||
|
|
BaseConstructor.add_constructor = function(tag, constructor) {
|
|||
|
|
if (!this.prototype.hasOwnProperty("yaml_constructors")) {
|
|||
|
|
this.prototype.yaml_constructors = util.extend({}, this.prototype.yaml_constructors);
|
|||
|
|
}
|
|||
|
|
return this.prototype.yaml_constructors[tag] = constructor;
|
|||
|
|
};
|
|||
|
|
BaseConstructor.add_multi_constructor = function(tag_prefix, multi_constructor) {
|
|||
|
|
if (!this.prototype.hasOwnProperty("yaml_multi_constructors")) {
|
|||
|
|
this.prototype.yaml_multi_constructors = util.extend({}, this.prototype.yaml_multi_constructors);
|
|||
|
|
}
|
|||
|
|
return this.prototype.yaml_multi_constructors[tag_prefix] = multi_constructor;
|
|||
|
|
};
|
|||
|
|
function BaseConstructor() {
|
|||
|
|
this.constructed_objects = {};
|
|||
|
|
this.constructing_nodes = [];
|
|||
|
|
this.deferred_constructors = [];
|
|||
|
|
}
|
|||
|
|
BaseConstructor.prototype.check_data = function() {
|
|||
|
|
return this.check_node();
|
|||
|
|
};
|
|||
|
|
BaseConstructor.prototype.get_data = function() {
|
|||
|
|
if (this.check_node()) {
|
|||
|
|
return this.construct_document(this.get_node());
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
BaseConstructor.prototype.get_single_data = function() {
|
|||
|
|
var node;
|
|||
|
|
node = this.get_single_node();
|
|||
|
|
if (node != null) {
|
|||
|
|
return this.construct_document(node);
|
|||
|
|
}
|
|||
|
|
return null;
|
|||
|
|
};
|
|||
|
|
BaseConstructor.prototype.construct_document = function(node) {
|
|||
|
|
var data;
|
|||
|
|
data = this.construct_object(node);
|
|||
|
|
while (!util.is_empty(this.deferred_constructors)) {
|
|||
|
|
this.deferred_constructors.pop()();
|
|||
|
|
}
|
|||
|
|
return data;
|
|||
|
|
};
|
|||
|
|
BaseConstructor.prototype.defer = function(f) {
|
|||
|
|
return this.deferred_constructors.push(f);
|
|||
|
|
};
|
|||
|
|
BaseConstructor.prototype.construct_object = function(node) {
|
|||
|
|
var constructor, object, tag_prefix, tag_suffix, _ref1;
|
|||
|
|
if (node.unique_id in this.constructed_objects) {
|
|||
|
|
return this.constructed_objects[node.unique_id];
|
|||
|
|
}
|
|||
|
|
if (_ref1 = node.unique_id, __indexOf.call(this.constructing_nodes, _ref1) >= 0) {
|
|||
|
|
throw new exports.ConstructorError(null, null, "found unconstructable recursive node", node.start_mark);
|
|||
|
|
}
|
|||
|
|
this.constructing_nodes.push(node.unique_id);
|
|||
|
|
constructor = null;
|
|||
|
|
tag_suffix = null;
|
|||
|
|
if (node.tag in this.yaml_constructors) {
|
|||
|
|
constructor = this.yaml_constructors[node.tag];
|
|||
|
|
} else {
|
|||
|
|
for (tag_prefix in this.yaml_multi_constructors) {
|
|||
|
|
if (node.tag.indexOf(tag_prefix === 0)) {
|
|||
|
|
tag_suffix = node.tag.slice(tag_prefix.length);
|
|||
|
|
constructor = this.yaml_multi_constructors[tag_prefix];
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (constructor == null) {
|
|||
|
|
if (null in this.yaml_multi_constructors) {
|
|||
|
|
tag_suffix = node.tag;
|
|||
|
|
constructor = this.yaml_multi_constructors[null];
|
|||
|
|
} else if (null in this.yaml_constructors) {
|
|||
|
|
constructor = this.yaml_constructors[null];
|
|||
|
|
} else if (node instanceof nodes.ScalarNode) {
|
|||
|
|
constructor = this.construct_scalar;
|
|||
|
|
} else if (node instanceof nodes.SequenceNode) {
|
|||
|
|
constructor = this.construct_sequence;
|
|||
|
|
} else if (node instanceof nodes.MappingNode) {
|
|||
|
|
constructor = this.construct_mapping;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
object = constructor.call(this, tag_suffix != null ? tag_suffix : node, node);
|
|||
|
|
this.constructed_objects[node.unique_id] = object;
|
|||
|
|
this.constructing_nodes.pop();
|
|||
|
|
return object;
|
|||
|
|
};
|
|||
|
|
BaseConstructor.prototype.construct_scalar = function(node) {
|
|||
|
|
if (!(node instanceof nodes.ScalarNode)) {
|
|||
|
|
throw new exports.ConstructorError(null, null, "expected a scalar node but found " + node.id, node.start_mark);
|
|||
|
|
}
|
|||
|
|
return node.value;
|
|||
|
|
};
|
|||
|
|
BaseConstructor.prototype.construct_sequence = function(node) {
|
|||
|
|
var child, _i, _len, _ref1, _results;
|
|||
|
|
if (!(node instanceof nodes.SequenceNode)) {
|
|||
|
|
throw new exports.ConstructorError(null, null, "expected a sequence node but found " + node.id, node.start_mark);
|
|||
|
|
}
|
|||
|
|
_ref1 = node.value;
|
|||
|
|
_results = [];
|
|||
|
|
for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
|
|||
|
|
child = _ref1[_i];
|
|||
|
|
_results.push(this.construct_object(child));
|
|||
|
|
}
|
|||
|
|
return _results;
|
|||
|
|
};
|
|||
|
|
BaseConstructor.prototype.construct_mapping = function(node) {
|
|||
|
|
var key, key_node, mapping, value, value_node, _i, _len, _ref1, _ref2;
|
|||
|
|
if (!(node instanceof nodes.MappingNode)) {
|
|||
|
|
throw new ConstructorError(null, null, "expected a mapping node but found " + node.id, node.start_mark);
|
|||
|
|
}
|
|||
|
|
mapping = {};
|
|||
|
|
_ref1 = node.value;
|
|||
|
|
for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
|
|||
|
|
_ref2 = _ref1[_i], key_node = _ref2[0], value_node = _ref2[1];
|
|||
|
|
key = this.construct_object(key_node);
|
|||
|
|
if (typeof key === "object") {
|
|||
|
|
throw new exports.ConstructorError("while constructing a mapping", node.start_mark, "found unhashable key", key_node.start_mark);
|
|||
|
|
}
|
|||
|
|
value = this.construct_object(value_node);
|
|||
|
|
mapping[key] = value;
|
|||
|
|
}
|
|||
|
|
return mapping;
|
|||
|
|
};
|
|||
|
|
BaseConstructor.prototype.construct_pairs = function(node) {
|
|||
|
|
var key, key_node, pairs, value, value_node, _i, _len, _ref1, _ref2;
|
|||
|
|
if (!(node instanceof nodes.MappingNode)) {
|
|||
|
|
throw new exports.ConstructorError(null, null, "expected a mapping node but found " + node.id, node.start_mark);
|
|||
|
|
}
|
|||
|
|
pairs = [];
|
|||
|
|
_ref1 = node.value;
|
|||
|
|
for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
|
|||
|
|
_ref2 = _ref1[_i], key_node = _ref2[0], value_node = _ref2[1];
|
|||
|
|
key = this.construct_object(key_node);
|
|||
|
|
value = this.construct_object(value_node);
|
|||
|
|
pairs.push([ key, value ]);
|
|||
|
|
}
|
|||
|
|
return pairs;
|
|||
|
|
};
|
|||
|
|
return BaseConstructor;
|
|||
|
|
}();
|
|||
|
|
this.Constructor = function(_super) {
|
|||
|
|
var BOOL_VALUES, TIMESTAMP_PARTS, TIMESTAMP_REGEX;
|
|||
|
|
__extends(Constructor, _super);
|
|||
|
|
function Constructor() {
|
|||
|
|
_ref1 = Constructor.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref1;
|
|||
|
|
}
|
|||
|
|
BOOL_VALUES = {
|
|||
|
|
on: true,
|
|||
|
|
off: false,
|
|||
|
|
"true": true,
|
|||
|
|
"false": false,
|
|||
|
|
yes: true,
|
|||
|
|
no: false
|
|||
|
|
};
|
|||
|
|
TIMESTAMP_REGEX = /^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:(?:[Tt]|[\x20\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\.([0-9]*))?(?:[\x20\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?)?$/;
|
|||
|
|
TIMESTAMP_PARTS = {
|
|||
|
|
year: 1,
|
|||
|
|
month: 2,
|
|||
|
|
day: 3,
|
|||
|
|
hour: 4,
|
|||
|
|
minute: 5,
|
|||
|
|
second: 6,
|
|||
|
|
fraction: 7,
|
|||
|
|
tz: 8,
|
|||
|
|
tz_sign: 9,
|
|||
|
|
tz_hour: 10,
|
|||
|
|
tz_minute: 11
|
|||
|
|
};
|
|||
|
|
Constructor.prototype.yaml_constructors = {};
|
|||
|
|
Constructor.prototype.yaml_multi_constructors = {};
|
|||
|
|
Constructor.prototype.construct_scalar = function(node) {
|
|||
|
|
var key_node, value_node, _i, _len, _ref2, _ref3;
|
|||
|
|
if (node instanceof nodes.MappingNode) {
|
|||
|
|
_ref2 = node.value;
|
|||
|
|
for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
|
|||
|
|
_ref3 = _ref2[_i], key_node = _ref3[0], value_node = _ref3[1];
|
|||
|
|
if (key_node.tag === "tag:yaml.org,2002:value") {
|
|||
|
|
return this.construct_scalar(value_node);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return Constructor.__super__.construct_scalar.call(this, node);
|
|||
|
|
};
|
|||
|
|
Constructor.prototype.flatten_mapping = function(node) {
|
|||
|
|
var index, key_node, merge, submerge, subnode, value, value_node, _i, _j, _len, _len1, _ref2, _ref3;
|
|||
|
|
merge = [];
|
|||
|
|
index = 0;
|
|||
|
|
while (index < node.value.length) {
|
|||
|
|
_ref2 = node.value[index], key_node = _ref2[0], value_node = _ref2[1];
|
|||
|
|
if (key_node.tag === "tag:yaml.org,2002:merge") {
|
|||
|
|
node.value.splice(index, 1);
|
|||
|
|
if (value_node instanceof nodes.MappingNode) {
|
|||
|
|
this.flatten_mapping(value_node);
|
|||
|
|
merge = merge.concat(value_node.value);
|
|||
|
|
} else if (value_node instanceof nodes.SequenceNode) {
|
|||
|
|
submerge = [];
|
|||
|
|
_ref3 = value_node.value;
|
|||
|
|
for (_i = 0, _len = _ref3.length; _i < _len; _i++) {
|
|||
|
|
subnode = _ref3[_i];
|
|||
|
|
if (!(subnode instanceof nodes.MappingNode)) {
|
|||
|
|
throw new exports.ConstructorError("while constructing a mapping", node.start_mark, "expected a mapping for merging, but found " + subnode.id, subnode.start_mark);
|
|||
|
|
}
|
|||
|
|
this.flatten_mapping(subnode);
|
|||
|
|
submerge.push(subnode.value);
|
|||
|
|
}
|
|||
|
|
submerge.reverse();
|
|||
|
|
for (_j = 0, _len1 = submerge.length; _j < _len1; _j++) {
|
|||
|
|
value = submerge[_j];
|
|||
|
|
merge = merge.concat(value);
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
throw new exports.ConstructorError("while constructing a mapping", node.start_mark, "expected a mapping or list of mappings for merging but found " + value_node.id, value_node.start_mark);
|
|||
|
|
}
|
|||
|
|
} else if (key_node.tag === "tag:yaml.org,2002:value") {
|
|||
|
|
key_node.tag = "tag:yaml.org,2002:str";
|
|||
|
|
index++;
|
|||
|
|
} else {
|
|||
|
|
index++;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (merge.length) {
|
|||
|
|
return node.value = merge.concat(node.value);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
Constructor.prototype.construct_mapping = function(node) {
|
|||
|
|
if (node instanceof nodes.MappingNode) {
|
|||
|
|
this.flatten_mapping(node);
|
|||
|
|
}
|
|||
|
|
return Constructor.__super__.construct_mapping.call(this, node);
|
|||
|
|
};
|
|||
|
|
Constructor.prototype.construct_yaml_null = function(node) {
|
|||
|
|
this.construct_scalar(node);
|
|||
|
|
return null;
|
|||
|
|
};
|
|||
|
|
Constructor.prototype.construct_yaml_bool = function(node) {
|
|||
|
|
var value;
|
|||
|
|
value = this.construct_scalar(node);
|
|||
|
|
return BOOL_VALUES[value.toLowerCase()];
|
|||
|
|
};
|
|||
|
|
Constructor.prototype.construct_yaml_int = function(node) {
|
|||
|
|
var base, digit, digits, part, sign, value, _i, _len, _ref2;
|
|||
|
|
value = this.construct_scalar(node);
|
|||
|
|
value = value.replace(/_/g, "");
|
|||
|
|
sign = value[0] === "-" ? -1 : 1;
|
|||
|
|
if (_ref2 = value[0], __indexOf.call("+-", _ref2) >= 0) {
|
|||
|
|
value = value.slice(1);
|
|||
|
|
}
|
|||
|
|
if (value === "0") {
|
|||
|
|
return 0;
|
|||
|
|
} else if (value.indexOf("0b") === 0) {
|
|||
|
|
return sign * parseInt(value.slice(2), 2);
|
|||
|
|
} else if (value.indexOf("0x") === 0) {
|
|||
|
|
return sign * parseInt(value.slice(2), 16);
|
|||
|
|
} else if (value.indexOf("0o") === 0) {
|
|||
|
|
return sign * parseInt(value.slice(2), 8);
|
|||
|
|
} else if (value[0] === "0") {
|
|||
|
|
return sign * parseInt(value, 8);
|
|||
|
|
} else if (__indexOf.call(value, ":") >= 0) {
|
|||
|
|
digits = function() {
|
|||
|
|
var _i, _len, _ref3, _results;
|
|||
|
|
_ref3 = value.split(/:/g);
|
|||
|
|
_results = [];
|
|||
|
|
for (_i = 0, _len = _ref3.length; _i < _len; _i++) {
|
|||
|
|
part = _ref3[_i];
|
|||
|
|
_results.push(parseInt(part));
|
|||
|
|
}
|
|||
|
|
return _results;
|
|||
|
|
}();
|
|||
|
|
digits.reverse();
|
|||
|
|
base = 1;
|
|||
|
|
value = 0;
|
|||
|
|
for (_i = 0, _len = digits.length; _i < _len; _i++) {
|
|||
|
|
digit = digits[_i];
|
|||
|
|
value += digit * base;
|
|||
|
|
base *= 60;
|
|||
|
|
}
|
|||
|
|
return sign * value;
|
|||
|
|
} else {
|
|||
|
|
return sign * parseInt(value);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
Constructor.prototype.construct_yaml_float = function(node) {
|
|||
|
|
var base, digit, digits, part, sign, value, _i, _len, _ref2;
|
|||
|
|
value = this.construct_scalar(node);
|
|||
|
|
value = value.replace(/_/g, "").toLowerCase();
|
|||
|
|
sign = value[0] === "-" ? -1 : 1;
|
|||
|
|
if (_ref2 = value[0], __indexOf.call("+-", _ref2) >= 0) {
|
|||
|
|
value = value.slice(1);
|
|||
|
|
}
|
|||
|
|
if (value === ".inf") {
|
|||
|
|
return sign * Infinity;
|
|||
|
|
} else if (value === ".nan") {
|
|||
|
|
return NaN;
|
|||
|
|
} else if (__indexOf.call(value, ":") >= 0) {
|
|||
|
|
digits = function() {
|
|||
|
|
var _i, _len, _ref3, _results;
|
|||
|
|
_ref3 = value.split(/:/g);
|
|||
|
|
_results = [];
|
|||
|
|
for (_i = 0, _len = _ref3.length; _i < _len; _i++) {
|
|||
|
|
part = _ref3[_i];
|
|||
|
|
_results.push(parseFloat(part));
|
|||
|
|
}
|
|||
|
|
return _results;
|
|||
|
|
}();
|
|||
|
|
digits.reverse();
|
|||
|
|
base = 1;
|
|||
|
|
value = 0;
|
|||
|
|
for (_i = 0, _len = digits.length; _i < _len; _i++) {
|
|||
|
|
digit = digits[_i];
|
|||
|
|
value += digit * base;
|
|||
|
|
base *= 60;
|
|||
|
|
}
|
|||
|
|
return sign * value;
|
|||
|
|
} else {
|
|||
|
|
return sign * parseFloat(value);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
Constructor.prototype.construct_yaml_binary = function(node) {
|
|||
|
|
var error, value;
|
|||
|
|
value = this.construct_scalar(node);
|
|||
|
|
try {
|
|||
|
|
if (typeof window !== "undefined" && window !== null) {
|
|||
|
|
return atob(value);
|
|||
|
|
}
|
|||
|
|
return (new Buffer(value, "base64")).toString("ascii");
|
|||
|
|
} catch (_error) {
|
|||
|
|
error = _error;
|
|||
|
|
throw new exports.ConstructorError(null, null, "failed to decode base64 data: " + error, node.start_mark);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
Constructor.prototype.construct_yaml_timestamp = function(node) {
|
|||
|
|
var date, day, fraction, hour, index, key, match, millisecond, minute, month, second, tz_hour, tz_minute, tz_sign, value, values, year;
|
|||
|
|
value = this.construct_scalar(node);
|
|||
|
|
match = node.value.match(TIMESTAMP_REGEX);
|
|||
|
|
values = {};
|
|||
|
|
for (key in TIMESTAMP_PARTS) {
|
|||
|
|
index = TIMESTAMP_PARTS[key];
|
|||
|
|
values[key] = match[index];
|
|||
|
|
}
|
|||
|
|
year = parseInt(values.year);
|
|||
|
|
month = parseInt(values.month) - 1;
|
|||
|
|
day = parseInt(values.day);
|
|||
|
|
if (!values.hour) {
|
|||
|
|
return new Date(Date.UTC(year, month, day));
|
|||
|
|
}
|
|||
|
|
hour = parseInt(values.hour);
|
|||
|
|
minute = parseInt(values.minute);
|
|||
|
|
second = parseInt(values.second);
|
|||
|
|
millisecond = 0;
|
|||
|
|
if (values.fraction) {
|
|||
|
|
fraction = values.fraction.slice(0, 6);
|
|||
|
|
while (fraction.length < 6) {
|
|||
|
|
fraction += "0";
|
|||
|
|
}
|
|||
|
|
fraction = parseInt(fraction);
|
|||
|
|
millisecond = Math.round(fraction / 1e3);
|
|||
|
|
}
|
|||
|
|
if (values.tz_sign) {
|
|||
|
|
tz_sign = values.tz_sign === "-" ? 1 : -1;
|
|||
|
|
if (tz_hour = parseInt(values.tz_hour)) {
|
|||
|
|
hour += tz_sign * tz_hour;
|
|||
|
|
}
|
|||
|
|
if (tz_minute = parseInt(values.tz_minute)) {
|
|||
|
|
minute += tz_sign * tz_minute;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
date = new Date(Date.UTC(year, month, day, hour, minute, second, millisecond));
|
|||
|
|
return date;
|
|||
|
|
};
|
|||
|
|
Constructor.prototype.construct_yaml_pair_list = function(type, node) {
|
|||
|
|
var list, _this = this;
|
|||
|
|
list = [];
|
|||
|
|
if (!(node instanceof nodes.SequenceNode)) {
|
|||
|
|
throw new exports.ConstructorError("while constructing " + type, node.start_mark, "expected a sequence but found " + node.id, node.start_mark);
|
|||
|
|
}
|
|||
|
|
this.defer(function() {
|
|||
|
|
var key, key_node, subnode, value, value_node, _i, _len, _ref2, _ref3, _results;
|
|||
|
|
_ref2 = node.value;
|
|||
|
|
_results = [];
|
|||
|
|
for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
|
|||
|
|
subnode = _ref2[_i];
|
|||
|
|
if (!(subnode instanceof nodes.MappingNode)) {
|
|||
|
|
throw new exports.ConstructorError("while constructing " + type, node.start_mark, "expected a mapping of length 1 but found " + subnode.id, subnode.start_mark);
|
|||
|
|
}
|
|||
|
|
if (subnode.value.length !== 1) {
|
|||
|
|
throw new exports.ConstructorError("while constructing " + type, node.start_mark, "expected a mapping of length 1 but found " + subnode.id, subnode.start_mark);
|
|||
|
|
}
|
|||
|
|
_ref3 = subnode.value[0], key_node = _ref3[0], value_node = _ref3[1];
|
|||
|
|
key = _this.construct_object(key_node);
|
|||
|
|
value = _this.construct_object(value_node);
|
|||
|
|
_results.push(list.push([ key, value ]));
|
|||
|
|
}
|
|||
|
|
return _results;
|
|||
|
|
});
|
|||
|
|
return list;
|
|||
|
|
};
|
|||
|
|
Constructor.prototype.construct_yaml_omap = function(node) {
|
|||
|
|
return this.construct_yaml_pair_list("an ordered map", node);
|
|||
|
|
};
|
|||
|
|
Constructor.prototype.construct_yaml_pairs = function(node) {
|
|||
|
|
return this.construct_yaml_pair_list("pairs", node);
|
|||
|
|
};
|
|||
|
|
Constructor.prototype.construct_yaml_set = function(node) {
|
|||
|
|
var data, _this = this;
|
|||
|
|
data = [];
|
|||
|
|
this.defer(function() {
|
|||
|
|
var item, _results;
|
|||
|
|
_results = [];
|
|||
|
|
for (item in _this.construct_mapping(node)) {
|
|||
|
|
_results.push(data.push(item));
|
|||
|
|
}
|
|||
|
|
return _results;
|
|||
|
|
});
|
|||
|
|
return data;
|
|||
|
|
};
|
|||
|
|
Constructor.prototype.construct_yaml_str = function(node) {
|
|||
|
|
return this.construct_scalar(node);
|
|||
|
|
};
|
|||
|
|
Constructor.prototype.construct_yaml_seq = function(node) {
|
|||
|
|
var data, _this = this;
|
|||
|
|
data = [];
|
|||
|
|
this.defer(function() {
|
|||
|
|
var item, _i, _len, _ref2, _results;
|
|||
|
|
_ref2 = _this.construct_sequence(node);
|
|||
|
|
_results = [];
|
|||
|
|
for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
|
|||
|
|
item = _ref2[_i];
|
|||
|
|
_results.push(data.push(item));
|
|||
|
|
}
|
|||
|
|
return _results;
|
|||
|
|
});
|
|||
|
|
return data;
|
|||
|
|
};
|
|||
|
|
Constructor.prototype.construct_yaml_map = function(node) {
|
|||
|
|
var data, _this = this;
|
|||
|
|
data = {};
|
|||
|
|
this.defer(function() {
|
|||
|
|
var key, value, _ref2, _results;
|
|||
|
|
_ref2 = _this.construct_mapping(node);
|
|||
|
|
_results = [];
|
|||
|
|
for (key in _ref2) {
|
|||
|
|
value = _ref2[key];
|
|||
|
|
_results.push(data[key] = value);
|
|||
|
|
}
|
|||
|
|
return _results;
|
|||
|
|
});
|
|||
|
|
return data;
|
|||
|
|
};
|
|||
|
|
Constructor.prototype.construct_yaml_object = function(node, klass) {
|
|||
|
|
var data, _this = this;
|
|||
|
|
data = new klass;
|
|||
|
|
this.defer(function() {
|
|||
|
|
var key, value, _ref2, _results;
|
|||
|
|
_ref2 = _this.construct_mapping(node, true);
|
|||
|
|
_results = [];
|
|||
|
|
for (key in _ref2) {
|
|||
|
|
value = _ref2[key];
|
|||
|
|
_results.push(data[key] = value);
|
|||
|
|
}
|
|||
|
|
return _results;
|
|||
|
|
});
|
|||
|
|
return data;
|
|||
|
|
};
|
|||
|
|
Constructor.prototype.construct_undefined = function(node) {
|
|||
|
|
throw new exports.ConstructorError(null, null, "could not determine a constructor for the tag " + node.tag, node.start_mark);
|
|||
|
|
};
|
|||
|
|
return Constructor;
|
|||
|
|
}(this.BaseConstructor);
|
|||
|
|
this.Constructor.add_constructor("tag:yaml.org,2002:null", this.Constructor.prototype.construct_yaml_null);
|
|||
|
|
this.Constructor.add_constructor("tag:yaml.org,2002:bool", this.Constructor.prototype.construct_yaml_bool);
|
|||
|
|
this.Constructor.add_constructor("tag:yaml.org,2002:int", this.Constructor.prototype.construct_yaml_int);
|
|||
|
|
this.Constructor.add_constructor("tag:yaml.org,2002:float", this.Constructor.prototype.construct_yaml_float);
|
|||
|
|
this.Constructor.add_constructor("tag:yaml.org,2002:binary", this.Constructor.prototype.construct_yaml_binary);
|
|||
|
|
this.Constructor.add_constructor("tag:yaml.org,2002:timestamp", this.Constructor.prototype.construct_yaml_timestamp);
|
|||
|
|
this.Constructor.add_constructor("tag:yaml.org,2002:omap", this.Constructor.prototype.construct_yaml_omap);
|
|||
|
|
this.Constructor.add_constructor("tag:yaml.org,2002:pairs", this.Constructor.prototype.construct_yaml_pairs);
|
|||
|
|
this.Constructor.add_constructor("tag:yaml.org,2002:set", this.Constructor.prototype.construct_yaml_set);
|
|||
|
|
this.Constructor.add_constructor("tag:yaml.org,2002:str", this.Constructor.prototype.construct_yaml_str);
|
|||
|
|
this.Constructor.add_constructor("tag:yaml.org,2002:seq", this.Constructor.prototype.construct_yaml_seq);
|
|||
|
|
this.Constructor.add_constructor("tag:yaml.org,2002:map", this.Constructor.prototype.construct_yaml_map);
|
|||
|
|
this.Constructor.add_constructor(null, this.Constructor.prototype.construct_undefined);
|
|||
|
|
}).call(this);
|
|||
|
|
});
|
|||
|
|
register({
|
|||
|
|
"0": [ "./reader" ]
|
|||
|
|
}, 0, function(global, module, exports, require, window) {
|
|||
|
|
(function() {
|
|||
|
|
var Mark, YAMLError, _ref, __hasProp = {}.hasOwnProperty, __extends = 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;
|
|||
|
|
}, __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;
|
|||
|
|
};
|
|||
|
|
_ref = require("./errors"), Mark = _ref.Mark, YAMLError = _ref.YAMLError;
|
|||
|
|
this.ReaderError = function(_super) {
|
|||
|
|
__extends(ReaderError, _super);
|
|||
|
|
function ReaderError(name, position, character, reason) {
|
|||
|
|
this.name = name;
|
|||
|
|
this.position = position;
|
|||
|
|
this.character = character;
|
|||
|
|
this.reason = reason;
|
|||
|
|
ReaderError.__super__.constructor.call(this);
|
|||
|
|
}
|
|||
|
|
ReaderError.prototype.toString = function() {
|
|||
|
|
return "unacceptable character " + this.character.charCodeAt() + ": " + this.reason + '\n in "' + this.name + '", position ' + this.position;
|
|||
|
|
};
|
|||
|
|
return ReaderError;
|
|||
|
|
}(YAMLError);
|
|||
|
|
this.Reader = function() {
|
|||
|
|
var NON_PRINTABLE;
|
|||
|
|
NON_PRINTABLE = /[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\uD7FF\uE000-\uFFFD]/;
|
|||
|
|
function Reader(string) {
|
|||
|
|
this.string = string;
|
|||
|
|
this.line = 0;
|
|||
|
|
this.column = 0;
|
|||
|
|
this.index = 0;
|
|||
|
|
this.check_printable();
|
|||
|
|
this.string += "\0";
|
|||
|
|
}
|
|||
|
|
Reader.prototype.peek = function(index) {
|
|||
|
|
if (index == null) {
|
|||
|
|
index = 0;
|
|||
|
|
}
|
|||
|
|
return this.string[this.index + index];
|
|||
|
|
};
|
|||
|
|
Reader.prototype.prefix = function(length) {
|
|||
|
|
if (length == null) {
|
|||
|
|
length = 1;
|
|||
|
|
}
|
|||
|
|
return this.string.slice(this.index, this.index + length);
|
|||
|
|
};
|
|||
|
|
Reader.prototype.forward = function(length) {
|
|||
|
|
var char, _results;
|
|||
|
|
if (length == null) {
|
|||
|
|
length = 1;
|
|||
|
|
}
|
|||
|
|
_results = [];
|
|||
|
|
while (length) {
|
|||
|
|
char = this.string[this.index];
|
|||
|
|
this.index++;
|
|||
|
|
if (__indexOf.call("\n
₂\u2029", char) >= 0 || char === "\r" && this.string[this.index] !== "\n") {
|
|||
|
|
this.line++;
|
|||
|
|
this.column = 0;
|
|||
|
|
} else {
|
|||
|
|
this.column++;
|
|||
|
|
}
|
|||
|
|
_results.push(length--);
|
|||
|
|
}
|
|||
|
|
return _results;
|
|||
|
|
};
|
|||
|
|
Reader.prototype.get_mark = function() {
|
|||
|
|
return new Mark(this.name, this.line, this.column, this.string, this.index);
|
|||
|
|
};
|
|||
|
|
Reader.prototype.check_printable = function() {
|
|||
|
|
var character, match, position;
|
|||
|
|
match = NON_PRINTABLE.exec(this.string);
|
|||
|
|
if (match) {
|
|||
|
|
character = match[0];
|
|||
|
|
position = this.string.length - this.index + match.index;
|
|||
|
|
throw new exports.ReaderError(this.name, position, character.charCodeAt(), "special characters are not allowed");
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
return Reader;
|
|||
|
|
}();
|
|||
|
|
}).call(this);
|
|||
|
|
});
|
|||
|
|
register({
|
|||
|
|
"0": [ "./tokens" ]
|
|||
|
|
}, 0, function(global, module, exports, require, window) {
|
|||
|
|
(function() {
|
|||
|
|
var _ref, _ref1, _ref10, _ref11, _ref12, _ref13, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9, __hasProp = {}.hasOwnProperty, __extends = 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;
|
|||
|
|
};
|
|||
|
|
this.Token = function() {
|
|||
|
|
function Token(start_mark, end_mark) {
|
|||
|
|
this.start_mark = start_mark;
|
|||
|
|
this.end_mark = end_mark;
|
|||
|
|
}
|
|||
|
|
return Token;
|
|||
|
|
}();
|
|||
|
|
this.DirectiveToken = function(_super) {
|
|||
|
|
__extends(DirectiveToken, _super);
|
|||
|
|
DirectiveToken.prototype.id = "<directive>";
|
|||
|
|
function DirectiveToken(name, value, start_mark, end_mark) {
|
|||
|
|
this.name = name;
|
|||
|
|
this.value = value;
|
|||
|
|
this.start_mark = start_mark;
|
|||
|
|
this.end_mark = end_mark;
|
|||
|
|
}
|
|||
|
|
return DirectiveToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.DocumentStartToken = function(_super) {
|
|||
|
|
__extends(DocumentStartToken, _super);
|
|||
|
|
function DocumentStartToken() {
|
|||
|
|
_ref = DocumentStartToken.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref;
|
|||
|
|
}
|
|||
|
|
DocumentStartToken.prototype.id = "<document start>";
|
|||
|
|
return DocumentStartToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.DocumentEndToken = function(_super) {
|
|||
|
|
__extends(DocumentEndToken, _super);
|
|||
|
|
function DocumentEndToken() {
|
|||
|
|
_ref1 = DocumentEndToken.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref1;
|
|||
|
|
}
|
|||
|
|
DocumentEndToken.prototype.id = "<document end>";
|
|||
|
|
return DocumentEndToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.StreamStartToken = function(_super) {
|
|||
|
|
__extends(StreamStartToken, _super);
|
|||
|
|
StreamStartToken.prototype.id = "<stream start>";
|
|||
|
|
function StreamStartToken(start_mark, end_mark, encoding) {
|
|||
|
|
this.start_mark = start_mark;
|
|||
|
|
this.end_mark = end_mark;
|
|||
|
|
this.encoding = encoding;
|
|||
|
|
}
|
|||
|
|
return StreamStartToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.StreamEndToken = function(_super) {
|
|||
|
|
__extends(StreamEndToken, _super);
|
|||
|
|
function StreamEndToken() {
|
|||
|
|
_ref2 = StreamEndToken.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref2;
|
|||
|
|
}
|
|||
|
|
StreamEndToken.prototype.id = "<stream end>";
|
|||
|
|
return StreamEndToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.BlockSequenceStartToken = function(_super) {
|
|||
|
|
__extends(BlockSequenceStartToken, _super);
|
|||
|
|
function BlockSequenceStartToken() {
|
|||
|
|
_ref3 = BlockSequenceStartToken.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref3;
|
|||
|
|
}
|
|||
|
|
BlockSequenceStartToken.prototype.id = "<block sequence start>";
|
|||
|
|
return BlockSequenceStartToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.BlockMappingStartToken = function(_super) {
|
|||
|
|
__extends(BlockMappingStartToken, _super);
|
|||
|
|
function BlockMappingStartToken() {
|
|||
|
|
_ref4 = BlockMappingStartToken.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref4;
|
|||
|
|
}
|
|||
|
|
BlockMappingStartToken.prototype.id = "<block mapping end>";
|
|||
|
|
return BlockMappingStartToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.BlockEndToken = function(_super) {
|
|||
|
|
__extends(BlockEndToken, _super);
|
|||
|
|
function BlockEndToken() {
|
|||
|
|
_ref5 = BlockEndToken.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref5;
|
|||
|
|
}
|
|||
|
|
BlockEndToken.prototype.id = "<block end>";
|
|||
|
|
return BlockEndToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.FlowSequenceStartToken = function(_super) {
|
|||
|
|
__extends(FlowSequenceStartToken, _super);
|
|||
|
|
function FlowSequenceStartToken() {
|
|||
|
|
_ref6 = FlowSequenceStartToken.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref6;
|
|||
|
|
}
|
|||
|
|
FlowSequenceStartToken.prototype.id = "[";
|
|||
|
|
return FlowSequenceStartToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.FlowMappingStartToken = function(_super) {
|
|||
|
|
__extends(FlowMappingStartToken, _super);
|
|||
|
|
function FlowMappingStartToken() {
|
|||
|
|
_ref7 = FlowMappingStartToken.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref7;
|
|||
|
|
}
|
|||
|
|
FlowMappingStartToken.prototype.id = "{";
|
|||
|
|
return FlowMappingStartToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.FlowSequenceEndToken = function(_super) {
|
|||
|
|
__extends(FlowSequenceEndToken, _super);
|
|||
|
|
function FlowSequenceEndToken() {
|
|||
|
|
_ref8 = FlowSequenceEndToken.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref8;
|
|||
|
|
}
|
|||
|
|
FlowSequenceEndToken.prototype.id = "]";
|
|||
|
|
return FlowSequenceEndToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.FlowMappingEndToken = function(_super) {
|
|||
|
|
__extends(FlowMappingEndToken, _super);
|
|||
|
|
function FlowMappingEndToken() {
|
|||
|
|
_ref9 = FlowMappingEndToken.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref9;
|
|||
|
|
}
|
|||
|
|
FlowMappingEndToken.prototype.id = "}";
|
|||
|
|
return FlowMappingEndToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.KeyToken = function(_super) {
|
|||
|
|
__extends(KeyToken, _super);
|
|||
|
|
function KeyToken() {
|
|||
|
|
_ref10 = KeyToken.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref10;
|
|||
|
|
}
|
|||
|
|
KeyToken.prototype.id = "?";
|
|||
|
|
return KeyToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.ValueToken = function(_super) {
|
|||
|
|
__extends(ValueToken, _super);
|
|||
|
|
function ValueToken() {
|
|||
|
|
_ref11 = ValueToken.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref11;
|
|||
|
|
}
|
|||
|
|
ValueToken.prototype.id = ":";
|
|||
|
|
return ValueToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.BlockEntryToken = function(_super) {
|
|||
|
|
__extends(BlockEntryToken, _super);
|
|||
|
|
function BlockEntryToken() {
|
|||
|
|
_ref12 = BlockEntryToken.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref12;
|
|||
|
|
}
|
|||
|
|
BlockEntryToken.prototype.id = "-";
|
|||
|
|
return BlockEntryToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.FlowEntryToken = function(_super) {
|
|||
|
|
__extends(FlowEntryToken, _super);
|
|||
|
|
function FlowEntryToken() {
|
|||
|
|
_ref13 = FlowEntryToken.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref13;
|
|||
|
|
}
|
|||
|
|
FlowEntryToken.prototype.id = ",";
|
|||
|
|
return FlowEntryToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.AliasToken = function(_super) {
|
|||
|
|
__extends(AliasToken, _super);
|
|||
|
|
AliasToken.prototype.id = "<alias>";
|
|||
|
|
function AliasToken(value, start_mark, end_mark) {
|
|||
|
|
this.value = value;
|
|||
|
|
this.start_mark = start_mark;
|
|||
|
|
this.end_mark = end_mark;
|
|||
|
|
}
|
|||
|
|
return AliasToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.AnchorToken = function(_super) {
|
|||
|
|
__extends(AnchorToken, _super);
|
|||
|
|
AnchorToken.prototype.id = "<anchor>";
|
|||
|
|
function AnchorToken(value, start_mark, end_mark) {
|
|||
|
|
this.value = value;
|
|||
|
|
this.start_mark = start_mark;
|
|||
|
|
this.end_mark = end_mark;
|
|||
|
|
}
|
|||
|
|
return AnchorToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.TagToken = function(_super) {
|
|||
|
|
__extends(TagToken, _super);
|
|||
|
|
TagToken.prototype.id = "<tag>";
|
|||
|
|
function TagToken(value, start_mark, end_mark) {
|
|||
|
|
this.value = value;
|
|||
|
|
this.start_mark = start_mark;
|
|||
|
|
this.end_mark = end_mark;
|
|||
|
|
}
|
|||
|
|
return TagToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
this.ScalarToken = function(_super) {
|
|||
|
|
__extends(ScalarToken, _super);
|
|||
|
|
ScalarToken.prototype.id = "<scalar>";
|
|||
|
|
function ScalarToken(value, plain, start_mark, end_mark, style) {
|
|||
|
|
this.value = value;
|
|||
|
|
this.plain = plain;
|
|||
|
|
this.start_mark = start_mark;
|
|||
|
|
this.end_mark = end_mark;
|
|||
|
|
this.style = style;
|
|||
|
|
}
|
|||
|
|
return ScalarToken;
|
|||
|
|
}(this.Token);
|
|||
|
|
}).call(this);
|
|||
|
|
});
|
|||
|
|
register({
|
|||
|
|
"0": [ "./scanner" ]
|
|||
|
|
}, 0, function(global, module, exports, require, window) {
|
|||
|
|
(function() {
|
|||
|
|
var MarkedYAMLError, SimpleKey, tokens, util, _ref, __hasProp = {}.hasOwnProperty, __extends = 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;
|
|||
|
|
}, __slice = [].slice, __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;
|
|||
|
|
};
|
|||
|
|
MarkedYAMLError = require("./errors").MarkedYAMLError;
|
|||
|
|
tokens = require("./tokens");
|
|||
|
|
util = require("./util");
|
|||
|
|
this.ScannerError = function(_super) {
|
|||
|
|
__extends(ScannerError, _super);
|
|||
|
|
function ScannerError() {
|
|||
|
|
_ref = ScannerError.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref;
|
|||
|
|
}
|
|||
|
|
return ScannerError;
|
|||
|
|
}(MarkedYAMLError);
|
|||
|
|
SimpleKey = function() {
|
|||
|
|
function SimpleKey(token_number, required, index, line, column, mark) {
|
|||
|
|
this.token_number = token_number;
|
|||
|
|
this.required = required;
|
|||
|
|
this.index = index;
|
|||
|
|
this.line = line;
|
|||
|
|
this.column = column;
|
|||
|
|
this.mark = mark;
|
|||
|
|
}
|
|||
|
|
return SimpleKey;
|
|||
|
|
}();
|
|||
|
|
this.Scanner = function() {
|
|||
|
|
var C_LB, C_NUMBERS, C_WS, ESCAPE_CODES, ESCAPE_REPLACEMENTS;
|
|||
|
|
C_LB = "\r\n
\u2028\u2029";
|
|||
|
|
C_WS = " ";
|
|||
|
|
C_NUMBERS = "0123456789";
|
|||
|
|
ESCAPE_REPLACEMENTS = {
|
|||
|
|
"0": "\0",
|
|||
|
|
a: "",
|
|||
|
|
b: "\b",
|
|||
|
|
t: " ",
|
|||
|
|
" ": " ",
|
|||
|
|
n: "\n",
|
|||
|
|
v: " ",
|
|||
|
|
f: "\f",
|
|||
|
|
r: "\r",
|
|||
|
|
e: "",
|
|||
|
|
" ": " ",
|
|||
|
|
'"': '"',
|
|||
|
|
"\\": "\\",
|
|||
|
|
N: "
",
|
|||
|
|
_: " ",
|
|||
|
|
L: "\u2028",
|
|||
|
|
P: "\u2029"
|
|||
|
|
};
|
|||
|
|
ESCAPE_CODES = {
|
|||
|
|
x: 2,
|
|||
|
|
u: 4,
|
|||
|
|
U: 8
|
|||
|
|
};
|
|||
|
|
function Scanner() {
|
|||
|
|
this.done = false;
|
|||
|
|
this.flow_level = 0;
|
|||
|
|
this.tokens = [];
|
|||
|
|
this.fetch_stream_start();
|
|||
|
|
this.tokens_taken = 0;
|
|||
|
|
this.indent = -1;
|
|||
|
|
this.indents = [];
|
|||
|
|
this.allow_simple_key = true;
|
|||
|
|
this.possible_simple_keys = {};
|
|||
|
|
}
|
|||
|
|
Scanner.prototype.check_token = function() {
|
|||
|
|
var choice, choices, _i, _len;
|
|||
|
|
choices = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
|
|||
|
|
while (this.need_more_tokens()) {
|
|||
|
|
this.fetch_more_tokens();
|
|||
|
|
}
|
|||
|
|
if (this.tokens.length !== 0) {
|
|||
|
|
if (choices.length === 0) {
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
for (_i = 0, _len = choices.length; _i < _len; _i++) {
|
|||
|
|
choice = choices[_i];
|
|||
|
|
if (this.tokens[0] instanceof choice) {
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.peek_token = function() {
|
|||
|
|
while (this.need_more_tokens()) {
|
|||
|
|
this.fetch_more_tokens();
|
|||
|
|
}
|
|||
|
|
if (this.tokens.length !== 0) {
|
|||
|
|
return this.tokens[0];
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.get_token = function() {
|
|||
|
|
while (this.need_more_tokens()) {
|
|||
|
|
this.fetch_more_tokens();
|
|||
|
|
}
|
|||
|
|
if (this.tokens.length !== 0) {
|
|||
|
|
this.tokens_taken++;
|
|||
|
|
return this.tokens.shift();
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.need_more_tokens = function() {
|
|||
|
|
if (this.done) {
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
if (this.tokens.length === 0) {
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
this.stale_possible_simple_keys();
|
|||
|
|
if (this.next_possible_simple_key() === this.tokens_taken) {
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_more_tokens = function() {
|
|||
|
|
var char;
|
|||
|
|
this.scan_to_next_token();
|
|||
|
|
this.stale_possible_simple_keys();
|
|||
|
|
this.unwind_indent(this.column);
|
|||
|
|
char = this.peek();
|
|||
|
|
if (char === "\0") {
|
|||
|
|
return this.fetch_stream_end();
|
|||
|
|
}
|
|||
|
|
if (char === "%" && this.check_directive()) {
|
|||
|
|
return this.fetch_directive();
|
|||
|
|
}
|
|||
|
|
if (char === "-" && this.check_document_start()) {
|
|||
|
|
return this.fetch_document_start();
|
|||
|
|
}
|
|||
|
|
if (char === "." && this.check_document_end()) {
|
|||
|
|
return this.fetch_document_end();
|
|||
|
|
}
|
|||
|
|
if (char === "[") {
|
|||
|
|
return this.fetch_flow_sequence_start();
|
|||
|
|
}
|
|||
|
|
if (char === "{") {
|
|||
|
|
return this.fetch_flow_mapping_start();
|
|||
|
|
}
|
|||
|
|
if (char === "]") {
|
|||
|
|
return this.fetch_flow_sequence_end();
|
|||
|
|
}
|
|||
|
|
if (char === "}") {
|
|||
|
|
return this.fetch_flow_mapping_end();
|
|||
|
|
}
|
|||
|
|
if (char === ",") {
|
|||
|
|
return this.fetch_flow_entry();
|
|||
|
|
}
|
|||
|
|
if (char === "-" && this.check_block_entry()) {
|
|||
|
|
return this.fetch_block_entry();
|
|||
|
|
}
|
|||
|
|
if (char === "?" && this.check_key()) {
|
|||
|
|
return this.fetch_key();
|
|||
|
|
}
|
|||
|
|
if (char === ":" && this.check_value()) {
|
|||
|
|
return this.fetch_value();
|
|||
|
|
}
|
|||
|
|
if (char === "*") {
|
|||
|
|
return this.fetch_alias();
|
|||
|
|
}
|
|||
|
|
if (char === "&") {
|
|||
|
|
return this.fetch_anchor();
|
|||
|
|
}
|
|||
|
|
if (char === "!") {
|
|||
|
|
return this.fetch_tag();
|
|||
|
|
}
|
|||
|
|
if (char === "|" && this.flow_level === 0) {
|
|||
|
|
return this.fetch_literal();
|
|||
|
|
}
|
|||
|
|
if (char === ">" && this.flow_level === 0) {
|
|||
|
|
return this.fetch_folded();
|
|||
|
|
}
|
|||
|
|
if (char === "'") {
|
|||
|
|
return this.fetch_single();
|
|||
|
|
}
|
|||
|
|
if (char === '"') {
|
|||
|
|
return this.fetch_double();
|
|||
|
|
}
|
|||
|
|
if (this.check_plain()) {
|
|||
|
|
return this.fetch_plain();
|
|||
|
|
}
|
|||
|
|
throw new exports.ScannerError("while scanning for the next token", null, "found character " + char + " that cannot start any token", this.get_mark());
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.next_possible_simple_key = function() {
|
|||
|
|
var key, level, min_token_number, _ref1;
|
|||
|
|
min_token_number = null;
|
|||
|
|
_ref1 = this.possible_simple_keys;
|
|||
|
|
for (level in _ref1) {
|
|||
|
|
if (!__hasProp.call(_ref1, level)) continue;
|
|||
|
|
key = _ref1[level];
|
|||
|
|
if (min_token_number === null || key.token_number < min_token_number) {
|
|||
|
|
min_token_number = key.token_number;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return min_token_number;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.stale_possible_simple_keys = function() {
|
|||
|
|
var key, level, _ref1, _results;
|
|||
|
|
_ref1 = this.possible_simple_keys;
|
|||
|
|
_results = [];
|
|||
|
|
for (level in _ref1) {
|
|||
|
|
if (!__hasProp.call(_ref1, level)) continue;
|
|||
|
|
key = _ref1[level];
|
|||
|
|
if (key.line === this.line && this.index - key.index <= 1024) {
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
if (!key.required) {
|
|||
|
|
_results.push(delete this.possible_simple_keys[level]);
|
|||
|
|
} else {
|
|||
|
|
throw new exports.ScannerError("while scanning a simple key", key.mark, "could not find expected ':'", this.get_mark());
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return _results;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.save_possible_simple_key = function() {
|
|||
|
|
var required, token_number;
|
|||
|
|
required = this.flow_level === 0 && this.indent === this.column;
|
|||
|
|
if (required && !this.allow_simple_key) {
|
|||
|
|
throw new Error("logic failure");
|
|||
|
|
}
|
|||
|
|
if (!this.allow_simple_key) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
this.remove_possible_simple_key();
|
|||
|
|
token_number = this.tokens_taken + this.tokens.length;
|
|||
|
|
return this.possible_simple_keys[this.flow_level] = new SimpleKey(token_number, required, this.index, this.line, this.column, this.get_mark());
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.remove_possible_simple_key = function() {
|
|||
|
|
var key;
|
|||
|
|
if (!(key = this.possible_simple_keys[this.flow_level])) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
if (!key.required) {
|
|||
|
|
return delete this.possible_simple_keys[this.flow_level];
|
|||
|
|
} else {
|
|||
|
|
throw new exports.ScannerError("while scanning a simple key", key.mark, "could not find expected ':'", this.get_mark());
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.unwind_indent = function(column) {
|
|||
|
|
var mark, _results;
|
|||
|
|
if (this.flow_level !== 0) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
_results = [];
|
|||
|
|
while (this.indent > column) {
|
|||
|
|
mark = this.get_mark();
|
|||
|
|
this.indent = this.indents.pop();
|
|||
|
|
_results.push(this.tokens.push(new tokens.BlockEndToken(mark, mark)));
|
|||
|
|
}
|
|||
|
|
return _results;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.add_indent = function(column) {
|
|||
|
|
if (!(column > this.indent)) {
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
this.indents.push(this.indent);
|
|||
|
|
this.indent = column;
|
|||
|
|
return true;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_stream_start = function() {
|
|||
|
|
var mark;
|
|||
|
|
mark = this.get_mark();
|
|||
|
|
return this.tokens.push(new tokens.StreamStartToken(mark, mark, this.encoding));
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_stream_end = function() {
|
|||
|
|
var mark;
|
|||
|
|
this.unwind_indent(-1);
|
|||
|
|
this.remove_possible_simple_key();
|
|||
|
|
this.allow_possible_simple_key = false;
|
|||
|
|
this.possible_simple_keys = {};
|
|||
|
|
mark = this.get_mark();
|
|||
|
|
this.tokens.push(new tokens.StreamEndToken(mark, mark));
|
|||
|
|
return this.done = true;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_directive = function() {
|
|||
|
|
this.unwind_indent(-1);
|
|||
|
|
this.remove_possible_simple_key();
|
|||
|
|
this.allow_simple_key = false;
|
|||
|
|
return this.tokens.push(this.scan_directive());
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_document_start = function() {
|
|||
|
|
return this.fetch_document_indicator(tokens.DocumentStartToken);
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_document_end = function() {
|
|||
|
|
return this.fetch_document_indicator(tokens.DocumentEndToken);
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_document_indicator = function(TokenClass) {
|
|||
|
|
var start_mark;
|
|||
|
|
this.unwind_indent(-1);
|
|||
|
|
this.remove_possible_simple_key();
|
|||
|
|
this.allow_simple_key = false;
|
|||
|
|
start_mark = this.get_mark();
|
|||
|
|
this.forward(3);
|
|||
|
|
return this.tokens.push(new TokenClass(start_mark, this.get_mark()));
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_flow_sequence_start = function() {
|
|||
|
|
return this.fetch_flow_collection_start(tokens.FlowSequenceStartToken);
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_flow_mapping_start = function() {
|
|||
|
|
return this.fetch_flow_collection_start(tokens.FlowMappingStartToken);
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_flow_collection_start = function(TokenClass) {
|
|||
|
|
var start_mark;
|
|||
|
|
this.save_possible_simple_key();
|
|||
|
|
this.flow_level++;
|
|||
|
|
this.allow_simple_key = true;
|
|||
|
|
start_mark = this.get_mark();
|
|||
|
|
this.forward();
|
|||
|
|
return this.tokens.push(new TokenClass(start_mark, this.get_mark()));
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_flow_sequence_end = function() {
|
|||
|
|
return this.fetch_flow_collection_end(tokens.FlowSequenceEndToken);
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_flow_mapping_end = function() {
|
|||
|
|
return this.fetch_flow_collection_end(tokens.FlowMappingEndToken);
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_flow_collection_end = function(TokenClass) {
|
|||
|
|
var start_mark;
|
|||
|
|
this.remove_possible_simple_key();
|
|||
|
|
this.flow_level--;
|
|||
|
|
this.allow_simple_key = false;
|
|||
|
|
start_mark = this.get_mark();
|
|||
|
|
this.forward();
|
|||
|
|
return this.tokens.push(new TokenClass(start_mark, this.get_mark()));
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_flow_entry = function() {
|
|||
|
|
var start_mark;
|
|||
|
|
this.allow_simple_key = true;
|
|||
|
|
this.remove_possible_simple_key();
|
|||
|
|
start_mark = this.get_mark();
|
|||
|
|
this.forward();
|
|||
|
|
return this.tokens.push(new tokens.FlowEntryToken(start_mark, this.get_mark()));
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_block_entry = function() {
|
|||
|
|
var mark, start_mark;
|
|||
|
|
if (this.flow_level === 0) {
|
|||
|
|
if (!this.allow_simple_key) {
|
|||
|
|
throw new exports.ScannerError(null, null, "sequence entries are not allowed here", this.get_mark());
|
|||
|
|
}
|
|||
|
|
if (this.add_indent(this.column)) {
|
|||
|
|
mark = this.get_mark();
|
|||
|
|
this.tokens.push(new tokens.BlockSequenceStartToken(mark, mark));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
this.allow_simple_key = true;
|
|||
|
|
this.remove_possible_simple_key();
|
|||
|
|
start_mark = this.get_mark();
|
|||
|
|
this.forward();
|
|||
|
|
return this.tokens.push(new tokens.BlockEntryToken(start_mark, this.get_mark()));
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_key = function() {
|
|||
|
|
var mark, start_mark;
|
|||
|
|
if (this.flow_level === 0) {
|
|||
|
|
if (!this.allow_simple_key) {
|
|||
|
|
throw new exports.ScannerError(null, null, "mapping keys are not allowed here", this.get_mark());
|
|||
|
|
}
|
|||
|
|
if (this.add_indent(this.column)) {
|
|||
|
|
mark = this.get_mark();
|
|||
|
|
this.tokens.push(new tokens.BlockMappingStartToken(mark, mark));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
this.allow_simple_key = !this.flow_level;
|
|||
|
|
this.remove_possible_simple_key();
|
|||
|
|
start_mark = this.get_mark();
|
|||
|
|
this.forward();
|
|||
|
|
return this.tokens.push(new tokens.KeyToken(start_mark, this.get_mark()));
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_value = function() {
|
|||
|
|
var key, mark, start_mark;
|
|||
|
|
if (key = this.possible_simple_keys[this.flow_level]) {
|
|||
|
|
delete this.possible_simple_keys[this.flow_level];
|
|||
|
|
this.tokens.splice(key.token_number - this.tokens_taken, 0, new tokens.KeyToken(key.mark, key.mark));
|
|||
|
|
if (this.flow_level === 0) {
|
|||
|
|
if (this.add_indent(key.column)) {
|
|||
|
|
this.tokens.splice(key.token_number - this.tokens_taken, 0, new tokens.BlockMappingStartToken(key.mark, key.mark));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
this.allow_simple_key = false;
|
|||
|
|
} else {
|
|||
|
|
if (this.flow_level === 0) {
|
|||
|
|
if (!this.allow_simple_key) {
|
|||
|
|
throw new exports.ScannerError(null, null, "mapping values are not allowed here", this.get_mark());
|
|||
|
|
}
|
|||
|
|
if (this.add_indent(this.column)) {
|
|||
|
|
mark = this.get_mark();
|
|||
|
|
this.tokens.push(new tokens.BlockMappingStartToken(mark, mark));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
this.allow_simple_key = !this.flow_level;
|
|||
|
|
this.remove_possible_simple_key();
|
|||
|
|
}
|
|||
|
|
start_mark = this.get_mark();
|
|||
|
|
this.forward();
|
|||
|
|
return this.tokens.push(new tokens.ValueToken(start_mark, this.get_mark()));
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_alias = function() {
|
|||
|
|
this.save_possible_simple_key();
|
|||
|
|
this.allow_simple_key = false;
|
|||
|
|
return this.tokens.push(this.scan_anchor(tokens.AliasToken));
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_anchor = function() {
|
|||
|
|
this.save_possible_simple_key();
|
|||
|
|
this.allow_simple_key = false;
|
|||
|
|
return this.tokens.push(this.scan_anchor(tokens.AnchorToken));
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_tag = function() {
|
|||
|
|
this.save_possible_simple_key();
|
|||
|
|
this.allow_simple_key = false;
|
|||
|
|
return this.tokens.push(this.scan_tag());
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_literal = function() {
|
|||
|
|
return this.fetch_block_scalar("|");
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_folded = function() {
|
|||
|
|
return this.fetch_block_scalar(">");
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_block_scalar = function(style) {
|
|||
|
|
this.allow_simple_key = true;
|
|||
|
|
this.remove_possible_simple_key();
|
|||
|
|
return this.tokens.push(this.scan_block_scalar(style));
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_single = function() {
|
|||
|
|
return this.fetch_flow_scalar("'");
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_double = function() {
|
|||
|
|
return this.fetch_flow_scalar('"');
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_flow_scalar = function(style) {
|
|||
|
|
this.save_possible_simple_key();
|
|||
|
|
this.allow_simple_key = false;
|
|||
|
|
return this.tokens.push(this.scan_flow_scalar(style));
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.fetch_plain = function() {
|
|||
|
|
this.save_possible_simple_key();
|
|||
|
|
this.allow_simple_key = false;
|
|||
|
|
return this.tokens.push(this.scan_plain());
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.check_directive = function() {
|
|||
|
|
if (this.column === 0) {
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.check_document_start = function() {
|
|||
|
|
var _ref1;
|
|||
|
|
if (this.column === 0 && this.prefix(3) === "---" && (_ref1 = this.peek(3), __indexOf.call(C_LB + C_WS + "\0", _ref1) >= 0)) {
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.check_document_end = function() {
|
|||
|
|
var _ref1;
|
|||
|
|
if (this.column === 0 && this.prefix(3) === "..." && (_ref1 = this.peek(3), __indexOf.call(C_LB + C_WS + "\0", _ref1) >= 0)) {
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.check_block_entry = function() {
|
|||
|
|
var _ref1;
|
|||
|
|
return _ref1 = this.peek(1), __indexOf.call(C_LB + C_WS + "\0", _ref1) >= 0;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.check_key = function() {
|
|||
|
|
var _ref1;
|
|||
|
|
if (this.flow_level !== 0) {
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
return _ref1 = this.peek(1), __indexOf.call(C_LB + C_WS + "\0", _ref1) >= 0;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.check_value = function() {
|
|||
|
|
var _ref1;
|
|||
|
|
if (this.flow_level !== 0) {
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
return _ref1 = this.peek(1), __indexOf.call(C_LB + C_WS + "\0", _ref1) >= 0;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.check_plain = function() {
|
|||
|
|
var char, _ref1;
|
|||
|
|
char = this.peek();
|
|||
|
|
return __indexOf.call(C_LB + C_WS + "\0-?:,[]{}#&*!|>'\"%@`", char) < 0 || (_ref1 = this.peek(1), __indexOf.call(C_LB + C_WS + "\0", _ref1) < 0) && (char === "-" || this.flow_level === 0 && __indexOf.call("?:", char) >= 0);
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_to_next_token = function() {
|
|||
|
|
var found, _ref1, _results;
|
|||
|
|
if (this.index === 0 && this.peek() === "") {
|
|||
|
|
this.forward();
|
|||
|
|
}
|
|||
|
|
found = false;
|
|||
|
|
_results = [];
|
|||
|
|
while (!found) {
|
|||
|
|
while (this.peek() === " ") {
|
|||
|
|
this.forward();
|
|||
|
|
}
|
|||
|
|
if (this.peek() === "#") {
|
|||
|
|
while (_ref1 = this.peek(), __indexOf.call(C_LB + "\0", _ref1) < 0) {
|
|||
|
|
this.forward();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (this.scan_line_break()) {
|
|||
|
|
if (this.flow_level === 0) {
|
|||
|
|
_results.push(this.allow_simple_key = true);
|
|||
|
|
} else {
|
|||
|
|
_results.push(void 0);
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
_results.push(found = true);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return _results;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_directive = function() {
|
|||
|
|
var end_mark, name, start_mark, value, _ref1;
|
|||
|
|
start_mark = this.get_mark();
|
|||
|
|
this.forward();
|
|||
|
|
name = this.scan_directive_name(start_mark);
|
|||
|
|
value = null;
|
|||
|
|
if (name === "YAML") {
|
|||
|
|
value = this.scan_yaml_directive_value(start_mark);
|
|||
|
|
end_mark = this.get_mark();
|
|||
|
|
} else if (name === "TAG") {
|
|||
|
|
value = this.scan_tag_directive_value(start_mark);
|
|||
|
|
end_mark = this.get_mark();
|
|||
|
|
} else {
|
|||
|
|
end_mark = this.get_mark();
|
|||
|
|
while (_ref1 = this.peek(), __indexOf.call(C_LB + "\0", _ref1) < 0) {
|
|||
|
|
this.forward();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
this.scan_directive_ignored_line(start_mark);
|
|||
|
|
return new tokens.DirectiveToken(name, value, start_mark, end_mark);
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_directive_name = function(start_mark) {
|
|||
|
|
var char, length, value;
|
|||
|
|
length = 0;
|
|||
|
|
char = this.peek(length);
|
|||
|
|
while ("0" <= char && char <= "9" || "A" <= char && char <= "Z" || "a" <= char && char <= "z" || __indexOf.call("-_", char) >= 0) {
|
|||
|
|
length++;
|
|||
|
|
char = peek(length);
|
|||
|
|
}
|
|||
|
|
throw new exports.ScannerError("while scanning a directive", start_mark, "expected alphanumeric or numeric character but found " + char, length === 0 ? this.get_mark() : void 0);
|
|||
|
|
value = this.prefix(length);
|
|||
|
|
this.forward(length);
|
|||
|
|
char = this.peek();
|
|||
|
|
throw new exports.ScannerError("while scanning a directive", start_mark, "expected alphanumeric or numeric character but found " + char, __indexOf.call(C_LB + "\0 ", char) < 0 ? this.get_mark() : void 0);
|
|||
|
|
return value;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_yaml_directive_value = function(start_mark) {
|
|||
|
|
var major, minor, _ref1;
|
|||
|
|
while (this.peek() === " ") {
|
|||
|
|
this.forward();
|
|||
|
|
}
|
|||
|
|
major = this.scan_yaml_directive_number(start_mark);
|
|||
|
|
throw new exports.ScannerError("while scanning a directive", start_mark, "expected a digit or '.' but found " + this.peek(), this.peek() !== "." ? this.get_mark() : void 0);
|
|||
|
|
this.forward();
|
|||
|
|
minor = this.scan_yaml_directive_number(start_mark);
|
|||
|
|
throw new exports.ScannerError("while scanning a directive", start_mark, "expected a digit or ' ' but found " + this.peek(), (_ref1 = this.peek(), __indexOf.call(C_LB + "\0 ", _ref1) < 0) ? this.get_mark() : void 0);
|
|||
|
|
return [ major, minor ];
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_yaml_directive_number = function(start_mark) {
|
|||
|
|
var char, length, value, _ref1;
|
|||
|
|
char = this.peek();
|
|||
|
|
throw new exports.ScannerError("while scanning a directive", start_mark, "expected a digit but found " + char, !("0" <= char && char <= "9") ? this.get_mark() : void 0);
|
|||
|
|
length = 0;
|
|||
|
|
while ("0" <= (_ref1 = this.peek(length)) && _ref1 <= "9") {
|
|||
|
|
length++;
|
|||
|
|
}
|
|||
|
|
value = parseInt(this.prefix(length));
|
|||
|
|
this.forward(length);
|
|||
|
|
return value;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_tag_directive_value = function(start_mark) {
|
|||
|
|
var handle, prefix;
|
|||
|
|
while (this.peek() === " ") {
|
|||
|
|
this.forward();
|
|||
|
|
}
|
|||
|
|
handle = this.scan_tag_directive_handle(start_mark);
|
|||
|
|
while (this.peek() === " ") {
|
|||
|
|
this.forward();
|
|||
|
|
}
|
|||
|
|
prefix = this.scan_tag_directive_prefix(start_mark);
|
|||
|
|
return [ handle, prefix ];
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_tag_directive_handle = function(start_mark) {
|
|||
|
|
var char, value;
|
|||
|
|
value = this.scan_tag_handle("directive", start_mark);
|
|||
|
|
char = this.peek();
|
|||
|
|
throw new exports.ScannerError("while scanning a directive", start_mark, "expected ' ' but found " + char, char !== " " ? this.get_mark() : void 0);
|
|||
|
|
return value;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_tag_directive_prefix = function(start_mark) {
|
|||
|
|
var char, value;
|
|||
|
|
value = this.scan_tag_uri("directive", start_mark);
|
|||
|
|
char = this.peek();
|
|||
|
|
throw new exports.ScannerError("while scanning a directive", start_mark, "expected ' ' but found " + char, __indexOf.call(C_LB + "\0 ", char) < 0 ? this.get_mark() : void 0);
|
|||
|
|
return value;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_directive_ignored_line = function(start_mark) {
|
|||
|
|
var char, _ref1;
|
|||
|
|
while (this.peek() === " ") {
|
|||
|
|
this.forward();
|
|||
|
|
}
|
|||
|
|
if (this.peek() === "#") {
|
|||
|
|
while (_ref1 = this.peek(), __indexOf.call(C_LB + "\0", _ref1) < 0) {
|
|||
|
|
this.forward();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
char = this.peek();
|
|||
|
|
throw new exports.ScannerError("while scanning a directive", start_mark, "expected a comment or a line break but found " + char, __indexOf.call(C_LB + "\0", char) < 0 ? this.get_mark() : void 0);
|
|||
|
|
return this.scan_line_break();
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_anchor = function(TokenClass) {
|
|||
|
|
var char, indicator, length, name, start_mark, value;
|
|||
|
|
start_mark = this.get_mark();
|
|||
|
|
indicator = this.peek();
|
|||
|
|
if (indicator === "*") {
|
|||
|
|
name = "alias";
|
|||
|
|
} else {
|
|||
|
|
name = "anchor";
|
|||
|
|
}
|
|||
|
|
this.forward();
|
|||
|
|
length = 0;
|
|||
|
|
char = this.peek(length);
|
|||
|
|
while ("0" <= char && char <= "9" || "A" <= char && char <= "Z" || "a" <= char && char <= "z" || __indexOf.call("-_", char) >= 0) {
|
|||
|
|
length++;
|
|||
|
|
char = this.peek(length);
|
|||
|
|
}
|
|||
|
|
if (length === 0) {
|
|||
|
|
throw new exports.ScannerError("while scanning an " + name, start_mark, "expected alphabetic or numeric character but found '" + char + "'", this.get_mark());
|
|||
|
|
}
|
|||
|
|
value = this.prefix(length);
|
|||
|
|
this.forward(length);
|
|||
|
|
char = this.peek();
|
|||
|
|
if (__indexOf.call(C_LB + C_WS + "\0" + "?:,]}%@`", char) < 0) {
|
|||
|
|
throw new exports.ScannerError("while scanning an " + name, start_mark, "expected alphabetic or numeric character but found '" + char + "'", this.get_mark());
|
|||
|
|
}
|
|||
|
|
return new TokenClass(value, start_mark, this.get_mark());
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_tag = function() {
|
|||
|
|
var char, handle, length, start_mark, suffix, use_handle;
|
|||
|
|
start_mark = this.get_mark();
|
|||
|
|
char = this.peek(1);
|
|||
|
|
if (char === "<") {
|
|||
|
|
handle = null;
|
|||
|
|
this.forward(2);
|
|||
|
|
suffix = this.scan_tag_uri("tag", start_mark);
|
|||
|
|
if (this.peek() !== ">") {
|
|||
|
|
throw new exports.ScannerError("while parsing a tag", start_mark, "expected '>' but found " + this.peek(), this.get_mark());
|
|||
|
|
}
|
|||
|
|
this.forward();
|
|||
|
|
} else if (__indexOf.call(C_LB + C_WS + "\0", char) >= 0) {
|
|||
|
|
handle = null;
|
|||
|
|
suffix = "!";
|
|||
|
|
this.forward();
|
|||
|
|
} else {
|
|||
|
|
length = 1;
|
|||
|
|
use_handle = false;
|
|||
|
|
while (__indexOf.call(C_LB + "\0 ", char) < 0) {
|
|||
|
|
if (char === "!") {
|
|||
|
|
use_handle = true;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
length++;
|
|||
|
|
char = this.peek(length);
|
|||
|
|
}
|
|||
|
|
if (use_handle) {
|
|||
|
|
handle = this.scan_tag_handle("tag", start_mark);
|
|||
|
|
} else {
|
|||
|
|
handle = "!";
|
|||
|
|
this.forward();
|
|||
|
|
}
|
|||
|
|
suffix = this.scan_tag_uri("tag", start_mark);
|
|||
|
|
}
|
|||
|
|
char = this.peek();
|
|||
|
|
if (__indexOf.call(C_LB + "\0 ", char) < 0) {
|
|||
|
|
throw new exports.ScannerError("while scanning a tag", start_mark, "expected ' ' but found " + char, this.get_mark());
|
|||
|
|
}
|
|||
|
|
return new tokens.TagToken([ handle, suffix ], start_mark, this.get_mark());
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_block_scalar = function(style) {
|
|||
|
|
var breaks, chomping, chunks, end_mark, folded, increment, indent, leading_non_space, length, line_break, max_indent, min_indent, start_mark, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7;
|
|||
|
|
folded = style === ">";
|
|||
|
|
chunks = [];
|
|||
|
|
start_mark = this.get_mark();
|
|||
|
|
this.forward();
|
|||
|
|
_ref1 = this.scan_block_scalar_indicators(start_mark), chomping = _ref1[0], increment = _ref1[1];
|
|||
|
|
this.scan_block_scalar_ignored_line(start_mark);
|
|||
|
|
min_indent = this.indent + 1;
|
|||
|
|
if (min_indent < 1) {
|
|||
|
|
min_indent = 1;
|
|||
|
|
}
|
|||
|
|
if (increment == null) {
|
|||
|
|
_ref2 = this.scan_block_scalar_indentation(), breaks = _ref2[0], max_indent = _ref2[1], end_mark = _ref2[2];
|
|||
|
|
indent = Math.max(min_indent, max_indent);
|
|||
|
|
} else {
|
|||
|
|
indent = min_indent + increment - 1;
|
|||
|
|
_ref3 = this.scan_block_scalar_breaks(indent), breaks = _ref3[0], end_mark = _ref3[1];
|
|||
|
|
}
|
|||
|
|
line_break = "";
|
|||
|
|
while (this.column === indent && this.peek() !== "\0") {
|
|||
|
|
chunks = chunks.concat(breaks);
|
|||
|
|
leading_non_space = (_ref4 = this.peek(), __indexOf.call(" ", _ref4) < 0);
|
|||
|
|
length = 0;
|
|||
|
|
while (_ref5 = this.peek(length), __indexOf.call(C_LB + "\0", _ref5) < 0) {
|
|||
|
|
length++;
|
|||
|
|
}
|
|||
|
|
chunks.push(this.prefix(length));
|
|||
|
|
this.forward(length);
|
|||
|
|
line_break = this.scan_line_break();
|
|||
|
|
_ref6 = this.scan_block_scalar_breaks(indent), breaks = _ref6[0], end_mark = _ref6[1];
|
|||
|
|
if (this.column === indent && this.peek() !== "\0") {
|
|||
|
|
if (folded && line_break === "\n" && leading_non_space && (_ref7 = this.peek(), __indexOf.call(" ", _ref7) < 0)) {
|
|||
|
|
if (util.is_empty(breaks)) {
|
|||
|
|
chunks.push(" ");
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
chunks.push(line_break);
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (chomping !== false) {
|
|||
|
|
chunks.push(line_break);
|
|||
|
|
}
|
|||
|
|
if (chomping === true) {
|
|||
|
|
chunks = chunks.concat(breaks);
|
|||
|
|
}
|
|||
|
|
return new tokens.ScalarToken(chunks.join(""), false, start_mark, end_mark, style);
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_block_scalar_indicators = function(start_mark) {
|
|||
|
|
var char, chomping, increment;
|
|||
|
|
chomping = null;
|
|||
|
|
increment = null;
|
|||
|
|
char = this.peek();
|
|||
|
|
if (__indexOf.call("+-", char) >= 0) {
|
|||
|
|
chomping = char === "+";
|
|||
|
|
this.forward();
|
|||
|
|
char = this.peek();
|
|||
|
|
if (__indexOf.call(C_NUMBERS, char) >= 0) {
|
|||
|
|
increment = parseInt(char);
|
|||
|
|
if (increment === 0) {
|
|||
|
|
throw new exports.ScannerError("while scanning a block scalar", start_mark, "expected indentation indicator in the range 1-9 but found 0", this.get_mark());
|
|||
|
|
}
|
|||
|
|
this.forward();
|
|||
|
|
}
|
|||
|
|
} else if (__indexOf.call(C_NUMBERS, char) >= 0) {
|
|||
|
|
increment = parseInt(char);
|
|||
|
|
if (increment === 0) {
|
|||
|
|
throw new exports.ScannerError("while scanning a block scalar", start_mark, "expected indentation indicator in the range 1-9 but found 0", this.get_mark());
|
|||
|
|
}
|
|||
|
|
this.forward();
|
|||
|
|
char = this.peek();
|
|||
|
|
if (__indexOf.call("+-", char) >= 0) {
|
|||
|
|
chomping = char === "+";
|
|||
|
|
this.forward();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
char = this.peek();
|
|||
|
|
if (__indexOf.call(C_LB + "\0 ", char) < 0) {
|
|||
|
|
throw new exports.ScannerError("while scanning a block scalar", start_mark, "expected chomping or indentation indicators, but found " + char, this.get_mark());
|
|||
|
|
}
|
|||
|
|
return [ chomping, increment ];
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_block_scalar_ignored_line = function(start_mark) {
|
|||
|
|
var char, _ref1;
|
|||
|
|
while (this.peek() === " ") {
|
|||
|
|
this.forward();
|
|||
|
|
}
|
|||
|
|
if (this.peek() === "#") {
|
|||
|
|
while (_ref1 = this.peek(), __indexOf.call(C_LB + "\0", _ref1) < 0) {
|
|||
|
|
this.forward();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
char = this.peek();
|
|||
|
|
if (__indexOf.call(C_LB + "\0", char) < 0) {
|
|||
|
|
throw new exports.ScannerError("while scanning a block scalar", start_mark, "expected a comment or a line break but found " + char, this.get_mark());
|
|||
|
|
}
|
|||
|
|
return this.scan_line_break();
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_block_scalar_indentation = function() {
|
|||
|
|
var chunks, end_mark, max_indent, _ref1;
|
|||
|
|
chunks = [];
|
|||
|
|
max_indent = 0;
|
|||
|
|
end_mark = this.get_mark();
|
|||
|
|
while (_ref1 = this.peek(), __indexOf.call(C_LB + " ", _ref1) >= 0) {
|
|||
|
|
if (this.peek() !== " ") {
|
|||
|
|
chunks.push(this.scan_line_break());
|
|||
|
|
end_mark = this.get_mark();
|
|||
|
|
} else {
|
|||
|
|
this.forward();
|
|||
|
|
if (this.column > max_indent) {
|
|||
|
|
max_indent = this.column;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return [ chunks, max_indent, end_mark ];
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_block_scalar_breaks = function(indent) {
|
|||
|
|
var chunks, end_mark, _ref1;
|
|||
|
|
chunks = [];
|
|||
|
|
end_mark = this.get_mark();
|
|||
|
|
while (this.column < indent && this.peek() === " ") {
|
|||
|
|
this.forward();
|
|||
|
|
}
|
|||
|
|
while (_ref1 = this.peek(), __indexOf.call(C_LB, _ref1) >= 0) {
|
|||
|
|
chunks.push(this.scan_line_break());
|
|||
|
|
end_mark = this.get_mark();
|
|||
|
|
while (this.column < indent && this.peek() === " ") {
|
|||
|
|
this.forward();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return [ chunks, end_mark ];
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_flow_scalar = function(style) {
|
|||
|
|
var chunks, double, quote, start_mark;
|
|||
|
|
double = style === '"';
|
|||
|
|
chunks = [];
|
|||
|
|
start_mark = this.get_mark();
|
|||
|
|
quote = this.peek();
|
|||
|
|
this.forward();
|
|||
|
|
chunks = chunks.concat(this.scan_flow_scalar_non_spaces(double, start_mark));
|
|||
|
|
while (this.peek() !== quote) {
|
|||
|
|
chunks = chunks.concat(this.scan_flow_scalar_spaces(double, start_mark));
|
|||
|
|
chunks = chunks.concat(this.scan_flow_scalar_non_spaces(double, start_mark));
|
|||
|
|
}
|
|||
|
|
this.forward();
|
|||
|
|
return new tokens.ScalarToken(chunks.join(""), false, start_mark, this.get_mark(), style);
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_flow_scalar_non_spaces = function(double, start_mark) {
|
|||
|
|
var char, chunks, code, k, length, _i, _ref1, _ref2;
|
|||
|
|
chunks = [];
|
|||
|
|
while (true) {
|
|||
|
|
length = 0;
|
|||
|
|
while (_ref1 = this.peek(length), __indexOf.call(C_LB + C_WS + "'\"\\\0", _ref1) < 0) {
|
|||
|
|
length++;
|
|||
|
|
}
|
|||
|
|
if (length !== 0) {
|
|||
|
|
chunks.push(this.prefix(length));
|
|||
|
|
this.forward(length);
|
|||
|
|
}
|
|||
|
|
char = this.peek();
|
|||
|
|
if (!double && char === "'" && this.peek(1) === "'") {
|
|||
|
|
chunks.push("'");
|
|||
|
|
this.forward(2);
|
|||
|
|
} else if (double && char === "'" || !double && __indexOf.call('"\\', char) >= 0) {
|
|||
|
|
chunks.push(char);
|
|||
|
|
this.forward();
|
|||
|
|
} else if (double && char === "\\") {
|
|||
|
|
this.forward();
|
|||
|
|
char = this.peek();
|
|||
|
|
if (char in ESCAPE_REPLACEMENTS) {
|
|||
|
|
chunks.push(ESCAPE_REPLACEMENTS[char]);
|
|||
|
|
this.forward();
|
|||
|
|
} else if (char in ESCAPE_CODES) {
|
|||
|
|
length = ESCAPE_CODES[char];
|
|||
|
|
this.forward();
|
|||
|
|
for (k = _i = 0; 0 <= length ? _i < length : _i > length; k = 0 <= length ? ++_i : --_i) {
|
|||
|
|
if (_ref2 = this.peek(k), __indexOf.call(C_NUMBERS + "ABCDEFabcdef", _ref2) < 0) {
|
|||
|
|
throw new exports.ScannerError("while scanning a double-quoted scalar", start_mark, "expected escape sequence of " + length + " hexadecimal numbers, but " + "found " + this.peek(k), this.get_mark());
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
code = parseInt(this.prefix(length), 16);
|
|||
|
|
chunks.push(String.fromCharCode(code));
|
|||
|
|
this.forward(length);
|
|||
|
|
} else if (__indexOf.call(C_LB, char) >= 0) {
|
|||
|
|
this.scan_line_break();
|
|||
|
|
chunks = chunks.concat(this.scan_flow_scalar_breaks(double, start_mark));
|
|||
|
|
} else {
|
|||
|
|
throw new exports.ScannerError("while scanning a double-quoted scalar", start_mark, "found unknown escape character " + char, this.get_mark());
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
return chunks;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_flow_scalar_spaces = function(double, start_mark) {
|
|||
|
|
var breaks, char, chunks, length, line_break, whitespaces, _ref1;
|
|||
|
|
chunks = [];
|
|||
|
|
length = 0;
|
|||
|
|
while (_ref1 = this.peek(length), __indexOf.call(C_WS, _ref1) >= 0) {
|
|||
|
|
length++;
|
|||
|
|
}
|
|||
|
|
whitespaces = this.prefix(length);
|
|||
|
|
this.forward(length);
|
|||
|
|
char = this.peek();
|
|||
|
|
if (char === "\0") {
|
|||
|
|
throw new exports.ScannerError("while scanning a quoted scalar", start_mark, "found unexpected end of stream", this.get_mark());
|
|||
|
|
}
|
|||
|
|
if (__indexOf.call(C_LB, char) >= 0) {
|
|||
|
|
line_break = this.scan_line_break();
|
|||
|
|
breaks = this.scan_flow_scalar_breaks(double, start_mark);
|
|||
|
|
if (line_break !== "\n") {
|
|||
|
|
chunks.push(line_break);
|
|||
|
|
} else if (!breaks) {
|
|||
|
|
chunks.push(" ");
|
|||
|
|
}
|
|||
|
|
chunks = chunks.concat(breaks);
|
|||
|
|
} else {
|
|||
|
|
chunks.push(whitespaces);
|
|||
|
|
}
|
|||
|
|
return chunks;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_flow_scalar_breaks = function(double, start_mark) {
|
|||
|
|
var chunks, prefix, _ref1, _ref2, _ref3;
|
|||
|
|
chunks = [];
|
|||
|
|
while (true) {
|
|||
|
|
prefix = this.prefix(3);
|
|||
|
|
if (prefix === "---" || prefix === "..." && (_ref1 = this.peek(3), __indexOf.call(C_LB + C_WS + "\0", _ref1) >= 0)) {
|
|||
|
|
throw new exports.ScannerError("while scanning a quoted scalar", start_mark, "found unexpected document separator", this.get_mark());
|
|||
|
|
}
|
|||
|
|
while (_ref2 = this.peek(), __indexOf.call(C_WS, _ref2) >= 0) {
|
|||
|
|
this.forward();
|
|||
|
|
}
|
|||
|
|
if (_ref3 = this.peek(), __indexOf.call(C_LB, _ref3) >= 0) {
|
|||
|
|
chunks.push(this.scan_line_break());
|
|||
|
|
} else {
|
|||
|
|
return chunks;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_plain = function() {
|
|||
|
|
var char, chunks, end_mark, indent, length, spaces, start_mark, _ref1, _ref2;
|
|||
|
|
chunks = [];
|
|||
|
|
start_mark = end_mark = this.get_mark();
|
|||
|
|
indent = this.indent + 1;
|
|||
|
|
spaces = [];
|
|||
|
|
while (true) {
|
|||
|
|
length = 0;
|
|||
|
|
if (this.peek() === "#") {
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
while (true) {
|
|||
|
|
char = this.peek(length);
|
|||
|
|
if (__indexOf.call(C_LB + C_WS + "\0", char) >= 0 || this.flow_level === 0 && char === ":" && (_ref1 = this.peek(length + 1), __indexOf.call(C_LB + C_WS + "\0", _ref1) >= 0) || this.flow_level !== 0 && __indexOf.call(",:?[]{}", char) >= 0) {
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
length++;
|
|||
|
|
}
|
|||
|
|
if (this.flow_level !== 0 && char === ":" && (_ref2 = this.peek(length + 1), __indexOf.call(C_LB + C_WS + "\0,[]{}", _ref2) < 0)) {
|
|||
|
|
this.forward(length);
|
|||
|
|
throw new exports.ScannerError("while scanning a plain scalar", start_mark, "found unexpected ':'", this.get_mark(), "Please check http://pyyaml.org/wiki/YAMLColonInFlowContext");
|
|||
|
|
}
|
|||
|
|
if (length === 0) {
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
this.allow_simple_key = false;
|
|||
|
|
chunks = chunks.concat(spaces);
|
|||
|
|
chunks.push(this.prefix(length));
|
|||
|
|
this.forward(length);
|
|||
|
|
end_mark = this.get_mark();
|
|||
|
|
spaces = this.scan_plain_spaces(indent, start_mark);
|
|||
|
|
if (spaces == null || spaces.length === 0 || this.peek() === "#" || this.flow_level === 0 && this.column < indent) {
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return new tokens.ScalarToken(chunks.join(""), true, start_mark, end_mark);
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_plain_spaces = function(indent, start_mark) {
|
|||
|
|
var breaks, char, chunks, length, line_break, prefix, whitespaces, _ref1, _ref2, _ref3, _ref4;
|
|||
|
|
chunks = [];
|
|||
|
|
length = 0;
|
|||
|
|
while (_ref1 = this.peek(length), __indexOf.call(" ", _ref1) >= 0) {
|
|||
|
|
length++;
|
|||
|
|
}
|
|||
|
|
whitespaces = this.prefix(length);
|
|||
|
|
this.forward(length);
|
|||
|
|
char = this.peek();
|
|||
|
|
if (__indexOf.call(C_LB, char) >= 0) {
|
|||
|
|
line_break = this.scan_line_break();
|
|||
|
|
this.allow_simple_key = true;
|
|||
|
|
prefix = this.prefix(3);
|
|||
|
|
if (prefix === "---" || prefix === "..." && (_ref2 = this.peek(3), __indexOf.call(C_LB + C_WS + "\0", _ref2) >= 0)) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
breaks = [];
|
|||
|
|
while (_ref4 = this.peek(), __indexOf.call(C_LB + " ", _ref4) >= 0) {
|
|||
|
|
if (this.peek() === " ") {
|
|||
|
|
this.forward();
|
|||
|
|
} else {
|
|||
|
|
breaks.push(this.scan_line_break());
|
|||
|
|
prefix = this.prefix(3);
|
|||
|
|
if (prefix === "---" || prefix === "..." && (_ref3 = this.peek(3), __indexOf.call(C_LB + C_WS + "\0", _ref3) >= 0)) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (line_break !== "\n") {
|
|||
|
|
chunks.push(line_break);
|
|||
|
|
} else if (breaks.length === 0) {
|
|||
|
|
chunks.push(" ");
|
|||
|
|
}
|
|||
|
|
chunks = chunks.concat(breaks);
|
|||
|
|
} else if (whitespaces) {
|
|||
|
|
chunks.push(whitespaces);
|
|||
|
|
}
|
|||
|
|
return chunks;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_tag_handle = function(name, start_mark) {
|
|||
|
|
var char, length, value;
|
|||
|
|
char = this.peek();
|
|||
|
|
if (char !== "!") {
|
|||
|
|
throw new exports.ScannerError("while scanning a " + name, start_mark, "expected '!' but found " + char, this.get_mark());
|
|||
|
|
}
|
|||
|
|
length = 1;
|
|||
|
|
char = this.peek(length);
|
|||
|
|
if (char !== " ") {
|
|||
|
|
while ("0" <= char && char <= "9" || "A" <= char && char <= "Z" || "a" <= char && char <= "z" || __indexOf.call("-_", char) >= 0) {
|
|||
|
|
length++;
|
|||
|
|
char = this.peek(length);
|
|||
|
|
}
|
|||
|
|
if (char !== "!") {
|
|||
|
|
this.forward(length);
|
|||
|
|
throw new exports.ScannerError("while scanning a " + name, start_mark, "expected '!' but found " + char, this.get_mark());
|
|||
|
|
}
|
|||
|
|
length++;
|
|||
|
|
}
|
|||
|
|
value = this.prefix(length);
|
|||
|
|
this.forward(length);
|
|||
|
|
return value;
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_tag_uri = function(name, start_mark) {
|
|||
|
|
var char, chunks, length;
|
|||
|
|
chunks = [];
|
|||
|
|
length = 0;
|
|||
|
|
char = this.peek(length);
|
|||
|
|
while ("0" <= char && char <= "9" || "A" <= char && char <= "Z" || "a" <= char && char <= "z" || __indexOf.call("-;/?:@&=+$,_.!~*'()[]%", char) >= 0) {
|
|||
|
|
if (char === "%") {
|
|||
|
|
chunks.push(this.prefix(length));
|
|||
|
|
this.forward(length);
|
|||
|
|
length = 0;
|
|||
|
|
chunks.push(this.scan_uri_escapes(name, start_mark));
|
|||
|
|
} else {
|
|||
|
|
length++;
|
|||
|
|
}
|
|||
|
|
char = this.peek(length);
|
|||
|
|
}
|
|||
|
|
if (length !== 0) {
|
|||
|
|
chunks.push(this.prefix(length));
|
|||
|
|
this.forward(length);
|
|||
|
|
length = 0;
|
|||
|
|
}
|
|||
|
|
if (chunks.length === 0) {
|
|||
|
|
throw new exports.ScannerError("while parsing a " + name, start_mark, "expected URI but found " + char, this.get_mark());
|
|||
|
|
}
|
|||
|
|
return chunks.join("");
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_uri_escapes = function(name, start_mark) {
|
|||
|
|
var bytes, k, mark, _i;
|
|||
|
|
bytes = [];
|
|||
|
|
mark = this.get_mark();
|
|||
|
|
while (this.peek() === "%") {
|
|||
|
|
this.forward();
|
|||
|
|
for (k = _i = 0; _i <= 2; k = ++_i) {
|
|||
|
|
throw new exports.ScannerError("while scanning a " + name, start_mark, "expected URI escape sequence of 2 hexadecimal numbers but found " + this.peek(k), this.get_mark());
|
|||
|
|
}
|
|||
|
|
bytes.push(String.fromCharCode(parseInt(this.prefix(2), 16)));
|
|||
|
|
this.forward(2);
|
|||
|
|
}
|
|||
|
|
return bytes.join("");
|
|||
|
|
};
|
|||
|
|
Scanner.prototype.scan_line_break = function() {
|
|||
|
|
var char;
|
|||
|
|
char = this.peek();
|
|||
|
|
if (__indexOf.call("\r\n
", char) >= 0) {
|
|||
|
|
if (this.prefix(2) === "\r\n") {
|
|||
|
|
this.forward(2);
|
|||
|
|
} else {
|
|||
|
|
this.forward();
|
|||
|
|
}
|
|||
|
|
return "\n";
|
|||
|
|
} else if (__indexOf.call("\u2028\u2029", char) >= 0) {
|
|||
|
|
this.forward();
|
|||
|
|
return char;
|
|||
|
|
}
|
|||
|
|
return "";
|
|||
|
|
};
|
|||
|
|
return Scanner;
|
|||
|
|
}();
|
|||
|
|
}).call(this);
|
|||
|
|
});
|
|||
|
|
register({
|
|||
|
|
"0": [ "./parser" ]
|
|||
|
|
}, 0, function(global, module, exports, require, window) {
|
|||
|
|
(function() {
|
|||
|
|
var MarkedYAMLError, events, tokens, _ref, __hasProp = {}.hasOwnProperty, __extends = 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;
|
|||
|
|
}, __slice = [].slice;
|
|||
|
|
events = require("./events");
|
|||
|
|
MarkedYAMLError = require("./errors").MarkedYAMLError;
|
|||
|
|
tokens = require("./tokens");
|
|||
|
|
this.ParserError = function(_super) {
|
|||
|
|
__extends(ParserError, _super);
|
|||
|
|
function ParserError() {
|
|||
|
|
_ref = ParserError.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref;
|
|||
|
|
}
|
|||
|
|
return ParserError;
|
|||
|
|
}(MarkedYAMLError);
|
|||
|
|
this.Parser = function() {
|
|||
|
|
var DEFAULT_TAGS;
|
|||
|
|
DEFAULT_TAGS = {
|
|||
|
|
"!": "!",
|
|||
|
|
"!!": "tag:yaml.org,2002:"
|
|||
|
|
};
|
|||
|
|
function Parser() {
|
|||
|
|
this.current_event = null;
|
|||
|
|
this.yaml_version = null;
|
|||
|
|
this.tag_handles = {};
|
|||
|
|
this.states = [];
|
|||
|
|
this.marks = [];
|
|||
|
|
this.state = "parse_stream_start";
|
|||
|
|
}
|
|||
|
|
Parser.prototype.dispose = function() {
|
|||
|
|
this.states = [];
|
|||
|
|
return this.state = null;
|
|||
|
|
};
|
|||
|
|
Parser.prototype.check_event = function() {
|
|||
|
|
var choice, choices, _i, _len;
|
|||
|
|
choices = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
|
|||
|
|
if (this.current_event === null) {
|
|||
|
|
if (this.state != null) {
|
|||
|
|
this.current_event = this[this.state]();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (this.current_event !== null) {
|
|||
|
|
if (choices.length === 0) {
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
for (_i = 0, _len = choices.length; _i < _len; _i++) {
|
|||
|
|
choice = choices[_i];
|
|||
|
|
if (this.current_event instanceof choice) {
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
};
|
|||
|
|
Parser.prototype.peek_event = function() {
|
|||
|
|
if (this.current_event === null && this.state != null) {
|
|||
|
|
this.current_event = this[this.state]();
|
|||
|
|
}
|
|||
|
|
return this.current_event;
|
|||
|
|
};
|
|||
|
|
Parser.prototype.get_event = function() {
|
|||
|
|
var event;
|
|||
|
|
if (this.current_event === null && this.state != null) {
|
|||
|
|
this.current_event = this[this.state]();
|
|||
|
|
}
|
|||
|
|
event = this.current_event;
|
|||
|
|
this.current_event = null;
|
|||
|
|
return event;
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_stream_start = function() {
|
|||
|
|
var event, token;
|
|||
|
|
token = this.get_token();
|
|||
|
|
event = new events.StreamStartEvent(token.start_mark, token.end_mark);
|
|||
|
|
this.state = "parse_implicit_document_start";
|
|||
|
|
return event;
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_implicit_document_start = function() {
|
|||
|
|
var end_mark, event, start_mark, token;
|
|||
|
|
if (!this.check_token(tokens.DirectiveToken, tokens.DocumentStartToken, tokens.StreamEndToken)) {
|
|||
|
|
this.tag_handles = DEFAULT_TAGS;
|
|||
|
|
token = this.peek_token();
|
|||
|
|
start_mark = end_mark = token.start_mark;
|
|||
|
|
event = new events.DocumentStartEvent(start_mark, end_mark, false);
|
|||
|
|
this.states.push("parse_document_end");
|
|||
|
|
this.state = "parse_block_node";
|
|||
|
|
return event;
|
|||
|
|
} else {
|
|||
|
|
return this.parse_document_start();
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_document_start = function() {
|
|||
|
|
var end_mark, event, start_mark, tags, token, version, _ref1;
|
|||
|
|
while (this.check_token(tokens.DocumentEndToken)) {
|
|||
|
|
this.get_token();
|
|||
|
|
}
|
|||
|
|
if (!this.check_token(tokens.StreamEndToken)) {
|
|||
|
|
start_mark = this.peek_token().start_mark;
|
|||
|
|
_ref1 = this.process_directives(), version = _ref1[0], tags = _ref1[1];
|
|||
|
|
if (!this.check_token(tokens.DocumentStartToken)) {
|
|||
|
|
throw new exports.ParserError("expected '<document start>', but found " + this.peek_token().id, this.peek_token().start_mark);
|
|||
|
|
}
|
|||
|
|
token = this.get_token();
|
|||
|
|
end_mark = token.end_mark;
|
|||
|
|
event = new events.DocumentStartEvent(start_mark, end_mark, true, version, tags);
|
|||
|
|
this.states.push("parse_document_end");
|
|||
|
|
this.state = "parse_document_content";
|
|||
|
|
} else {
|
|||
|
|
token = this.get_token();
|
|||
|
|
event = new events.StreamEndEvent(token.start_mark, token.end_mark);
|
|||
|
|
if (this.states.length !== 0) {
|
|||
|
|
throw new Error("assertion error, states should be empty");
|
|||
|
|
}
|
|||
|
|
if (this.marks.length !== 0) {
|
|||
|
|
throw new Error("assertion error, marks should be empty");
|
|||
|
|
}
|
|||
|
|
this.state = null;
|
|||
|
|
}
|
|||
|
|
return event;
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_document_end = function() {
|
|||
|
|
var end_mark, event, explicit, start_mark, token;
|
|||
|
|
token = this.peek_token();
|
|||
|
|
start_mark = end_mark = token.start_mark;
|
|||
|
|
explicit = false;
|
|||
|
|
if (this.check_token(tokens.DocumentEndToken)) {
|
|||
|
|
token = this.get_token();
|
|||
|
|
end_mark = token.end_mark;
|
|||
|
|
explicit = true;
|
|||
|
|
}
|
|||
|
|
event = new events.DocumentEndEvent(start_mark, end_mark, explicit);
|
|||
|
|
this.state = "parse_document_start";
|
|||
|
|
return event;
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_document_content = function() {
|
|||
|
|
var event;
|
|||
|
|
if (this.check_token(tokens.DirectiveToken, tokens.DocumentStartToken, tokens.DocumentEndToken, tokens.StreamEndToken)) {
|
|||
|
|
event = this.process_empty_scalar(this.peek_token().start_mark);
|
|||
|
|
this.state = this.states.pop();
|
|||
|
|
return event;
|
|||
|
|
} else {
|
|||
|
|
return this.parse_block_node();
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
Parser.prototype.process_directives = function() {
|
|||
|
|
var handle, major, minor, prefix, tag_handles_copy, token, value, _ref1, _ref2, _ref3;
|
|||
|
|
this.yaml_version = null;
|
|||
|
|
this.tag_handles = {};
|
|||
|
|
while (this.check_token(tokens.DirectiveToken)) {
|
|||
|
|
token = this.get_token();
|
|||
|
|
if (token.name === "YAML") {
|
|||
|
|
if (this.yaml_version !== null) {
|
|||
|
|
throw new exports.ParserError(null, null, "found duplicate YAML directive", token.start_mark);
|
|||
|
|
}
|
|||
|
|
_ref1 = token.value, major = _ref1[0], minor = _ref1[1];
|
|||
|
|
if (major !== 1) {
|
|||
|
|
throw new exports.ParserError(null, null, "found incompatible YAML document (version 1.* is required)", token.start_mark);
|
|||
|
|
}
|
|||
|
|
this.yaml_version = token.value;
|
|||
|
|
} else if (token.name === "TAG") {
|
|||
|
|
_ref2 = this.tag_handles, handle = _ref2[0], prefix = _ref2[1];
|
|||
|
|
if (handle in this.tag_handles) {
|
|||
|
|
throw new exports.ParserError(null, null, "duplicate tag handle " + handle, token.start_mark);
|
|||
|
|
}
|
|||
|
|
this.tag_handles[handle] = prefix;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
tag_handles_copy = null;
|
|||
|
|
_ref3 = this.tag_handles;
|
|||
|
|
for (handle in _ref3) {
|
|||
|
|
if (!__hasProp.call(_ref3, handle)) continue;
|
|||
|
|
prefix = _ref3[handle];
|
|||
|
|
if (tag_handles_copy == null) {
|
|||
|
|
tag_handles_copy = {};
|
|||
|
|
}
|
|||
|
|
tag_handles_copy[handle] = prefix;
|
|||
|
|
}
|
|||
|
|
value = [ this.yaml_version, tag_handles_copy ];
|
|||
|
|
for (handle in DEFAULT_TAGS) {
|
|||
|
|
if (!__hasProp.call(DEFAULT_TAGS, handle)) continue;
|
|||
|
|
prefix = DEFAULT_TAGS[handle];
|
|||
|
|
if (!(prefix in this.tag_handles)) {
|
|||
|
|
this.tag_handles[handle] = prefix;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return value;
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_block_node = function() {
|
|||
|
|
return this.parse_node(true);
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_flow_node = function() {
|
|||
|
|
return this.parse_node();
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_block_node_or_indentless_sequence = function() {
|
|||
|
|
return this.parse_node(true, true);
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_node = function(block, indentless_sequence) {
|
|||
|
|
var anchor, end_mark, event, handle, implicit, node, start_mark, suffix, tag, tag_mark, token;
|
|||
|
|
if (block == null) {
|
|||
|
|
block = false;
|
|||
|
|
}
|
|||
|
|
if (indentless_sequence == null) {
|
|||
|
|
indentless_sequence = false;
|
|||
|
|
}
|
|||
|
|
if (this.check_token(tokens.AliasToken)) {
|
|||
|
|
token = this.get_token();
|
|||
|
|
event = new events.AliasEvent(token.value, token.start_mark, token.end_mark);
|
|||
|
|
this.state = this.states.pop();
|
|||
|
|
} else {
|
|||
|
|
anchor = null;
|
|||
|
|
tag = null;
|
|||
|
|
start_mark = end_mark = tag_mark = null;
|
|||
|
|
if (this.check_token(tokens.AnchorToken)) {
|
|||
|
|
token = this.get_token();
|
|||
|
|
start_mark = token.start_mark;
|
|||
|
|
end_mark = token.end_mark;
|
|||
|
|
anchor = token.value;
|
|||
|
|
if (this.check_token(tokens.TagToken)) {
|
|||
|
|
token = this.get_token();
|
|||
|
|
tag_mark = token.start_mark;
|
|||
|
|
end_mark = token.end_mark;
|
|||
|
|
tag = token.value;
|
|||
|
|
}
|
|||
|
|
} else if (this.check_token(tokens.TagToken)) {
|
|||
|
|
token = this.get_token();
|
|||
|
|
start_mark = tag_mark = token.start_mark;
|
|||
|
|
end_mark = token.end_mark;
|
|||
|
|
tag = token.value;
|
|||
|
|
if (this.check_token(tokens.AnchorToken)) {
|
|||
|
|
token = this.get_token();
|
|||
|
|
end_mark = token.end_mark;
|
|||
|
|
anchor = token.value;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (tag !== null) {
|
|||
|
|
handle = tag[0], suffix = tag[1];
|
|||
|
|
if (handle !== null) {
|
|||
|
|
if (!(handle in this.tag_handles)) {
|
|||
|
|
throw new exports.ParserError("while parsing a node", start_mark, "found undefined tag handle " + handle, tag_mark);
|
|||
|
|
}
|
|||
|
|
tag = this.tag_handles[handle] + suffix;
|
|||
|
|
} else {
|
|||
|
|
tag = suffix;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (start_mark === null) {
|
|||
|
|
start_mark = end_mark = this.peek_token().start_mark;
|
|||
|
|
}
|
|||
|
|
event = null;
|
|||
|
|
implicit = tag === null || tag === "!";
|
|||
|
|
if (indentless_sequence && this.check_token(tokens.BlockEntryToken)) {
|
|||
|
|
end_mark = this.peek_token().end_mark;
|
|||
|
|
event = new events.SequenceStartEvent(anchor, tag, implicit, start_mark, end_mark);
|
|||
|
|
this.state = "parse_indentless_sequence_entry";
|
|||
|
|
} else {
|
|||
|
|
if (this.check_token(tokens.ScalarToken)) {
|
|||
|
|
token = this.get_token();
|
|||
|
|
end_mark = token.end_mark;
|
|||
|
|
if (token.plain && tag === null || tag === "!") {
|
|||
|
|
implicit = [ true, false ];
|
|||
|
|
} else if (tag === null) {
|
|||
|
|
implicit = [ false, true ];
|
|||
|
|
} else {
|
|||
|
|
implicit = [ false, false ];
|
|||
|
|
}
|
|||
|
|
event = new events.ScalarEvent(anchor, tag, implicit, token.value, start_mark, end_mark, token.style);
|
|||
|
|
this.state = this.states.pop();
|
|||
|
|
} else if (this.check_token(tokens.FlowSequenceStartToken)) {
|
|||
|
|
end_mark = this.peek_token().end_mark;
|
|||
|
|
event = new events.SequenceStartEvent(anchor, tag, implicit, start_mark, end_mark, true);
|
|||
|
|
this.state = "parse_flow_sequence_first_entry";
|
|||
|
|
} else if (this.check_token(tokens.FlowMappingStartToken)) {
|
|||
|
|
end_mark = this.peek_token().end_mark;
|
|||
|
|
event = new events.MappingStartEvent(anchor, tag, implicit, start_mark, end_mark, true);
|
|||
|
|
this.state = "parse_flow_mapping_first_key";
|
|||
|
|
} else if (block && this.check_token(tokens.BlockSequenceStartToken)) {
|
|||
|
|
end_mark = this.peek_token().end_mark;
|
|||
|
|
event = new events.SequenceStartEvent(anchor, tag, implicit, start_mark, end_mark, false);
|
|||
|
|
this.state = "parse_block_sequence_first_entry";
|
|||
|
|
} else if (block && this.check_token(tokens.BlockMappingStartToken)) {
|
|||
|
|
end_mark = this.peek_token().end_mark;
|
|||
|
|
event = new events.MappingStartEvent(anchor, tag, implicit, start_mark, end_mark, false);
|
|||
|
|
this.state = "parse_block_mapping_first_key";
|
|||
|
|
} else if (anchor !== null || tag !== null) {
|
|||
|
|
event = new events.ScalarEvent(anchor, tag, [ implicit, false ], "", start_mark, end_mark);
|
|||
|
|
this.state = this.states.pop();
|
|||
|
|
} else {
|
|||
|
|
if (block) {
|
|||
|
|
node = "block";
|
|||
|
|
} else {
|
|||
|
|
node = "flow";
|
|||
|
|
}
|
|||
|
|
token = this.peek_token();
|
|||
|
|
throw new exports.ParserError("while parsing a " + node + " node", start_mark, "expected the node content, but found " + token.id, token.start_mark);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return event;
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_block_sequence_first_entry = function() {
|
|||
|
|
var token;
|
|||
|
|
token = this.get_token();
|
|||
|
|
this.marks.push(token.start_mark);
|
|||
|
|
return this.parse_block_sequence_entry();
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_block_sequence_entry = function() {
|
|||
|
|
var event, token;
|
|||
|
|
if (this.check_token(tokens.BlockEntryToken)) {
|
|||
|
|
token = this.get_token();
|
|||
|
|
if (!this.check_token(tokens.BlockEntryToken, tokens.BlockEndToken)) {
|
|||
|
|
this.states.push("parse_block_sequence_entry");
|
|||
|
|
return this.parse_block_node();
|
|||
|
|
} else {
|
|||
|
|
this.state = "parse_block_sequence_entry";
|
|||
|
|
return this.process_empty_scalar(token.end_mark);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (!this.check_token(tokens.BlockEndToken)) {
|
|||
|
|
token = this.peek_token();
|
|||
|
|
throw new exports.ParserError("while parsing a block collection", this.marks.slice(-1)[0], "expected <block end>, but found " + token.id, token.start_mark);
|
|||
|
|
}
|
|||
|
|
token = this.get_token();
|
|||
|
|
event = new events.SequenceEndEvent(token.start_mark, token.end_mark);
|
|||
|
|
this.state = this.states.pop();
|
|||
|
|
this.marks.pop();
|
|||
|
|
return event;
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_indentless_sequence_entry = function() {
|
|||
|
|
var event, token;
|
|||
|
|
if (this.check_token(tokens.BlockEntryToken)) {
|
|||
|
|
token = this.get_token();
|
|||
|
|
if (!this.check_token(tokens.BlockEntryToken, tokens.KeyToken, tokens.ValueToken, tokens.BlockEndToken)) {
|
|||
|
|
this.states.push("parse_indentless_sequence_entry");
|
|||
|
|
return this.parse_block_node();
|
|||
|
|
} else {
|
|||
|
|
this.state = "parse_indentless_sequence_entry";
|
|||
|
|
return this.process_empty_scalar(token.end_mark);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
token = this.peek_token();
|
|||
|
|
event = new events.SequenceEndEvent(token.start_mark, token.start_mark);
|
|||
|
|
this.state = this.states.pop();
|
|||
|
|
return event;
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_block_mapping_first_key = function() {
|
|||
|
|
var token;
|
|||
|
|
token = this.get_token();
|
|||
|
|
this.marks.push(token.start_mark);
|
|||
|
|
return this.parse_block_mapping_key();
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_block_mapping_key = function() {
|
|||
|
|
var event, token;
|
|||
|
|
if (this.check_token(tokens.KeyToken)) {
|
|||
|
|
token = this.get_token();
|
|||
|
|
if (!this.check_token(tokens.KeyToken, tokens.ValueToken, tokens.BlockEndToken)) {
|
|||
|
|
this.states.push("parse_block_mapping_value");
|
|||
|
|
return this.parse_block_node_or_indentless_sequence();
|
|||
|
|
} else {
|
|||
|
|
this.state = "parse_block_mapping_value";
|
|||
|
|
return this.process_empty_scalar(token.end_mark);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (!this.check_token(tokens.BlockEndToken)) {
|
|||
|
|
token = this.peek_token();
|
|||
|
|
throw new exports.ParserError("while parsing a block mapping", this.marks.slice(-1)[0], "expected <block end>, but found " + token.id, token.start_mark);
|
|||
|
|
}
|
|||
|
|
token = this.get_token();
|
|||
|
|
event = new events.MappingEndEvent(token.start_mark, token.end_mark);
|
|||
|
|
this.state = this.states.pop();
|
|||
|
|
this.marks.pop();
|
|||
|
|
return event;
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_block_mapping_value = function() {
|
|||
|
|
var token;
|
|||
|
|
if (this.check_token(tokens.ValueToken)) {
|
|||
|
|
token = this.get_token();
|
|||
|
|
if (!this.check_token(tokens.KeyToken, tokens.ValueToken, tokens.BlockEndToken)) {
|
|||
|
|
this.states.push("parse_block_mapping_key");
|
|||
|
|
return this.parse_block_node_or_indentless_sequence();
|
|||
|
|
} else {
|
|||
|
|
this.state = "parse_block_mapping_key";
|
|||
|
|
return this.process_empty_scalar(token.end_mark);
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
this.state = "parse_block_mapping_key";
|
|||
|
|
token = this.peek_token();
|
|||
|
|
return this.process_empty_scalar(token.start_mark);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_flow_sequence_first_entry = function() {
|
|||
|
|
var token;
|
|||
|
|
token = this.get_token();
|
|||
|
|
this.marks.push(token.start_mark);
|
|||
|
|
return this.parse_flow_sequence_entry(true);
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_flow_sequence_entry = function(first) {
|
|||
|
|
var event, token;
|
|||
|
|
if (first == null) {
|
|||
|
|
first = false;
|
|||
|
|
}
|
|||
|
|
if (!this.check_token(tokens.FlowSequenceEndToken)) {
|
|||
|
|
if (!first) {
|
|||
|
|
if (this.check_token(tokens.FlowEntryToken)) {
|
|||
|
|
this.get_token();
|
|||
|
|
} else {
|
|||
|
|
token = this.peek_token();
|
|||
|
|
throw new exports.ParserError("while parsing a flow sequence", this.marks.slice(-1)[0], "expected ',' or ']', but got " + token.id, token.start_mark);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (this.check_token(tokens.KeyToken)) {
|
|||
|
|
token = this.peek_token();
|
|||
|
|
event = new events.MappingStartEvent(null, null, true, token.start_mark, token.end_mark, true);
|
|||
|
|
this.state = "parse_flow_sequence_entry_mapping_key";
|
|||
|
|
return event;
|
|||
|
|
} else if (!this.check_token(tokens.FlowSequenceEndToken)) {
|
|||
|
|
this.states.push("parse_flow_sequence_entry");
|
|||
|
|
return this.parse_flow_node();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
token = this.get_token();
|
|||
|
|
event = new events.SequenceEndEvent(token.start_mark, token.end_mark);
|
|||
|
|
this.state = this.states.pop();
|
|||
|
|
this.marks.pop();
|
|||
|
|
return event;
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_flow_sequence_entry_mapping_key = function() {
|
|||
|
|
var token;
|
|||
|
|
token = this.get_token();
|
|||
|
|
if (!this.check_token(tokens.ValueToken, tokens.FlowEntryToken, tokens.FlowSequenceEndToken)) {
|
|||
|
|
this.states.push("parse_flow_sequence_entry_mapping_value");
|
|||
|
|
return this.parse_flow_node();
|
|||
|
|
} else {
|
|||
|
|
this.state = "parse_flow_sequence_entry_mapping_value";
|
|||
|
|
return this.process_empty_scalar(token.end_mark);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_flow_sequence_entry_mapping_value = function() {
|
|||
|
|
var token;
|
|||
|
|
if (this.check_token(tokens.ValueToken)) {
|
|||
|
|
token = this.get_token();
|
|||
|
|
if (!this.check_token(tokens.FlowEntryToken, tokens.FlowSequenceEndToken)) {
|
|||
|
|
this.states.push("parse_flow_sequence_entry_mapping_end");
|
|||
|
|
return this.parse_flow_node();
|
|||
|
|
} else {
|
|||
|
|
this.state = "parse_flow_sequence_entry_mapping_end";
|
|||
|
|
return this.process_empty_scalar(token.end_mark);
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
this.state = "parse_flow_sequence_entry_mapping_end";
|
|||
|
|
token = this.peek_token();
|
|||
|
|
return this.process_empty_scalar(token.start_mark);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_flow_sequence_entry_mapping_end = function() {
|
|||
|
|
var token;
|
|||
|
|
this.state = "parse_flow_sequence_entry";
|
|||
|
|
token = this.peek_token();
|
|||
|
|
return new events.MappingEndEvent(token.start_mark, token.start_mark);
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_flow_mapping_first_key = function() {
|
|||
|
|
var token;
|
|||
|
|
token = this.get_token();
|
|||
|
|
this.marks.push(token.start_mark);
|
|||
|
|
return this.parse_flow_mapping_key(true);
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_flow_mapping_key = function(first) {
|
|||
|
|
var event, token;
|
|||
|
|
if (first == null) {
|
|||
|
|
first = false;
|
|||
|
|
}
|
|||
|
|
if (!this.check_token(tokens.FlowMappingEndToken)) {
|
|||
|
|
if (!first) {
|
|||
|
|
if (this.check_token(tokens.FlowEntryToken)) {
|
|||
|
|
this.get_token();
|
|||
|
|
} else {
|
|||
|
|
token = this.peek_token();
|
|||
|
|
throw new exports.ParserError("while parsing a flow mapping", this.marks.slice(-1)[0], "expected ',' or '}', but got " + token.id, token.start_mark);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (this.check_token(tokens.KeyToken)) {
|
|||
|
|
token = this.get_token();
|
|||
|
|
if (!this.check_token(tokens.ValueToken, tokens.FlowEntryToken, tokens.FlowMappingEndToken)) {
|
|||
|
|
this.states.push("parse_flow_mapping_value");
|
|||
|
|
return this.parse_flow_node();
|
|||
|
|
} else {
|
|||
|
|
this.state = "parse_flow_mapping_value";
|
|||
|
|
return this.process_empty_scalar(token.end_mark);
|
|||
|
|
}
|
|||
|
|
} else if (!this.check_token(tokens.FlowMappingEndToken)) {
|
|||
|
|
this.states.push("parse_flow_mapping_empty_value");
|
|||
|
|
return this.parse_flow_node();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
token = this.get_token();
|
|||
|
|
event = new events.MappingEndEvent(token.start_mark, token.end_mark);
|
|||
|
|
this.state = this.states.pop();
|
|||
|
|
this.marks.pop();
|
|||
|
|
return event;
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_flow_mapping_value = function() {
|
|||
|
|
var token;
|
|||
|
|
if (this.check_token(tokens.ValueToken)) {
|
|||
|
|
token = this.get_token();
|
|||
|
|
if (!this.check_token(tokens.FlowEntryToken, tokens.FlowMappingEndToken)) {
|
|||
|
|
this.states.push("parse_flow_mapping_key");
|
|||
|
|
return this.parse_flow_node();
|
|||
|
|
} else {
|
|||
|
|
this.state = "parse_flow_mapping_key";
|
|||
|
|
return this.process_empty_scalar(token.end_mark);
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
this.state = "parse_flow_mapping_key";
|
|||
|
|
token = this.peek_token();
|
|||
|
|
return this.process_empty_scalar(token.start_mark);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
Parser.prototype.parse_flow_mapping_empty_value = function() {
|
|||
|
|
this.state = "parse_flow_mapping_key";
|
|||
|
|
return this.process_empty_scalar(this.peek_token().start_mark);
|
|||
|
|
};
|
|||
|
|
Parser.prototype.process_empty_scalar = function(mark) {
|
|||
|
|
return new events.ScalarEvent(null, null, [ true, false ], "", mark, mark);
|
|||
|
|
};
|
|||
|
|
return Parser;
|
|||
|
|
}();
|
|||
|
|
}).call(this);
|
|||
|
|
});
|
|||
|
|
register({
|
|||
|
|
"0": [ "./resolver" ]
|
|||
|
|
}, 0, function(global, module, exports, require, window) {
|
|||
|
|
(function() {
|
|||
|
|
var YAMLError, nodes, util, _ref, _ref1, __hasProp = {}.hasOwnProperty, __extends = 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;
|
|||
|
|
}, __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;
|
|||
|
|
};
|
|||
|
|
nodes = require("./nodes");
|
|||
|
|
util = require("./util");
|
|||
|
|
YAMLError = require("./errors").YAMLError;
|
|||
|
|
this.ResolverError = function(_super) {
|
|||
|
|
__extends(ResolverError, _super);
|
|||
|
|
function ResolverError() {
|
|||
|
|
_ref = ResolverError.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref;
|
|||
|
|
}
|
|||
|
|
return ResolverError;
|
|||
|
|
}(YAMLError);
|
|||
|
|
this.BaseResolver = function() {
|
|||
|
|
var DEFAULT_MAPPING_TAG, DEFAULT_SCALAR_TAG, DEFAULT_SEQUENCE_TAG;
|
|||
|
|
DEFAULT_SCALAR_TAG = "tag:yaml.org,2002:str";
|
|||
|
|
DEFAULT_SEQUENCE_TAG = "tag:yaml.org,2002:seq";
|
|||
|
|
DEFAULT_MAPPING_TAG = "tag:yaml.org,2002:map";
|
|||
|
|
BaseResolver.prototype.yaml_implicit_resolvers = {};
|
|||
|
|
BaseResolver.prototype.yaml_path_resolvers = {};
|
|||
|
|
BaseResolver.add_implicit_resolver = function(tag, regexp, first) {
|
|||
|
|
var char, _base, _i, _len, _ref1, _results;
|
|||
|
|
if (first == null) {
|
|||
|
|
first = [ null ];
|
|||
|
|
}
|
|||
|
|
if (!this.prototype.hasOwnProperty("yaml_implicit_resolvers")) {
|
|||
|
|
this.prototype.yaml_implicit_resolvers = util.extend({}, this.prototype.yaml_implicit_resolvers);
|
|||
|
|
}
|
|||
|
|
_results = [];
|
|||
|
|
for (_i = 0, _len = first.length; _i < _len; _i++) {
|
|||
|
|
char = first[_i];
|
|||
|
|
_results.push(((_ref1 = (_base = this.prototype.yaml_implicit_resolvers)[char]) != null ? _ref1 : _base[char] = []).push([ tag, regexp ]));
|
|||
|
|
}
|
|||
|
|
return _results;
|
|||
|
|
};
|
|||
|
|
function BaseResolver() {
|
|||
|
|
this.resolver_exact_paths = [];
|
|||
|
|
this.resolver_prefix_paths = [];
|
|||
|
|
}
|
|||
|
|
BaseResolver.prototype.descend_resolver = function(current_node, current_index) {
|
|||
|
|
var depth, exact_paths, kind, path, prefix_paths, _i, _j, _len, _len1, _ref1, _ref2, _ref3, _ref4;
|
|||
|
|
if (util.is_empty(this.yaml_path_resolvers)) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
exact_paths = {};
|
|||
|
|
prefix_paths = [];
|
|||
|
|
if (current_node) {
|
|||
|
|
depth = this.resolver_prefix_paths.length;
|
|||
|
|
_ref1 = this.resolver_prefix_paths.slice(-1)[0];
|
|||
|
|
for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
|
|||
|
|
_ref2 = _ref1[_i], path = _ref2[0], kind = _ref2[1];
|
|||
|
|
if (this.check_resolver_prefix(depth, path, kind, current_node, current_index)) {
|
|||
|
|
if (path.length > depth) {
|
|||
|
|
prefix_paths.push([ path, kind ]);
|
|||
|
|
} else {
|
|||
|
|
exact_paths[kind] = this.yaml_path_resolvers[path][kind];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
_ref3 = this.yaml_path_resolvers;
|
|||
|
|
for (_j = 0, _len1 = _ref3.length; _j < _len1; _j++) {
|
|||
|
|
_ref4 = _ref3[_j], path = _ref4[0], kind = _ref4[1];
|
|||
|
|
if (!path) {
|
|||
|
|
exact_paths[kind] = this.yaml_path_resolvers[path][kind];
|
|||
|
|
} else {
|
|||
|
|
prefix_paths.push([ path, kind ]);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
this.resolver_exact_paths.push(exact_paths);
|
|||
|
|
return this.resolver_prefix_paths.push(prefix_paths);
|
|||
|
|
};
|
|||
|
|
BaseResolver.prototype.ascend_resolver = function() {
|
|||
|
|
if (util.is_empty(this.yaml_path_resolvers)) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
this.resolver_exact_paths.pop();
|
|||
|
|
return this.resolver_prefix_paths.pop();
|
|||
|
|
};
|
|||
|
|
BaseResolver.prototype.check_resolver_prefix = function(depth, path, kind, current_node, current_index) {
|
|||
|
|
var index_check, node_check, _ref1;
|
|||
|
|
_ref1 = path[depth - 1], node_check = _ref1[0], index_check = _ref1[1];
|
|||
|
|
if (typeof node_check === "string") {
|
|||
|
|
if (current_node.tag !== node_check) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
} else if (node_check !== null) {
|
|||
|
|
if (!(current_node instanceof node_check)) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (index_check === true && current_index !== null) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
if ((index_check === false || index_check === null) && current_index === null) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
if (typeof index_check === "string") {
|
|||
|
|
if (!(current_index instanceof nodes.ScalarNode) && index_check === current_index.value) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
} else if (typeof index_check === "number") {
|
|||
|
|
if (index_check !== current_index) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return true;
|
|||
|
|
};
|
|||
|
|
BaseResolver.prototype.resolve = function(kind, value, implicit) {
|
|||
|
|
var empty, exact_paths, k, regexp, resolvers, tag, _i, _len, _ref1, _ref2, _ref3, _ref4;
|
|||
|
|
if (kind === nodes.ScalarNode && implicit[0]) {
|
|||
|
|
if (value === "") {
|
|||
|
|
resolvers = (_ref1 = this.yaml_implicit_resolvers[""]) != null ? _ref1 : [];
|
|||
|
|
} else {
|
|||
|
|
resolvers = (_ref2 = this.yaml_implicit_resolvers[value[0]]) != null ? _ref2 : [];
|
|||
|
|
}
|
|||
|
|
resolvers = resolvers.concat((_ref3 = this.yaml_implicit_resolvers[null]) != null ? _ref3 : []);
|
|||
|
|
for (_i = 0, _len = resolvers.length; _i < _len; _i++) {
|
|||
|
|
_ref4 = resolvers[_i], tag = _ref4[0], regexp = _ref4[1];
|
|||
|
|
if (value.match(regexp)) {
|
|||
|
|
return tag;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
implicit = implicit[1];
|
|||
|
|
}
|
|||
|
|
empty = true;
|
|||
|
|
for (k in this.yaml_path_resolvers) {
|
|||
|
|
if ({}[k] == null) {
|
|||
|
|
empty = false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (!empty) {
|
|||
|
|
exact_paths = this.resolver_exact_paths.slice(-1)[0];
|
|||
|
|
if (__indexOf.call(exact_paths, kind) >= 0) {
|
|||
|
|
return exact_paths[kind];
|
|||
|
|
}
|
|||
|
|
if (__indexOf.call(exact_paths, null) >= 0) {
|
|||
|
|
return exact_paths[null];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (kind === nodes.ScalarNode) {
|
|||
|
|
return DEFAULT_SCALAR_TAG;
|
|||
|
|
}
|
|||
|
|
if (kind === nodes.SequenceNode) {
|
|||
|
|
return DEFAULT_SEQUENCE_TAG;
|
|||
|
|
}
|
|||
|
|
if (kind === nodes.MappingNode) {
|
|||
|
|
return DEFAULT_MAPPING_TAG;
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
return BaseResolver;
|
|||
|
|
}();
|
|||
|
|
this.Resolver = function(_super) {
|
|||
|
|
__extends(Resolver, _super);
|
|||
|
|
function Resolver() {
|
|||
|
|
_ref1 = Resolver.__super__.constructor.apply(this, arguments);
|
|||
|
|
return _ref1;
|
|||
|
|
}
|
|||
|
|
return Resolver;
|
|||
|
|
}(this.BaseResolver);
|
|||
|
|
this.Resolver.add_implicit_resolver("tag:yaml.org,2002:bool", /^(?:yes|Yes|YES|true|True|TRUE|on|On|ON|no|No|NO|false|False|FALSE|off|Off|OFF)$/, "yYnNtTfFoO");
|
|||
|
|
this.Resolver.add_implicit_resolver("tag:yaml.org,2002:float", /^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+][0-9]+)?|\.[0-9_]+(?:[eE][-+][0-9]+)?|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*|[-+]?\.(?:inf|Inf|INF)|\.(?:nan|NaN|NAN))$/, "-+0123456789.");
|
|||
|
|
this.Resolver.add_implicit_resolver("tag:yaml.org,2002:int", /^(?:[-+]?0b[01_]+|[-+]?0[0-7_]+|[-+]?(?:0|[1-9][0-9_]*)|[-+]?0x[0-9a-fA-F_]+|[-+]?0o[0-7_]+|[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$/, "-+0123456789");
|
|||
|
|
this.Resolver.add_implicit_resolver("tag:yaml.org,2002:merge", /^(?:<<)$/, "<");
|
|||
|
|
this.Resolver.add_implicit_resolver("tag:yaml.org,2002:null", /^(?:~|null|Null|NULL|)$/, [ "~", "n", "N", "" ]);
|
|||
|
|
this.Resolver.add_implicit_resolver("tag:yaml.org,2002:timestamp", /^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]|[0-9][0-9][0-9][0-9]-[0-9][0-9]?-[0-9][0-9]?(?:[Tt]|[\x20\t]+)[0-9][0-9]?:[0-9][0-9]:[0-9][0-9](?:\.[0-9]*)?(?:[\x20\t]*(?:Z|[-+][0-9][0-9]?(?::[0-9][0-9])?))?)$/, "0123456789");
|
|||
|
|
this.Resolver.add_implicit_resolver("tag:yaml.org,2002:value", /^(?:=)$/, "=");
|
|||
|
|
this.Resolver.add_implicit_resolver("tag:yaml.org,2002:yaml", /^(?:!|&|\*)$/, "!&*");
|
|||
|
|
}).call(this);
|
|||
|
|
});
|
|||
|
|
register({
|
|||
|
|
"0": [ "./loader" ]
|
|||
|
|
}, 0, function(global, module, exports, require, window) {
|
|||
|
|
(function() {
|
|||
|
|
var composer, constructor, parser, reader, resolver, scanner, util;
|
|||
|
|
util = require("./util");
|
|||
|
|
reader = require("./reader");
|
|||
|
|
scanner = require("./scanner");
|
|||
|
|
parser = require("./parser");
|
|||
|
|
composer = require("./composer");
|
|||
|
|
resolver = require("./resolver");
|
|||
|
|
constructor = require("./constructor");
|
|||
|
|
this.make_loader = function(Reader, Scanner, Parser, Composer, Resolver, Constructor) {
|
|||
|
|
if (Reader == null) {
|
|||
|
|
Reader = reader.Reader;
|
|||
|
|
}
|
|||
|
|
if (Scanner == null) {
|
|||
|
|
Scanner = scanner.Scanner;
|
|||
|
|
}
|
|||
|
|
if (Parser == null) {
|
|||
|
|
Parser = parser.Parser;
|
|||
|
|
}
|
|||
|
|
if (Composer == null) {
|
|||
|
|
Composer = composer.Composer;
|
|||
|
|
}
|
|||
|
|
if (Resolver == null) {
|
|||
|
|
Resolver = resolver.Resolver;
|
|||
|
|
}
|
|||
|
|
if (Constructor == null) {
|
|||
|
|
Constructor = constructor.Constructor;
|
|||
|
|
}
|
|||
|
|
return function() {
|
|||
|
|
var component, components;
|
|||
|
|
components = [ Reader, Scanner, Parser, Composer, Resolver, Constructor ];
|
|||
|
|
util.extend.apply(util, [ _Class.prototype ].concat(function() {
|
|||
|
|
var _i, _len, _results;
|
|||
|
|
_results = [];
|
|||
|
|
for (_i = 0, _len = components.length; _i < _len; _i++) {
|
|||
|
|
component = components[_i];
|
|||
|
|
_results.push(component.prototype);
|
|||
|
|
}
|
|||
|
|
return _results;
|
|||
|
|
}()));
|
|||
|
|
function _Class(stream) {
|
|||
|
|
var _i, _len, _ref;
|
|||
|
|
components[0].call(this, stream);
|
|||
|
|
_ref = components.slice(1);
|
|||
|
|
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
|
|||
|
|
component = _ref[_i];
|
|||
|
|
component.call(this);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return _Class;
|
|||
|
|
}();
|
|||
|
|
};
|
|||
|
|
this.Loader = this.make_loader();
|
|||
|
|
}).call(this);
|
|||
|
|
});
|
|||
|
|
register({
|
|||
|
|
"": [ "yaml" ]
|
|||
|
|
}, 0, function(global, module, exports, require, window) {
|
|||
|
|
(function() {
|
|||
|
|
var fs;
|
|||
|
|
this.composer = require("./composer");
|
|||
|
|
this.constructor = require("./constructor");
|
|||
|
|
this.errors = require("./errors");
|
|||
|
|
this.events = require("./events");
|
|||
|
|
this.loader = require("./loader");
|
|||
|
|
this.nodes = require("./nodes");
|
|||
|
|
this.parser = require("./parser");
|
|||
|
|
this.reader = require("./reader");
|
|||
|
|
this.resolver = require("./resolver");
|
|||
|
|
this.scanner = require("./scanner");
|
|||
|
|
this.tokens = require("./tokens");
|
|||
|
|
this.scan = function(stream, Loader) {
|
|||
|
|
var loader, _results;
|
|||
|
|
if (Loader == null) {
|
|||
|
|
Loader = exports.loader.Loader;
|
|||
|
|
}
|
|||
|
|
loader = new Loader(stream);
|
|||
|
|
_results = [];
|
|||
|
|
while (loader.check_token()) {
|
|||
|
|
_results.push(loader.get_token());
|
|||
|
|
}
|
|||
|
|
return _results;
|
|||
|
|
};
|
|||
|
|
this.parse = function(stream, Loader) {
|
|||
|
|
var loader, _results;
|
|||
|
|
if (Loader == null) {
|
|||
|
|
Loader = exports.loader.Loader;
|
|||
|
|
}
|
|||
|
|
loader = new Loader(stream);
|
|||
|
|
_results = [];
|
|||
|
|
while (loader.check_event()) {
|
|||
|
|
_results.push(loader.get_event());
|
|||
|
|
}
|
|||
|
|
return _results;
|
|||
|
|
};
|
|||
|
|
this.compose = function(stream, Loader) {
|
|||
|
|
var loader;
|
|||
|
|
if (Loader == null) {
|
|||
|
|
Loader = exports.loader.Loader;
|
|||
|
|
}
|
|||
|
|
loader = new Loader(stream);
|
|||
|
|
return loader.get_single_node();
|
|||
|
|
};
|
|||
|
|
this.compose_all = function(stream, Loader) {
|
|||
|
|
var loader, _results;
|
|||
|
|
if (Loader == null) {
|
|||
|
|
Loader = exports.loader.Loader;
|
|||
|
|
}
|
|||
|
|
loader = new Loader(stream);
|
|||
|
|
_results = [];
|
|||
|
|
while (loader.check_node()) {
|
|||
|
|
_results.push(loader.get_node());
|
|||
|
|
}
|
|||
|
|
return _results;
|
|||
|
|
};
|
|||
|
|
this.load = function(stream, Loader) {
|
|||
|
|
var loader;
|
|||
|
|
if (Loader == null) {
|
|||
|
|
Loader = exports.loader.Loader;
|
|||
|
|
}
|
|||
|
|
loader = new Loader(stream);
|
|||
|
|
return loader.get_single_data();
|
|||
|
|
};
|
|||
|
|
this.load_all = function(stream, Loader) {
|
|||
|
|
var loader, _results;
|
|||
|
|
if (Loader == null) {
|
|||
|
|
Loader = exports.loader.Loader;
|
|||
|
|
}
|
|||
|
|
loader = new Loader(stream);
|
|||
|
|
_results = [];
|
|||
|
|
while (loader.check_data()) {
|
|||
|
|
_results.push(loader.get_data());
|
|||
|
|
}
|
|||
|
|
return _results;
|
|||
|
|
};
|
|||
|
|
if (typeof require !== "undefined" && require !== null && require.extensions) {
|
|||
|
|
fs = require("fs");
|
|||
|
|
require.extensions[".yml"] = require.extensions[".yaml"] = function(module, filename) {
|
|||
|
|
return module.exports = exports.load_all(fs.readFileSync(filename, "utf8"));
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
}).call(this);
|
|||
|
|
});
|
|||
|
|
root["yaml"] = require_from(null, "")("yaml");
|
|||
|
|
}).call(this);
|