Performance Test Generator.postman_collection.json

{
	"info": {
		"_postman_id": "09ac3e6b-f226-4f23-bdff-1175fadebd74",
		"name": "Performance Tests",
		"schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
	},
	"item": [
		{
			"name": "API Validation",
			"item": [
				{
					"name": "Validate API In Workspace",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"let apiIds = pm.environment.get('env-apiIds');\r",
									"\r",
									"if (apiIds) {\r",
									"    let parsedApiIds;\r",
									"    try {\r",
									"        parsedApiIds = JSON.parse(apiIds);\r",
									"    }\r",
									"    catch (err) { }\r",
									"\r",
									"    if (parsedApiIds && Array.isArray(parsedApiIds) && parsedApiIds.length) {\r",
									"        pm.collectionVariables.set('coll-apiIds', JSON.stringify(parsedApiIds));\r",
									"    }\r",
									"    else {\r",
									"        pm.collectionVariables.set('coll-apiIds', JSON.stringify([apiIds]));\r",
									"    }\r",
									"}\r",
									"else {\r",
									"    const jsonData = pm.response.json();\r",
									"\r",
									"    let apiIds = [];\r",
									"    _.forEach(jsonData.apis, function (api) {\r",
									"        apiIds.push(api.id);\r",
									"    });\r",
									"\r",
									"    pm.collectionVariables.set('coll-apiIds', JSON.stringify(apiIds));\r",
									"}"
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									"let apiIds =pm.environment.get('env-apiIds');\r",
									"if(apiIds){\r",
									"    pm.request.url = 'https://postman-echo.com/delay/0';        \r",
									"}"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "noauth"
						},
						"method": "GET",
						"header": [
							{
								"key": "X-Api-Key",
								"value": "{{env-apiKey}}",
								"type": "text"
							}
						],
						"url": {
							"raw": "https://api.getpostman.com/apis?workspace={{env-workspaceId}}",
							"protocol": "https",
							"host": [
								"api",
								"getpostman",
								"com"
							],
							"path": [
								"apis"
							],
							"query": [
								{
									"key": "workspace",
									"value": "{{env-workspaceId}}"
								}
							]
						}
					},
					"response": []
				},
				{
					"name": "Get Current API Version",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"const jsonData = pm.response.json();\r",
									"\r",
									"pm.test('API has one or more versions', function(){\r",
									"    pm.expect(jsonData).to.have.property('versions').and.to.be.an('array');\r",
									"    pm.expect(jsonData.versions.length).to.be.above(0);\r",
									"});\r",
									"\r",
									"const version = jsonData.versions[0];\r",
									"pm.collectionVariables.set('coll-versionId', version.id);"
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									"let apiIds = pm.collectionVariables.get('coll-apiIds');\r",
									"if(apiIds){\r",
									"    apiIds = JSON.parse(apiIds);\r",
									"    const apiId = apiIds.pop();\r",
									"\r",
									"    pm.collectionVariables.set('coll-apiId', apiId);\r",
									"    pm.collectionVariables.set('coll-apiIds', JSON.stringify(apiIds));\r",
									"}\r",
									"else {\r",
									"    pm.request.url = 'https://postman-echo.com/delay/0'\r",
									"    pm.request.name = 'No APIs found. Skipping execution';\r",
									"    postman.setNextRequest(null);\r",
									"}"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "noauth"
						},
						"method": "GET",
						"header": [
							{
								"key": "X-Api-Key",
								"value": "{{env-apiKey}}",
								"type": "text"
							}
						],
						"url": {
							"raw": "https://api.getpostman.com/apis/:apiId/versions",
							"protocol": "https",
							"host": [
								"api",
								"getpostman",
								"com"
							],
							"path": [
								"apis",
								":apiId",
								"versions"
							],
							"query": [
								{
									"key": null,
									"value": "",
									"disabled": true
								}
							],
							"variable": [
								{
									"key": "apiId",
									"value": "{{coll-apiId}}"
								}
							]
						}
					},
					"response": []
				},
				{
					"name": "Get Current API Schema",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"const jsonData = pm.response.json();\r",
									"\r",
									"pm.test('Has schema for current version', function(){\r",
									"    pm.expect(jsonData).to.have.property('version');\r",
									"    pm.expect(jsonData.version).to.have.property('schema').and.to.be.an('array');\r",
									"    pm.expect(jsonData.version.schema.length).to.be.above(0);\r",
									"\r",
									"    pm.collectionVariables.set('coll-schemaId', jsonData.version.schema[0]);\r",
									"});"
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "noauth"
						},
						"method": "GET",
						"header": [
							{
								"key": "X-Api-Key",
								"type": "text",
								"value": "{{env-apiKey}}"
							}
						],
						"url": {
							"raw": "https://api.getpostman.com/apis/:apiId/versions/:versionId",
							"protocol": "https",
							"host": [
								"api",
								"getpostman",
								"com"
							],
							"path": [
								"apis",
								":apiId",
								"versions",
								":versionId"
							],
							"query": [
								{
									"key": null,
									"value": "",
									"disabled": true
								}
							],
							"variable": [
								{
									"key": "apiId",
									"value": "{{coll-apiId}}"
								},
								{
									"key": "versionId",
									"value": "{{coll-versionId}}"
								}
							]
						}
					},
					"response": []
				},
				{
					"name": "Get API Schema",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"try {\r",
									"    const jsonData = pm.response.json();\r",
									"\r",
									"    if (jsonData.schema.language.toLowerCase() == 'json') {\r",
									"        pm.test('Schema is JSON', function () {\r",
									"            pm.expect(1).to.equal(1);\r",
									"        });\r",
									"    }\r",
									"    else {\r",
									"        pm.test('Schema translates to JSON', function () {\r",
									"            try {\r",
									"                const yaml = pm.collectionVariables.get('coll-yamlToJson');\r",
									"                (new Function(yaml))();\r",
									"\r",
									"                const schema = jsyaml.load(jsonData.schema.schema);\r",
									"                pm.collectionVariables.set('coll-schema', JSON.stringify(schema));\r",
									"                pm.expect(1).to.equal(1);\r",
									"\r",
									"                const server = pm.environment.get('env-server');\r",
									"                pm.test('Environment has test server defined', function () {\r",
									"                    pm.expect(server).to.not.be.undefined;\r",
									"                });\r",
									"\r",
									"                pm.test('Schema has server/baseUrl defined', function () {\r",
									"                    const servers = schema.servers;\r",
									"                    pm.expect(servers).to.not.be.undefined;\r",
									"                    const serverToTest = servers.find(s => s.description.toLowerCase() == server.toLowerCase());\r",
									"                    pm.expect(serverToTest).to.not.be.undefined;\r",
									"\r",
									"                    pm.expect(serverToTest).to.have.property('url');\r",
									"                    pm.collectionVariables.set('coll-baseUrl', serverToTest.url);\r",
									"                });\r",
									"            }\r",
									"            catch (err) {\r",
									"                pm.expect(1).to.equal(0);\r",
									"            }\r",
									"        });\r",
									"    }\r",
									"}\r",
									"catch (err) {\r",
									"    console.log(err);\r",
									"    pm.test('Unable to load schema', function () {\r",
									"        pm.expect(0).to.equal(1);\r",
									"        postman.setNextRequest(null);\r",
									"    })\r",
									"}"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "noauth"
						},
						"method": "GET",
						"header": [
							{
								"key": "X-Api-Key",
								"value": "{{env-apiKey}}",
								"type": "text"
							}
						],
						"url": {
							"raw": "https://api.getpostman.com/apis/:apiId/versions/:apiVersionId/schemas/:schemaId",
							"protocol": "https",
							"host": [
								"api",
								"getpostman",
								"com"
							],
							"path": [
								"apis",
								":apiId",
								"versions",
								":apiVersionId",
								"schemas",
								":schemaId"
							],
							"variable": [
								{
									"key": "apiId",
									"value": "{{coll-apiId}}"
								},
								{
									"key": "apiVersionId",
									"value": "{{coll-versionId}}"
								},
								{
									"key": "schemaId",
									"value": "{{coll-schemaId}}"
								}
							]
						}
					},
					"response": []
				}
			]
		},
		{
			"name": "Performance Tests",
			"item": [
				{
					"name": "Build Performance Tests",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									"const schema = JSON.parse(pm.collectionVariables.get('coll-schema'));\r",
									"\r",
									"let performanceTests = [];\r",
									"for (let prop in schema.paths) {\r",
									"    const updatedPath  = prop;\r",
									"    let path = {\r",
									"        path: `${pm.collectionVariables.get('coll-baseUrl')}${updatedPath}`,\r",
									"        parameters: schema.paths[prop].parameters,\r",
									"    };\r",
									"\r",
									"    for (let method in schema.paths[prop]) {\r",
									"        if (method.toLowerCase() == 'parameters') {\r",
									"            continue;\r",
									"        }\r",
									"\r",
									"        let currentPath = _.cloneDeep(path);\r",
									"        currentPath.method = method.toUpperCase();\r",
									"        let pathMethod = schema.paths[prop][method];\r",
									"        let securityExtension = pm.environment.get('env-securityExtensionName');\r",
									"        if (securityExtension && pathMethod[securityExtension] && pathMethod[securityExtension].length > 0) {\r",
									"            currentPath.allowedRole = pathMethod[securityExtension][0];\r",
									"        }\r",
									"\r",
									"        let performanceTest = _.cloneDeep(currentPath);\r",
									"        performanceTest.name = `${performanceTest.method} - ${updatedPath}`;\r",
									"        performanceTest.responses = getExpectedResponses(pathMethod);\r",
									"\r",
									"        performanceTest.bodies = [];\r",
									"        if (pathMethod.requestBody) {\r",
									"            let bodyModel;\r",
									"            if (pathMethod.requestBody.content['application/json'].schema.$ref) {\r",
									"                bodyModel = getSchemaReference(schema, pathMethod.requestBody.content['application/json'].schema.$ref);\r",
									"            }\r",
									"            else {\r",
									"                bodyModel = pathMethod.requestBody.content['application/json'].schema\r",
									"            }\r",
									"            const models = buildModels(schema, bodyModel);\r",
									"\r",
									"            performanceTest.bodies = models;\r",
									"        }\r",
									"        performanceTests.push(performanceTest);\r",
									"    }\r",
									"}\r",
									"\r",
									"pm.collectionVariables.set('coll-performanceTests', JSON.stringify(performanceTests));\r",
									"pm.collectionVariables.unset('coll-stats');\r",
									"\r",
									"//\r",
									"// Supporting Methods Below\r",
									"//\r",
									"function buildModels(schema, object) {\r",
									"    let models = [];\r",
									"\r",
									"    if (object['$ref']) {\r",
									"        object = getSchemaReference(schema, object['$ref']);\r",
									"    }\r",
									"\r",
									"    if (object.type && object.type.toLowerCase() == 'object') {\r",
									"        models.push({});\r",
									"        for (const [key, property] of Object.entries(object.properties)) {\r",
									"            if (property.type && ['string', 'number', 'integer', 'boolean'].includes(property.type.toLowerCase())) {\r",
									"                for (let modelIndex = 0; modelIndex < models.length; modelIndex++) {\r",
									"                    let model = models[modelIndex];\r",
									"                    model[key] = property.example;\r",
									"                }\r",
									"            }\r",
									"            else {\r",
									"                const nestedObjects = buildModels(schema, property);\r",
									"                models = addToModels(models, nestedObjects, key);\r",
									"            }\r",
									"        };\r",
									"    }\r",
									"    else if (object.type && object.type.toLowerCase() == 'array') {\r",
									"        let items = buildModels(schema, object.items);\r",
									"        if (Array.isArray(items)) {\r",
									"            for (let i = 0; i < items.length; i++) {\r",
									"                models.push([items[i]]);\r",
									"            }\r",
									"        }\r",
									"        else {\r",
									"            models.push([items]);\r",
									"        }\r",
									"    }\r",
									"    else if (object.oneOf) {\r",
									"        _.forEach(object.oneOf, function (component) {\r",
									"            let items = buildModels(schema, component);\r",
									"            models = models.concat(items);\r",
									"        });\r",
									"    }\r",
									"    else if (object.allOf) {\r",
									"        let pieces = [{}];\r",
									"        _.forEach(object.allOf, function (component) {\r",
									"            let componentModels = buildModels(schema, component);\r",
									"            pieces = addToModels(pieces, componentModels);\r",
									"        });\r",
									"\r",
									"        models = pieces;\r",
									"    }\r",
									"    else if (object.anyOf) {\r",
									"        let pieces = [];\r",
									"        let combinedPieces = [{}];\r",
									"        _.forEach(object.anyOf, function (component) {\r",
									"            let componentModels = buildModels(schema, component);\r",
									"            combinedPieces = addToModels(combinedPieces, componentModels);\r",
									"            pieces = pieces.concat(componentModels);\r",
									"        });\r",
									"\r",
									"        models = pieces.concat(combinedPieces);\r",
									"    }\r",
									"    else {\r",
									"        // All other options are primitive values\r",
									"        return object.example;\r",
									"    }\r",
									"    return models;\r",
									"}\r",
									"\r",
									"function getSchemaReference(schema, referenceName) {\r",
									"    const refPieces = referenceName.split('/');\r",
									"    let reference = schema;\r",
									"    for (let i = 1; i < refPieces.length; i++) {\r",
									"        reference = reference[refPieces[i]];\r",
									"    }\r",
									"\r",
									"    return reference;\r",
									"}\r",
									"\r",
									"function addToModels(models, newPieces, name) {\r",
									"    let newModels = [];\r",
									"    _.forEach(models, function (model) {\r",
									"        _.forEach(newPieces, function (newPiece) {\r",
									"            let newModel = _.cloneDeep(model);\r",
									"            if (name) {\r",
									"                newModel[name] = newPiece;\r",
									"            }\r",
									"            else {\r",
									"                Object.assign(newModel, newPiece);\r",
									"            }\r",
									"            newModels.push(newModel);\r",
									"        });\r",
									"    });\r",
									"\r",
									"    return newModels;\r",
									"}\r",
									"\r",
									"function replacePathParameters(schema, pathName) {\r",
									"    let replacedPathName = pathName;\r",
									"    let pathVariableRegex = /{([^}]*)}/g;\r",
									"    let matches = pathName.match(pathVariableRegex);\r",
									"    _.forEach(matches, function (match) {\r",
									"        let paramName = match.substring(1, match.length - 1);\r",
									"        let parameter = schema.components.parameters[paramName];\r",
									"\r",
									"        let parameterValue = encodeURIComponent(parameter.schema.example);\r",
									"        replacedPathName = replacedPathName.replace(match, parameterValue);\r",
									"    });\r",
									"\r",
									"    return replacedPathName;\r",
									"}\r",
									"\r",
									"function getExpectedResponses(pathMethod){\r",
									"    const responses = [];\r",
									"        for(const [statusCode, value] of Object.entries(pathMethod.responses)){\r",
									"            let response = {\r",
									"                statusCode: Number(statusCode)\r",
									"            };\r",
									"\r",
									"            if(value['x-postman-variables'] && Array.isArray(value['x-postman-variables'])){\r",
									"                response.variables = value['x-postman-variables'].filter(variable => variable.type.toLowerCase() === 'save');\r",
									"            }\r",
									"\r",
									"            if(value.$ref){\r",
									"                response.$ref = value.$ref;                \r",
									"            }\r",
									"            else\r",
									"            {\r",
									"                if(value.content && value.content['application/json'] && value.content['application/json'].schema){\r",
									"                    if(value.content['application/json'].schema.$ref){\r",
									"                       response.$ref = value.content['application/json'].schema.$ref;                        \r",
									"                    }\r",
									"                    else {\r",
									"                       response.schema = value.content['application/json'].schema;\r",
									"                    }\r",
									"                }\r",
									"            }            \r",
									"\r",
									"            responses.push(response);\r",
									"        }\r",
									"    return responses;\r",
									"}"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "noauth"
						},
						"method": "GET",
						"header": [],
						"url": {
							"raw": "https://postman-echo.com/delay/0",
							"protocol": "https",
							"host": [
								"postman-echo",
								"com"
							],
							"path": [
								"delay",
								"0"
							]
						}
					},
					"response": []
				},
				{
					"name": "Run Performance Test",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									"const url = require('url');\r",
									"const schema = JSON.parse(pm.collectionVariables.get('coll-schema'));\r",
									"let currentPerformanceTest = pm.variables.get('currentPerformanceTest');\r",
									"if(!currentPerformanceTest){\r",
									"    let performanceTests = JSON.parse(pm.collectionVariables.get('coll-performanceTests'));\r",
									"\r",
									"    currentPerformanceTest = performanceTests.shift();\r",
									"    pm.collectionVariables.set('coll-performanceTests', JSON.stringify(performanceTests));\r",
									"    pm.variables.set('currentPerformanceTest', JSON.stringify(currentPerformanceTest));\r",
									"}\r",
									"else {\r",
									"    currentPerformanceTest = JSON.parse(currentPerformanceTest);\r",
									"}\r",
									"\r",
									"const path = replacePathParameters(schema, currentPerformanceTest.path, currentPerformanceTest.parameters);\r",
									"pm.request.url.update(path);\r",
									"delete pm.request.url.auth;\r",
									"delete pm.request.url.port;\r",
									"delete pm.request.url.hash;\r",
									"pm.request.url.protocol = pm.request.url.protocol.replace(/\\:$/, '');\r",
									"pm.request.method = currentPerformanceTest.method;\r",
									"pm.request.name = currentPerformanceTest.name;\r",
									"\r",
									"pm.variables.set('requestName', currentPerformanceTest.name);\r",
									"request.name = currentPerformanceTest.name;\r",
									"\r",
									"if(currentPerformanceTest.parameters && currentPerformanceTest.parameters.length){\r",
									"    // Add top level parameters from the path\r",
									"    for(let i = 0; i < currentPerformanceTest.parameters.length; i++){\r",
									"        let param = currentPerformanceTest.parameters[i];\r",
									"        let pieces = param.$ref.split('/');\r",
									"        const name = pieces[pieces.length-1];\r",
									"\r",
									"        const schemaParam = schema.components.parameters[name];\r",
									"        if(schemaParam.in.toLowerCase() == 'header'){\r",
									"            let roleHeaderName = pm.environment.get('env-roleHeaderName');\r",
									"            if(roleHeaderName && schemaParam.name.toLowerCase() == roleHeaderName.toLowerCase()){\r",
									"                pm.request.headers.upsert({ key: schemaParam.name, value: currentPerformanceTest.allowedRole });    \r",
									"            } \r",
									"            else {\r",
									"                pm.request.headers.upsert({ key: schemaParam.name, value: schemaParam.schema.example });\r",
									"            }\r",
									"        }\r",
									"    }\r",
									"}\r",
									"\r",
									"let currentIterations = pm.variables.get('currentIterations');\r",
									"if(!currentIterations){\r",
									"    currentIterations = 0;\r",
									"}\r",
									"\r",
									"if(currentPerformanceTest.bodies.length){\r",
									"    const bodyIndex = (currentIterations % currentPerformanceTest.bodies.length);\r",
									"    const body = currentPerformanceTest.bodies[bodyIndex];\r",
									"    pm.variables.set('body', JSON.stringify(body));\r",
									"}\r",
									"\r",
									"pm.variables.set('currentIterations', (currentIterations + 1));\r",
									"\r",
									"function loadParameterValue(parameter){\r",
									"    let parameterValue;\r",
									"    if(parameter['x-postman-variables']){\r",
									"        let variable = parameter['x-postman-variables'].find(v => v.type.toLowerCase() === 'load');\r",
									"        if(variable && pm.collectionVariables.has(variable.name)){\r",
									"            parameterValue = pm.collectionVariables.get(variable.name);\r",
									"        }\r",
									"        else {\r",
									"            parameterValue = encodeURIComponent(parameter.schema.example ? parameter.schema.example : parameter.example);    \r",
									"        }\r",
									"    }\r",
									"    else {\r",
									"        parameterValue = encodeURIComponent(parameter.schema.example ? parameter.schema.example : parameter.example);\r",
									"    }\r",
									"\r",
									"    return parameterValue;\r",
									"}\r",
									"\r",
									"function replacePathParameters(schema, pathName, parameters){\r",
									"    let replacedPathName = pathName;\r",
									"    let pathVariableRegex = /{([^}]*)}/g;\r",
									"    let matches = pathName.match(pathVariableRegex);\r",
									"    _.forEach(matches, function(match){\r",
									"        let paramName = match.substring(1, match.length - 1);\r",
									"        _.forEach(parameters, function(param){\r",
									"            if(param.$ref){\r",
									"                let parameter = getSchemaReference(schema, param.$ref);                \r",
									"                if (parameter.in && parameter.in.toLowerCase() == 'path' && parameter.name && parameter.name == paramName){\r",
									"                    let parameterValue = loadParameterValue(parameter);\r",
									"                    replacedPathName = replacedPathName.replace(match, parameterValue);\r",
									"                    return false;\r",
									"                }\r",
									"            } else {\r",
									"                if (param.in && param.in.toLowerCase() == 'path' && param.name && param.name == paramName) {\r",
									"                    let parameterValue = loadParameterValue(param);\r",
									"                    replacedPathName = replacedPathName.replace(match, parameterValue);\r",
									"                    return false;\r",
									"                }\r",
									"            }\r",
									"        });    \r",
									"    });\r",
									"\r",
									"    return url.parse(replacedPathName);\r",
									"}\r",
									"\r",
									"function getSchemaReference(schema, referenceName){  \r",
									"  const refPieces = referenceName.split('/');\r",
									"  let reference = schema;\r",
									"  for(let i = 1; i < refPieces.length; i++){\r",
									"    reference = reference[refPieces[i]];\r",
									"  }\r",
									"\r",
									"  return reference;  \r",
									"}"
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"const performanceTests = JSON.parse(pm.collectionVariables.get('coll-performanceTests'));\r",
									"const currentIterations = pm.variables.get('currentIterations');\r",
									"const performanceIterationCount = Number(pm.environment.get('env-performanceIterations'));\r",
									"const currentPerformanceTest = JSON.parse(pm.variables.get('currentPerformanceTest'));\r",
									"if(currentIterations >= performanceIterationCount && performanceTests.length){\r",
									"    postman.setNextRequest('Run Performance Test');\r",
									"    pm.variables.unset('currentIterations');\r",
									"    pm.variables.unset('currentPerformanceTest');\r",
									"}\r",
									"else if (currentIterations < performanceIterationCount){\r",
									"    postman.setNextRequest(request.name);\r",
									"    setDynamicVariables(currentPerformanceTest);\r",
									"}\r",
									"\r",
									"// All calculations will be done at the end.\r",
									"\r",
									"\r",
									"let stats = pm.collectionVariables.get('coll-stats');\r",
									"if(!stats){\r",
									"    stats = [];\r",
									"}\r",
									"else {\r",
									"    stats = JSON.parse(stats);\r",
									"}\r",
									"console.log(currentPerformanceTest.name);\r",
									"let perfTestStats = stats.find(s => s.name === currentPerformanceTest.name);\r",
									"if(!perfTestStats){\r",
									"    perfTestStats = {\r",
									"        name: currentPerformanceTest.name,\r",
									"        responseTimes: [],\r",
									"        statusCodes: []\r",
									"    }\r",
									"    stats.push(perfTestStats);\r",
									"}\r",
									"\r",
									"perfTestStats.statusCodes.push(pm.response.code);\r",
									"perfTestStats.responseTimes.push(pm.response.responseTime);\r",
									"\r",
									"pm.collectionVariables.set('coll-stats', JSON.stringify(stats));\r",
									"\r",
									"function setDynamicVariables(currentPerformanceTest){\r",
									"    const expectedResponse = currentPerformanceTest.responses.find(r => r.statusCode == pm.response.code);\r",
									"    if(expectedResponse.variables){\r",
									"        const jsonData = pm.response.json();\r",
									"        _.forEach(expectedResponse.variables, function(variable){\r",
									"            let pathPieces = variable.path.split('.').filter(piece => piece);\r",
									"            let data = jsonData;\r",
									"            let found = true;\r",
									"            _.forEach(pathPieces, function(piece){\r",
									"                if(data[piece]){\r",
									"                    data = data[piece];\r",
									"                }\r",
									"                else {\r",
									"                    found = false;\r",
									"                }\r",
									"            });\r",
									"\r",
									"            if(found){\r",
									"                pm.collectionVariables.set(variable.name, data);\r",
									"            }\r",
									"            else {\r",
									"                pm.test(`Unable to save dynamic variable ${variable.name} at the provided path.`, function() {\r",
									"                    pm.expect(true).to.equal(variable.path);\r",
									"                });\r",
									"            }\r",
									"        });\r",
									"    }\r",
									"}"
								],
								"type": "text/javascript"
							}
						}
					],
					"protocolProfileBehavior": {
						"disableBodyPruning": true
					},
					"request": {
						"method": "GET",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{{body}}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "https://postman-echo.com/get",
							"protocol": "https",
							"host": [
								"postman-echo",
								"com"
							],
							"path": [
								"get"
							]
						}
					},
					"response": []
				},
				{
					"name": "Analyze Performance Results",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"const stats = JSON.parse(pm.collectionVariables.get('coll-stats'));\r",
									"const averageThreshold = Number(pm.environment.get('env-performanceAverageMs'));\r",
									"const p99Threshold = Number(pm.environment.get('env-performanceP99Ms'));\r",
									"_.forEach(stats, (stat) => {\r",
									"    const average = stat.responseTimes.reduce((a,b) => a + b, 0) / stat.responseTimes.length;\r",
									"    const p99 = _.sortBy(stat.responseTimes)[stat.responseTimes.length - 1];\r",
									"    pm.test(`${stat.name}: Average execution time (${average}ms) is less than ${averageThreshold}ms`, function(){\r",
									"        pm.expect(average).to.be.below(averageThreshold);\r",
									"    });\r",
									"\r",
									"    pm.test(`${stat.name}: Slowest execution (${p99}ms) is less than ${p99Threshold}ms`, function(){\r",
									"        pm.expect(p99).to.be.below(p99Threshold);\r",
									"    });\r",
									"\r",
									"    const successCount = stat.statusCodes.filter(sc => sc < 300);\r",
									"    const successRate = (successCount.length / stat.statusCodes.length) * 100;\r",
									"    pm.test(`${stat.name}: Response success rate (${successRate}%) is greater than 50%`, function(){\r",
									"        pm.expect(successRate).to.be.above(49);\r",
									"    });\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "noauth"
						},
						"method": "GET",
						"header": [],
						"url": {
							"raw": "https://postman-echo.com/delay/0",
							"protocol": "https",
							"host": [
								"postman-echo",
								"com"
							],
							"path": [
								"delay",
								"0"
							]
						}
					},
					"response": []
				}
			]
		}
	],
	"event": [
		{
			"listen": "prerequest",
			"script": {
				"type": "text/javascript",
				"exec": [
					""
				]
			}
		},
		{
			"listen": "test",
			"script": {
				"type": "text/javascript",
				"exec": [
					""
				]
			}
		}
	],
	"variable": [
		{
			"key": "coll-apiIds",
			"value": ""
		},
		{
			"key": "coll-apiId",
			"value": ""
		},
		{
			"key": "coll-previousVersionId",
			"value": ""
		},
		{
			"key": "coll-versionId",
			"value": ""
		},
		{
			"key": "coll-schemaId",
			"value": ""
		},
		{
			"key": "coll-schema",
			"value": ""
		},
		{
			"key": "coll-schemaTests",
			"value": ""
		},
		{
			"key": "coll-baseUrl",
			"value": ""
		},
		{
			"key": "coll-performanceTests",
			"value": ""
		},
		{
			"key": "coll-yamlToJson",
			"value": "/* js-yaml 3.13.1 https://github.com/nodeca/js-yaml */(function(f){if(typeof exports===\"object\"&&typeof module!==\"undefined\"){module.exports=f()}else if(typeof define===\"function\"&&define.amd){define([],f)}else{var g;if(typeof window!==\"undefined\"){g=window}else if(typeof global!==\"undefined\"){g=global}else if(typeof self!==\"undefined\"){g=self}else{g=this}g.jsyaml = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){\n'use strict';\nvar loader = require('./js-yaml/loader');\nvar dumper = require('./js-yaml/dumper');\nfunction deprecated(name) {\n  return function () {\n    throw new Error('Function ' + name + ' is deprecated and cannot be used.');\n  };\n}\nmodule.exports.Type                = require('./js-yaml/type');\nmodule.exports.Schema              = require('./js-yaml/schema');\nmodule.exports.FAILSAFE_SCHEMA     = require('./js-yaml/schema/failsafe');\nmodule.exports.JSON_SCHEMA         = require('./js-yaml/schema/json');\nmodule.exports.CORE_SCHEMA         = require('./js-yaml/schema/core');\nmodule.exports.DEFAULT_SAFE_SCHEMA = require('./js-yaml/schema/default_safe');\nmodule.exports.DEFAULT_FULL_SCHEMA = require('./js-yaml/schema/default_full');\nmodule.exports.load                = loader.load;\nmodule.exports.loadAll             = loader.loadAll;\nmodule.exports.safeLoad            = loader.safeLoad;\nmodule.exports.safeLoadAll         = loader.safeLoadAll;\nmodule.exports.dump                = dumper.dump;\nmodule.exports.safeDump            = dumper.safeDump;\nmodule.exports.YAMLException       = require('./js-yaml/exception');\n// Deprecated schema names from JS-YAML 2.0.x\nmodule.exports.MINIMAL_SCHEMA = require('./js-yaml/schema/failsafe');\nmodule.exports.SAFE_SCHEMA    = require('./js-yaml/schema/default_safe');\nmodule.exports.DEFAULT_SCHEMA = require('./js-yaml/schema/default_full');\n// Deprecated functions from JS-YAML 1.x.x\nmodule.exports.scan           = deprecated('scan');\nmodule.exports.parse          = deprecated('parse');\nmodule.exports.compose        = deprecated('compose');\nmodule.exports.addConstructor = deprecated('addConstructor');\n},{\"./js-yaml/dumper\":3,\"./js-yaml/exception\":4,\"./js-yaml/loader\":5,\"./js-yaml/schema\":7,\"./js-yaml/schema/core\":8,\"./js-yaml/schema/default_full\":9,\"./js-yaml/schema/default_safe\":10,\"./js-yaml/schema/failsafe\":11,\"./js-yaml/schema/json\":12,\"./js-yaml/type\":13}],2:[function(require,module,exports){\n'use strict';\nfunction isNothing(subject) {\n  return (typeof subject === 'undefined') || (subject === null);\n}\nfunction isObject(subject) {\n  return (typeof subject === 'object') && (subject !== null);\n}\nfunction toArray(sequence) {\n  if (Array.isArray(sequence)) return sequence;\n  else if (isNothing(sequence)) return [];\n  return [ sequence ];\n}\nfunction extend(target, source) {\n  var index, length, key, sourceKeys;\n  if (source) {\n    sourceKeys = Object.keys(source);\n    for (index = 0, length = sourceKeys.length; index < length; index += 1) {\n      key = sourceKeys[index];\n      target[key] = source[key];\n    }\n  }\n  return target;\n}\nfunction repeat(string, count) {\n  var result = '', cycle;\n  for (cycle = 0; cycle < count; cycle += 1) {\n    result += string;\n  }\n  return result;\n}\nfunction isNegativeZero(number) {\n  return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number);\n}\nmodule.exports.isNothing      = isNothing;\nmodule.exports.isObject       = isObject;\nmodule.exports.toArray        = toArray;\nmodule.exports.repeat         = repeat;\nmodule.exports.isNegativeZero = isNegativeZero;\nmodule.exports.extend         = extend;\n},{}],3:[function(require,module,exports){\n'use strict';\n/*eslint-disable no-use-before-define*/\nvar common              = require('./common');\nvar YAMLException       = require('./exception');\nvar DEFAULT_FULL_SCHEMA = require('./schema/default_full');\nvar DEFAULT_SAFE_SCHEMA = require('./schema/default_safe');\nvar _toString       = Object.prototype.toString;\nvar _hasOwnProperty = Object.prototype.hasOwnProperty;\nvar CHAR_TAB                  = 0x09; /* Tab */\nvar CHAR_LINE_FEED            = 0x0A; /* LF */\nvar CHAR_SPACE                = 0x20; /* Space */\nvar CHAR_EXCLAMATION          = 0x21; /* ! */\nvar CHAR_DOUBLE_QUOTE         = 0x22; /* \" */\nvar CHAR_SHARP                = 0x23; /* # */\nvar CHAR_PERCENT              = 0x25; /* % */\nvar CHAR_AMPERSAND            = 0x26; /* & */\nvar CHAR_SINGLE_QUOTE         = 0x27; /* ' */\nvar CHAR_ASTERISK             = 0x2A; /* * */\nvar CHAR_COMMA                = 0x2C; /* , */\nvar CHAR_MINUS                = 0x2D; /* - */\nvar CHAR_COLON                = 0x3A; /* : */\nvar CHAR_GREATER_THAN         = 0x3E; /* > */\nvar CHAR_QUESTION             = 0x3F; /* ? */\nvar CHAR_COMMERCIAL_AT        = 0x40; /* @ */\nvar CHAR_LEFT_SQUARE_BRACKET  = 0x5B; /* [ */\nvar CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */\nvar CHAR_GRAVE_ACCENT         = 0x60; /* ` */\nvar CHAR_LEFT_CURLY_BRACKET   = 0x7B; /* { */\nvar CHAR_VERTICAL_LINE        = 0x7C; /* | */\nvar CHAR_RIGHT_CURLY_BRACKET  = 0x7D; /* } */\nvar ESCAPE_SEQUENCES = {};\nESCAPE_SEQUENCES[0x00]   = '\\\\0';\nESCAPE_SEQUENCES[0x07]   = '\\\\a';\nESCAPE_SEQUENCES[0x08]   = '\\\\b';\nESCAPE_SEQUENCES[0x09]   = '\\\\t';\nESCAPE_SEQUENCES[0x0A]   = '\\\\n';\nESCAPE_SEQUENCES[0x0B]   = '\\\\v';\nESCAPE_SEQUENCES[0x0C]   = '\\\\f';\nESCAPE_SEQUENCES[0x0D]   = '\\\\r';\nESCAPE_SEQUENCES[0x1B]   = '\\\\e';\nESCAPE_SEQUENCES[0x22]   = '\\\\\"';\nESCAPE_SEQUENCES[0x5C]   = '\\\\\\\\';\nESCAPE_SEQUENCES[0x85]   = '\\\\N';\nESCAPE_SEQUENCES[0xA0]   = '\\\\_';\nESCAPE_SEQUENCES[0x2028] = '\\\\L';\nESCAPE_SEQUENCES[0x2029] = '\\\\P';\nvar DEPRECATED_BOOLEANS_SYNTAX = [\n  'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON',\n  'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'\n];\nfunction compileStyleMap(schema, map) {\n  var result, keys, index, length, tag, style, type;\n  if (map === null) return {};\n  result = {};\n  keys = Object.keys(map);\n  for (index = 0, length = keys.length; index < length; index += 1) {\n    tag = keys[index];\n    style = String(map[tag]);\n    if (tag.slice(0, 2) === '!!') {\n      tag = 'tag:yaml.org,2002:' + tag.slice(2);\n    }\n    type = schema.compiledTypeMap['fallback'][tag];\n    if (type && _hasOwnProperty.call(type.styleAliases, style)) {\n      style = type.styleAliases[style];\n    }\n    result[tag] = style;\n  }\n  return result;\n}\nfunction encodeHex(character) {\n  var string, handle, length;\n  string = character.toString(16).toUpperCase();\n  if (character <= 0xFF) {\n    handle = 'x';\n    length = 2;\n  } else if (character <= 0xFFFF) {\n    handle = 'u';\n    length = 4;\n  } else if (character <= 0xFFFFFFFF) {\n    handle = 'U';\n    length = 8;\n  } else {\n    throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF');\n  }\n  return '\\\\' + handle + common.repeat('0', length - string.length) + string;\n}\nfunction State(options) {\n  this.schema        = options['schema'] || DEFAULT_FULL_SCHEMA;\n  this.indent        = Math.max(1, (options['indent'] || 2));\n  this.noArrayIndent = options['noArrayIndent'] || false;\n  this.skipInvalid   = options['skipInvalid'] || false;\n  this.flowLevel     = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']);\n  this.styleMap      = compileStyleMap(this.schema, options['styles'] || null);\n  this.sortKeys      = options['sortKeys'] || false;\n  this.lineWidth     = options['lineWidth'] || 80;\n  this.noRefs        = options['noRefs'] || false;\n  this.noCompatMode  = options['noCompatMode'] || false;\n  this.condenseFlow  = options['condenseFlow'] || false;\n  this.implicitTypes = this.schema.compiledImplicit;\n  this.explicitTypes = this.schema.compiledExplicit;\n  this.tag = null;\n  this.result = '';\n  this.duplicates = [];\n  this.usedDuplicates = null;\n}\n// Indents every line in a string. Empty lines (\\n only) are not indented.\nfunction indentString(string, spaces) {\n  var ind = common.repeat(' ', spaces),\n      position = 0,\n      next = -1,\n      result = '',\n      line,\n      length = string.length;\n  while (position < length) {\n    next = string.indexOf('\\n', position);\n    if (next === -1) {\n      line = string.slice(position);\n      position = length;\n    } else {\n      line = string.slice(position, next + 1);\n      position = next + 1;\n    }\n    if (line.length && line !== '\\n') result += ind;\n    result += line;\n  }\n  return result;\n}\nfunction generateNextLine(state, level) {\n  return '\\n' + common.repeat(' ', state.indent * level);\n}\nfunction testImplicitResolving(state, str) {\n  var index, length, type;\n  for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {\n    type = state.implicitTypes[index];\n    if (type.resolve(str)) {\n      return true;\n    }\n  }\n  return false;\n}\n// [33] s-white ::= s-space | s-tab\nfunction isWhitespace(c) {\n  return c === CHAR_SPACE || c === CHAR_TAB;\n}\n// Returns true if the character can be printed without escaping.\n// From YAML 1.2: \"any allowed characters known to be non-printable\n// should also be escaped. [However,] This isn’t mandatory\"\n// Derived from nb-char - \\t - #x85 - #xA0 - #x2028 - #x2029.\nfunction isPrintable(c) {\n  return  (0x00020 <= c && c <= 0x00007E)\n      || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029)\n      || ((0x0E000 <= c && c <= 0x00FFFD) && c !== 0xFEFF /* BOM */)\n      ||  (0x10000 <= c && c <= 0x10FFFF);\n}\n// Simplified test for values allowed after the first character in plain style.\nfunction isPlainSafe(c) {\n  // Uses a subset of nb-char - c-flow-indicator - \":\" - \"#\"\n  // where nb-char ::= c-printable - b-char - c-byte-order-mark.\n  return isPrintable(c) && c !== 0xFEFF\n    // - c-flow-indicator\n    && c !== CHAR_COMMA\n    && c !== CHAR_LEFT_SQUARE_BRACKET\n    && c !== CHAR_RIGHT_SQUARE_BRACKET\n    && c !== CHAR_LEFT_CURLY_BRACKET\n    && c !== CHAR_RIGHT_CURLY_BRACKET\n    // - \":\" - \"#\"\n    && c !== CHAR_COLON\n    && c !== CHAR_SHARP;\n}\n// Simplified test for values allowed as the first character in plain style.\nfunction isPlainSafeFirst(c) {\n  // Uses a subset of ns-char - c-indicator\n  // where ns-char = nb-char - s-white.\n  return isPrintable(c) && c !== 0xFEFF\n    && !isWhitespace(c) // - s-white\n    // - (c-indicator ::=\n    // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}”\n    && c !== CHAR_MINUS\n    && c !== CHAR_QUESTION\n    && c !== CHAR_COLON\n    && c !== CHAR_COMMA\n    && c !== CHAR_LEFT_SQUARE_BRACKET\n    && c !== CHAR_RIGHT_SQUARE_BRACKET\n    && c !== CHAR_LEFT_CURLY_BRACKET\n    && c !== CHAR_RIGHT_CURLY_BRACKET\n    // | “#” | “&” | “*” | “!” | “|” | “>” | “'” | “\"”\n    && c !== CHAR_SHARP\n    && c !== CHAR_AMPERSAND\n    && c !== CHAR_ASTERISK\n    && c !== CHAR_EXCLAMATION\n    && c !== CHAR_VERTICAL_LINE\n    && c !== CHAR_GREATER_THAN\n    && c !== CHAR_SINGLE_QUOTE\n    && c !== CHAR_DOUBLE_QUOTE\n    // | “%” | “@” | “`”)\n    && c !== CHAR_PERCENT\n    && c !== CHAR_COMMERCIAL_AT\n    && c !== CHAR_GRAVE_ACCENT;\n}\n// Determines whether block indentation indicator is required.\nfunction needIndentIndicator(string) {\n  var leadingSpaceRe = /^\\n* /;\n  return leadingSpaceRe.test(string);\n}\nvar STYLE_PLAIN   = 1,\n    STYLE_SINGLE  = 2,\n    STYLE_LITERAL = 3,\n    STYLE_FOLDED  = 4,\n    STYLE_DOUBLE  = 5;\n// Determines which scalar styles are possible and returns the preferred style.\n// lineWidth = -1 => no limit.\n// Pre-conditions: str.length > 0.\n// Post-conditions:\n//    STYLE_PLAIN or STYLE_SINGLE => no \\n are in the string.\n//    STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1).\n//    STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1).\nfunction chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType) {\n  var i;\n  var char;\n  var hasLineBreak = false;\n  var hasFoldableLine = false; // only checked if shouldTrackWidth\n  var shouldTrackWidth = lineWidth !== -1;\n  var previousLineBreak = -1; // count the first line correctly\n  var plain = isPlainSafeFirst(string.charCodeAt(0))\n          && !isWhitespace(string.charCodeAt(string.length - 1));\n  if (singleLineOnly) {\n    // Case: no block styles.\n    // Check for disallowed characters to rule out plain and single.\n    for (i = 0; i < string.length; i++) {\n      char = string.charCodeAt(i);\n      if (!isPrintable(char)) {\n        return STYLE_DOUBLE;\n      }\n      plain = plain && isPlainSafe(char);\n    }\n  } else {\n    // Case: block styles permitted.\n    for (i = 0; i < string.length; i++) {\n      char = string.charCodeAt(i);\n      if (char === CHAR_LINE_FEED) {\n        hasLineBreak = true;\n        // Check if any line can be folded.\n        if (shouldTrackWidth) {\n          hasFoldableLine = hasFoldableLine ||\n            // Foldable line = too long, and not more-indented.\n            (i - previousLineBreak - 1 > lineWidth &&\n             string[previousLineBreak + 1] !== ' ');\n          previousLineBreak = i;\n        }\n      } else if (!isPrintable(char)) {\n        return STYLE_DOUBLE;\n      }\n      plain = plain && isPlainSafe(char);\n    }\n    // in case the end is missing a \\n\n    hasFoldableLine = hasFoldableLine || (shouldTrackWidth &&\n      (i - previousLineBreak - 1 > lineWidth &&\n       string[previousLineBreak + 1] !== ' '));\n  }\n  // Although every style can represent \\n without escaping, prefer block styles\n  // for multiline, since they're more readable and they don't add empty lines.\n  // Also prefer folding a super-long line.\n  if (!hasLineBreak && !hasFoldableLine) {\n    // Strings interpretable as another type have to be quoted;\n    // e.g. the string 'true' vs. the boolean true.\n    return plain && !testAmbiguousType(string)\n      ? STYLE_PLAIN : STYLE_SINGLE;\n  }\n  // Edge case: block indentation indicator can only have one digit.\n  if (indentPerLevel > 9 && needIndentIndicator(string)) {\n    return STYLE_DOUBLE;\n  }\n  // At this point we know block styles are valid.\n  // Prefer literal style unless we want to fold.\n  return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;\n}\n// Note: line breaking/folding is implemented for only the folded style.\n// NB. We drop the last trailing newline (if any) of a returned block scalar\n//  since the dumper adds its own newline. This always works:\n//    • No ending newline => unaffected; already using strip \"-\" chomping.\n//    • Ending newline    => removed then restored.\n//  Importantly, this keeps the \"+\" chomp indicator from gaining an extra line.\nfunction writeScalar(state, string, level, iskey) {\n  state.dump = (function () {\n    if (string.length === 0) {\n      return \"''\";\n    }\n    if (!state.noCompatMode &&\n        DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1) {\n      return \"'\" + string + \"'\";\n    }\n    var indent = state.indent * Math.max(1, level); // no 0-indent scalars\n    // As indentation gets deeper, let the width decrease monotonically\n    // to the lower bound min(state.lineWidth, 40).\n    // Note that this implies\n    //  state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound.\n    //  state.lineWidth > 40 + state.indent: width decreases until the lower bound.\n    // This behaves better than a constant minimum width which disallows narrower options,\n    // or an indent threshold which causes the width to suddenly increase.\n    var lineWidth = state.lineWidth === -1\n      ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);\n    // Without knowing if keys are implicit/explicit, assume implicit for safety.\n    var singleLineOnly = iskey\n      // No block styles in flow mode.\n      || (state.flowLevel > -1 && level >= state.flowLevel);\n    function testAmbiguity(string) {\n      return testImplicitResolving(state, string);\n    }\n    switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity)) {\n      case STYLE_PLAIN:\n        return string;\n      case STYLE_SINGLE:\n        return \"'\" + string.replace(/'/g, \"''\") + \"'\";\n      case STYLE_LITERAL:\n        return '|' + blockHeader(string, state.indent)\n          + dropEndingNewline(indentString(string, indent));\n      case STYLE_FOLDED:\n        return '>' + blockHeader(string, state.indent)\n          + dropEndingNewline(indentString(foldString(string, lineWidth), indent));\n      case STYLE_DOUBLE:\n        return '\"' + escapeString(string, lineWidth) + '\"';\n      default:\n        throw new YAMLException('impossible error: invalid scalar style');\n    }\n  }());\n}\n// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9.\nfunction blockHeader(string, indentPerLevel) {\n  var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : '';\n  // note the special case: the string '\\n' counts as a \"trailing\" empty line.\n  var clip =          string[string.length - 1] === '\\n';\n  var keep = clip && (string[string.length - 2] === '\\n' || string === '\\n');\n  var chomp = keep ? '+' : (clip ? '' : '-');\n  return indentIndicator + chomp + '\\n';\n}\n// (See the note for writeScalar.)\nfunction dropEndingNewline(string) {\n  return string[string.length - 1] === '\\n' ? string.slice(0, -1) : string;\n}\n// Note: a long line without a suitable break point will exceed the width limit.\n// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0.\nfunction foldString(string, width) {\n  // In folded style, $k$ consecutive newlines output as $k+1$ newlines—\n  // unless they're before or after a more-indented line, or at the very\n  // beginning or end, in which case $k$ maps to $k$.\n  // Therefore, parse each chunk as newline(s) followed by a content line.\n  var lineRe = /(\\n+)([^\\n]*)/g;\n  // first line (possibly an empty line)\n  var result = (function () {\n    var nextLF = string.indexOf('\\n');\n    nextLF = nextLF !== -1 ? nextLF : string.length;\n    lineRe.lastIndex = nextLF;\n    return foldLine(string.slice(0, nextLF), width);\n  }());\n  // If we haven't reached the first content line yet, don't add an extra \\n.\n  var prevMoreIndented = string[0] === '\\n' || string[0] === ' ';\n  var moreIndented;\n  // rest of the lines\n  var match;\n  while ((match = lineRe.exec(string))) {\n    var prefix = match[1], line = match[2];\n    moreIndented = (line[0] === ' ');\n    result += prefix\n      + (!prevMoreIndented && !moreIndented && line !== ''\n        ? '\\n' : '')\n      + foldLine(line, width);\n    prevMoreIndented = moreIndented;\n  }\n  return result;\n}\n// Greedy line breaking.\n// Picks the longest line under the limit each time,\n// otherwise settles for the shortest line over the limit.\n// NB. More-indented lines *cannot* be folded, as that would add an extra \\n.\nfunction foldLine(line, width) {\n  if (line === '' || line[0] === ' ') return line;\n  // Since a more-indented line adds a \\n, breaks can't be followed by a space.\n  var breakRe = / [^ ]/g; // note: the match index will always be <= length-2.\n  var match;\n  // start is an inclusive index. end, curr, and next are exclusive.\n  var start = 0, end, curr = 0, next = 0;\n  var result = '';\n  // Invariants: 0 <= start <= length-1.\n  //   0 <= curr <= next <= max(0, length-2). curr - start <= width.\n  // Inside the loop:\n  //   A match implies length >= 2, so curr and next are <= length-2.\n  while ((match = breakRe.exec(line))) {\n    next = match.index;\n    // maintain invariant: curr - start <= width\n    if (next - start > width) {\n      end = (curr > start) ? curr : next; // derive end <= length-2\n      result += '\\n' + line.slice(start, end);\n      // skip the space that was output as \\n\n      start = end + 1;                    // derive start <= length-1\n    }\n    curr = next;\n  }\n  // By the invariants, start <= length-1, so there is something left over.\n  // It is either the whole string or a part starting from non-whitespace.\n  result += '\\n';\n  // Insert a break if the remainder is too long and there is a break available.\n  if (line.length - start > width && curr > start) {\n    result += line.slice(start, curr) + '\\n' + line.slice(curr + 1);\n  } else {\n    result += line.slice(start);\n  }\n  return result.slice(1); // drop extra \\n joiner\n}\n// Escapes a double-quoted string.\nfunction escapeString(string) {\n  var result = '';\n  var char, nextChar;\n  var escapeSeq;\n  for (var i = 0; i < string.length; i++) {\n    char = string.charCodeAt(i);\n    // Check for surrogate pairs (reference Unicode 3.0 section \"3.7 Surrogates\").\n    if (char >= 0xD800 && char <= 0xDBFF/* high surrogate */) {\n      nextChar = string.charCodeAt(i + 1);\n      if (nextChar >= 0xDC00 && nextChar <= 0xDFFF/* low surrogate */) {\n        // Combine the surrogate pair and store it escaped.\n        result += encodeHex((char - 0xD800) * 0x400 + nextChar - 0xDC00 + 0x10000);\n        // Advance index one extra since we already used that char here.\n        i++; continue;\n      }\n    }\n    escapeSeq = ESCAPE_SEQUENCES[char];\n    result += !escapeSeq && isPrintable(char)\n      ? string[i]\n      : escapeSeq || encodeHex(char);\n  }\n  return result;\n}\nfunction writeFlowSequence(state, level, object) {\n  var _result = '',\n      _tag    = state.tag,\n      index,\n      length;\n  for (index = 0, length = object.length; index < length; index += 1) {\n    // Write only valid elements.\n    if (writeNode(state, level, object[index], false, false)) {\n      if (index !== 0) _result += ',' + (!state.condenseFlow ? ' ' : '');\n      _result += state.dump;\n    }\n  }\n  state.tag = _tag;\n  state.dump = '[' + _result + ']';\n}\nfunction writeBlockSequence(state, level, object, compact) {\n  var _result = '',\n      _tag    = state.tag,\n      index,\n      length;\n  for (index = 0, length = object.length; index < length; index += 1) {\n    // Write only valid elements.\n    if (writeNode(state, level + 1, object[index], true, true)) {\n      if (!compact || index !== 0) {\n        _result += generateNextLine(state, level);\n      }\n      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {\n        _result += '-';\n      } else {\n        _result += '- ';\n      }\n      _result += state.dump;\n    }\n  }\n  state.tag = _tag;\n  state.dump = _result || '[]'; // Empty sequence if no valid values.\n}\nfunction writeFlowMapping(state, level, object) {\n  var _result       = '',\n      _tag          = state.tag,\n      objectKeyList = Object.keys(object),\n      index,\n      length,\n      objectKey,\n      objectValue,\n      pairBuffer;\n  for (index = 0, length = objectKeyList.length; index < length; index += 1) {\n    pairBuffer = state.condenseFlow ? '\"' : '';\n    if (index !== 0) pairBuffer += ', ';\n    objectKey = objectKeyList[index];\n    objectValue = object[objectKey];\n    if (!writeNode(state, level, objectKey, false, false)) {\n      continue; // Skip this pair because of invalid key;\n    }\n    if (state.dump.length > 1024) pairBuffer += '? ';\n    pairBuffer += state.dump + (state.condenseFlow ? '\"' : '') + ':' + (state.condenseFlow ? '' : ' ');\n    if (!writeNode(state, level, objectValue, false, false)) {\n      continue; // Skip this pair because of invalid value.\n    }\n    pairBuffer += state.dump;\n    // Both key and value are valid.\n    _result += pairBuffer;\n  }\n  state.tag = _tag;\n  state.dump = '{' + _result + '}';\n}\nfunction writeBlockMapping(state, level, object, compact) {\n  var _result       = '',\n      _tag          = state.tag,\n      objectKeyList = Object.keys(object),\n      index,\n      length,\n      objectKey,\n      objectValue,\n      explicitPair,\n      pairBuffer;\n  // Allow sorting keys so that the output file is deterministic\n  if (state.sortKeys === true) {\n    // Default sorting\n    objectKeyList.sort();\n  } else if (typeof state.sortKeys === 'function') {\n    // Custom sort function\n    objectKeyList.sort(state.sortKeys);\n  } else if (state.sortKeys) {\n    // Something is wrong\n    throw new YAMLException('sortKeys must be a boolean or a function');\n  }\n  for (index = 0, length = objectKeyList.length; index < length; index += 1) {\n    pairBuffer = '';\n    if (!compact || index !== 0) {\n      pairBuffer += generateNextLine(state, level);\n    }\n    objectKey = objectKeyList[index];\n    objectValue = object[objectKey];\n    if (!writeNode(state, level + 1, objectKey, true, true, true)) {\n      continue; // Skip this pair because of invalid key.\n    }\n    explicitPair = (state.tag !== null && state.tag !== '?') ||\n                   (state.dump && state.dump.length > 1024);\n    if (explicitPair) {\n      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {\n        pairBuffer += '?';\n      } else {\n        pairBuffer += '? ';\n      }\n    }\n    pairBuffer += state.dump;\n    if (explicitPair) {\n      pairBuffer += generateNextLine(state, level);\n    }\n    if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {\n      continue; // Skip this pair because of invalid value.\n    }\n    if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {\n      pairBuffer += ':';\n    } else {\n      pairBuffer += ': ';\n    }\n    pairBuffer += state.dump;\n    // Both key and value are valid.\n    _result += pairBuffer;\n  }\n  state.tag = _tag;\n  state.dump = _result || '{}'; // Empty mapping if no valid pairs.\n}\nfunction detectType(state, object, explicit) {\n  var _result, typeList, index, length, type, style;\n  typeList = explicit ? state.explicitTypes : state.implicitTypes;\n  for (index = 0, length = typeList.length; index < length; index += 1) {\n    type = typeList[index];\n    if ((type.instanceOf  || type.predicate) &&\n        (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) &&\n        (!type.predicate  || type.predicate(object))) {\n      state.tag = explicit ? type.tag : '?';\n      if (type.represent) {\n        style = state.styleMap[type.tag] || type.defaultStyle;\n        if (_toString.call(type.represent) === '[object Function]') {\n          _result = type.represent(object, style);\n        } else if (_hasOwnProperty.call(type.represent, style)) {\n          _result = type.represent[style](object, style);\n        } else {\n          throw new YAMLException('!<' + type.tag + '> tag resolver accepts not \"' + style + '\" style');\n        }\n        state.dump = _result;\n      }\n      return true;\n    }\n  }\n  return false;\n}\n// Serializes `object` and writes it to global `result`.\n// Returns true on success, or false on invalid object.\n//\nfunction writeNode(state, level, object, block, compact, iskey) {\n  state.tag = null;\n  state.dump = object;\n  if (!detectType(state, object, false)) {\n    detectType(state, object, true);\n  }\n  var type = _toString.call(state.dump);\n  if (block) {\n    block = (state.flowLevel < 0 || state.flowLevel > level);\n  }\n  var objectOrArray = type === '[object Object]' || type === '[object Array]',\n      duplicateIndex,\n      duplicate;\n  if (objectOrArray) {\n    duplicateIndex = state.duplicates.indexOf(object);\n    duplicate = duplicateIndex !== -1;\n  }\n  if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) {\n    compact = false;\n  }\n  if (duplicate && state.usedDuplicates[duplicateIndex]) {\n    state.dump = '*ref_' + duplicateIndex;\n  } else {\n    if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {\n      state.usedDuplicates[duplicateIndex] = true;\n    }\n    if (type === '[object Object]') {\n      if (block && (Object.keys(state.dump).length !== 0)) {\n        writeBlockMapping(state, level, state.dump, compact);\n        if (duplicate) {\n          state.dump = '&ref_' + duplicateIndex + state.dump;\n        }\n      } else {\n        writeFlowMapping(state, level, state.dump);\n        if (duplicate) {\n          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;\n        }\n      }\n    } else if (type === '[object Array]') {\n      var arrayLevel = (state.noArrayIndent && (level > 0)) ? level - 1 : level;\n      if (block && (state.dump.length !== 0)) {\n        writeBlockSequence(state, arrayLevel, state.dump, compact);\n        if (duplicate) {\n          state.dump = '&ref_' + duplicateIndex + state.dump;\n        }\n      } else {\n        writeFlowSequence(state, arrayLevel, state.dump);\n        if (duplicate) {\n          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;\n        }\n      }\n    } else if (type === '[object String]') {\n      if (state.tag !== '?') {\n        writeScalar(state, state.dump, level, iskey);\n      }\n    } else {\n      if (state.skipInvalid) return false;\n      throw new YAMLException('unacceptable kind of an object to dump ' + type);\n    }\n    if (state.tag !== null && state.tag !== '?') {\n      state.dump = '!<' + state.tag + '> ' + state.dump;\n    }\n  }\n  return true;\n}\nfunction getDuplicateReferences(object, state) {\n  var objects = [],\n      duplicatesIndexes = [],\n      index,\n      length;\n  inspectNode(object, objects, duplicatesIndexes);\n  for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {\n    state.duplicates.push(objects[duplicatesIndexes[index]]);\n  }\n  state.usedDuplicates = new Array(length);\n}\nfunction inspectNode(object, objects, duplicatesIndexes) {\n  var objectKeyList,\n      index,\n      length;\n  if (object !== null && typeof object === 'object') {\n    index = objects.indexOf(object);\n    if (index !== -1) {\n      if (duplicatesIndexes.indexOf(index) === -1) {\n        duplicatesIndexes.push(index);\n      }\n    } else {\n      objects.push(object);\n      if (Array.isArray(object)) {\n        for (index = 0, length = object.length; index < length; index += 1) {\n          inspectNode(object[index], objects, duplicatesIndexes);\n        }\n      } else {\n        objectKeyList = Object.keys(object);\n        for (index = 0, length = objectKeyList.length; index < length; index += 1) {\n          inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);\n        }\n      }\n    }\n  }\n}\nfunction dump(input, options) {\n  options = options || {};\n  var state = new State(options);\n  if (!state.noRefs) getDuplicateReferences(input, state);\n  if (writeNode(state, 0, input, true, true)) return state.dump + '\\n';\n  return '';\n}\nfunction safeDump(input, options) {\n  return dump(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));\n}\nmodule.exports.dump     = dump;\nmodule.exports.safeDump = safeDump;\n},{\"./common\":2,\"./exception\":4,\"./schema/default_full\":9,\"./schema/default_safe\":10}],4:[function(require,module,exports){\n// YAML error class. http://stackoverflow.com/questions/8458984\n//\n'use strict';\nfunction YAMLException(reason, mark) {\n  // Super constructor\n  Error.call(this);\n  this.name = 'YAMLException';\n  this.reason = reason;\n  this.mark = mark;\n  this.message = (this.reason || '(unknown reason)') + (this.mark ? ' ' + this.mark.toString() : '');\n  // Include stack trace in error object\n  if (Error.captureStackTrace) {\n    // Chrome and NodeJS\n    Error.captureStackTrace(this, this.constructor);\n  } else {\n    // FF, IE 10+ and Safari 6+. Fallback for others\n    this.stack = (new Error()).stack || '';\n  }\n}\n// Inherit from Error\nYAMLException.prototype = Object.create(Error.prototype);\nYAMLException.prototype.constructor = YAMLException;\nYAMLException.prototype.toString = function toString(compact) {\n  var result = this.name + ': ';\n  result += this.reason || '(unknown reason)';\n  if (!compact && this.mark) {\n    result += ' ' + this.mark.toString();\n  }\n  return result;\n};\nmodule.exports = YAMLException;\n},{}],5:[function(require,module,exports){\n'use strict';\n/*eslint-disable max-len,no-use-before-define*/\nvar common              = require('./common');\nvar YAMLException       = require('./exception');\nvar Mark                = require('./mark');\nvar DEFAULT_SAFE_SCHEMA = require('./schema/default_safe');\nvar DEFAULT_FULL_SCHEMA = require('./schema/default_full');\nvar _hasOwnProperty = Object.prototype.hasOwnProperty;\nvar CONTEXT_FLOW_IN   = 1;\nvar CONTEXT_FLOW_OUT  = 2;\nvar CONTEXT_BLOCK_IN  = 3;\nvar CONTEXT_BLOCK_OUT = 4;\nvar CHOMPING_CLIP  = 1;\nvar CHOMPING_STRIP = 2;\nvar CHOMPING_KEEP  = 3;\nvar PATTERN_NON_PRINTABLE         = /[\\x00-\\x08\\x0B\\x0C\\x0E-\\x1F\\x7F-\\x84\\x86-\\x9F\\uFFFE\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]/;\nvar PATTERN_NON_ASCII_LINE_BREAKS = /[\\x85\\u2028\\u2029]/;\nvar PATTERN_FLOW_INDICATORS       = /[,\\[\\]\\{\\}]/;\nvar PATTERN_TAG_HANDLE            = /^(?:!|!!|![a-z\\-]+!)$/i;\nvar PATTERN_TAG_URI               = /^(?:!|[^,\\[\\]\\{\\}])(?:%[0-9a-f]{2}|[0-9a-z\\-#;\\/\\?:@&=\\+\\$,_\\.!~\\*'\\(\\)\\[\\]])*$/i;\nfunction _class(obj) { return Object.prototype.toString.call(obj); }\nfunction is_EOL(c) {\n  return (c === 0x0A/* LF */) || (c === 0x0D/* CR */);\n}\nfunction is_WHITE_SPACE(c) {\n  return (c === 0x09/* Tab */) || (c === 0x20/* Space */);\n}\nfunction is_WS_OR_EOL(c) {\n  return (c === 0x09/* Tab */) ||\n         (c === 0x20/* Space */) ||\n         (c === 0x0A/* LF */) ||\n         (c === 0x0D/* CR */);\n}\nfunction is_FLOW_INDICATOR(c) {\n  return c === 0x2C/* , */ ||\n         c === 0x5B/* [ */ ||\n         c === 0x5D/* ] */ ||\n         c === 0x7B/* { */ ||\n         c === 0x7D/* } */;\n}\nfunction fromHexCode(c) {\n  var lc;\n  if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {\n    return c - 0x30;\n  }\n  /*eslint-disable no-bitwise*/\n  lc = c | 0x20;\n  if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) {\n    return lc - 0x61 + 10;\n  }\n  return -1;\n}\nfunction escapedHexLen(c) {\n  if (c === 0x78/* x */) { return 2; }\n  if (c === 0x75/* u */) { return 4; }\n  if (c === 0x55/* U */) { return 8; }\n  return 0;\n}\nfunction fromDecimalCode(c) {\n  if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {\n    return c - 0x30;\n  }\n  return -1;\n}\nfunction simpleEscapeSequence(c) {\n  /* eslint-disable indent */\n  return (c === 0x30/* 0 */) ? '\\x00' :\n        (c === 0x61/* a */) ? '\\x07' :\n        (c === 0x62/* b */) ? '\\x08' :\n        (c === 0x74/* t */) ? '\\x09' :\n        (c === 0x09/* Tab */) ? '\\x09' :\n        (c === 0x6E/* n */) ? '\\x0A' :\n        (c === 0x76/* v */) ? '\\x0B' :\n        (c === 0x66/* f */) ? '\\x0C' :\n        (c === 0x72/* r */) ? '\\x0D' :\n        (c === 0x65/* e */) ? '\\x1B' :\n        (c === 0x20/* Space */) ? ' ' :\n        (c === 0x22/* \" */) ? '\\x22' :\n        (c === 0x2F/* / */) ? '/' :\n        (c === 0x5C/* \\ */) ? '\\x5C' :\n        (c === 0x4E/* N */) ? '\\x85' :\n        (c === 0x5F/* _ */) ? '\\xA0' :\n        (c === 0x4C/* L */) ? '\\u2028' :\n        (c === 0x50/* P */) ? '\\u2029' : '';\n}\nfunction charFromCodepoint(c) {\n  if (c <= 0xFFFF) {\n    return String.fromCharCode(c);\n  }\n  // Encode UTF-16 surrogate pair\n  // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF\n  return String.fromCharCode(\n    ((c - 0x010000) >> 10) + 0xD800,\n    ((c - 0x010000) & 0x03FF) + 0xDC00\n  );\n}\nvar simpleEscapeCheck = new Array(256); // integer, for fast access\nvar simpleEscapeMap = new Array(256);\nfor (var i = 0; i < 256; i++) {\n  simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;\n  simpleEscapeMap[i] = simpleEscapeSequence(i);\n}\nfunction State(input, options) {\n  this.input = input;\n  this.filename  = options['filename']  || null;\n  this.schema    = options['schema']    || DEFAULT_FULL_SCHEMA;\n  this.onWarning = options['onWarning'] || null;\n  this.legacy    = options['legacy']    || false;\n  this.json      = options['json']      || false;\n  this.listener  = options['listener']  || null;\n  this.implicitTypes = this.schema.compiledImplicit;\n  this.typeMap       = this.schema.compiledTypeMap;\n  this.length     = input.length;\n  this.position   = 0;\n  this.line       = 0;\n  this.lineStart  = 0;\n  this.lineIndent = 0;\n  this.documents = [];\n  /*\n  this.version;\n  this.checkLineBreaks;\n  this.tagMap;\n  this.anchorMap;\n  this.tag;\n  this.anchor;\n  this.kind;\n  this.result;*/\n}\nfunction generateError(state, message) {\n  return new YAMLException(\n    message,\n    new Mark(state.filename, state.input, state.position, state.line, (state.position - state.lineStart)));\n}\nfunction throwError(state, message) {\n  throw generateError(state, message);\n}\nfunction throwWarning(state, message) {\n  if (state.onWarning) {\n    state.onWarning.call(null, generateError(state, message));\n  }\n}\nvar directiveHandlers = {\n  YAML: function handleYamlDirective(state, name, args) {\n    var match, major, minor;\n    if (state.version !== null) {\n      throwError(state, 'duplication of %YAML directive');\n    }\n    if (args.length !== 1) {\n      throwError(state, 'YAML directive accepts exactly one argument');\n    }\n    match = /^([0-9]+)\\.([0-9]+)$/.exec(args[0]);\n    if (match === null) {\n      throwError(state, 'ill-formed argument of the YAML directive');\n    }\n    major = parseInt(match[1], 10);\n    minor = parseInt(match[2], 10);\n    if (major !== 1) {\n      throwError(state, 'unacceptable YAML version of the document');\n    }\n    state.version = args[0];\n    state.checkLineBreaks = (minor < 2);\n    if (minor !== 1 && minor !== 2) {\n      throwWarning(state, 'unsupported YAML version of the document');\n    }\n  },\n  TAG: function handleTagDirective(state, name, args) {\n    var handle, prefix;\n    if (args.length !== 2) {\n      throwError(state, 'TAG directive accepts exactly two arguments');\n    }\n    handle = args[0];\n    prefix = args[1];\n    if (!PATTERN_TAG_HANDLE.test(handle)) {\n      throwError(state, 'ill-formed tag handle (first argument) of the TAG directive');\n    }\n    if (_hasOwnProperty.call(state.tagMap, handle)) {\n      throwError(state, 'there is a previously declared suffix for \"' + handle + '\" tag handle');\n    }\n    if (!PATTERN_TAG_URI.test(prefix)) {\n      throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive');\n    }\n    state.tagMap[handle] = prefix;\n  }\n};\nfunction captureSegment(state, start, end, checkJson) {\n  var _position, _length, _character, _result;\n  if (start < end) {\n    _result = state.input.slice(start, end);\n    if (checkJson) {\n      for (_position = 0, _length = _result.length; _position < _length; _position += 1) {\n        _character = _result.charCodeAt(_position);\n        if (!(_character === 0x09 ||\n              (0x20 <= _character && _character <= 0x10FFFF))) {\n          throwError(state, 'expected valid JSON character');\n        }\n      }\n    } else if (PATTERN_NON_PRINTABLE.test(_result)) {\n      throwError(state, 'the stream contains non-printable characters');\n    }\n    state.result += _result;\n  }\n}\nfunction mergeMappings(state, destination, source, overridableKeys) {\n  var sourceKeys, key, index, quantity;\n  if (!common.isObject(source)) {\n    throwError(state, 'cannot merge mappings; the provided source object is unacceptable');\n  }\n  sourceKeys = Object.keys(source);\n  for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {\n    key = sourceKeys[index];\n    if (!_hasOwnProperty.call(destination, key)) {\n      destination[key] = source[key];\n      overridableKeys[key] = true;\n    }\n  }\n}\nfunction storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) {\n  var index, quantity;\n  // The output is a plain object here, so keys can only be strings.\n  // We need to convert keyNode to a string, but doing so can hang the process\n  // (deeply nested arrays that explode exponentially using aliases).\n  if (Array.isArray(keyNode)) {\n    keyNode = Array.prototype.slice.call(keyNode);\n    for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {\n      if (Array.isArray(keyNode[index])) {\n        throwError(state, 'nested arrays are not supported inside keys');\n      }\n      if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') {\n        keyNode[index] = '[object Object]';\n      }\n    }\n  }\n  // Avoid code execution in load() via toString property\n  // (still use its own toString for arrays, timestamps,\n  // and whatever user schema extensions happen to have @@toStringTag)\n  if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') {\n    keyNode = '[object Object]';\n  }\n  keyNode = String(keyNode);\n  if (_result === null) {\n    _result = {};\n  }\n  if (keyTag === 'tag:yaml.org,2002:merge') {\n    if (Array.isArray(valueNode)) {\n      for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {\n        mergeMappings(state, _result, valueNode[index], overridableKeys);\n      }\n    } else {\n      mergeMappings(state, _result, valueNode, overridableKeys);\n    }\n  } else {\n    if (!state.json &&\n        !_hasOwnProperty.call(overridableKeys, keyNode) &&\n        _hasOwnProperty.call(_result, keyNode)) {\n      state.line = startLine || state.line;\n      state.position = startPos || state.position;\n      throwError(state, 'duplicated mapping key');\n    }\n    _result[keyNode] = valueNode;\n    delete overridableKeys[keyNode];\n  }\n  return _result;\n}\nfunction readLineBreak(state) {\n  var ch;\n  ch = state.input.charCodeAt(state.position);\n  if (ch === 0x0A/* LF */) {\n    state.position++;\n  } else if (ch === 0x0D/* CR */) {\n    state.position++;\n    if (state.input.charCodeAt(state.position) === 0x0A/* LF */) {\n      state.position++;\n    }\n  } else {\n    throwError(state, 'a line break is expected');\n  }\n  state.line += 1;\n  state.lineStart = state.position;\n}\nfunction skipSeparationSpace(state, allowComments, checkIndent) {\n  var lineBreaks = 0,\n      ch = state.input.charCodeAt(state.position);\n  while (ch !== 0) {\n    while (is_WHITE_SPACE(ch)) {\n      ch = state.input.charCodeAt(++state.position);\n    }\n    if (allowComments && ch === 0x23/* # */) {\n      do {\n        ch = state.input.charCodeAt(++state.position);\n      } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0);\n    }\n    if (is_EOL(ch)) {\n      readLineBreak(state);\n      ch = state.input.charCodeAt(state.position);\n      lineBreaks++;\n      state.lineIndent = 0;\n      while (ch === 0x20/* Space */) {\n        state.lineIndent++;\n        ch = state.input.charCodeAt(++state.position);\n      }\n    } else {\n      break;\n    }\n  }\n  if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {\n    throwWarning(state, 'deficient indentation');\n  }\n  return lineBreaks;\n}\nfunction testDocumentSeparator(state) {\n  var _position = state.position,\n      ch;\n  ch = state.input.charCodeAt(_position);\n  // Condition state.position === state.lineStart is tested\n  // in parent on each call, for efficiency. No needs to test here again.\n  if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) &&\n      ch === state.input.charCodeAt(_position + 1) &&\n      ch === state.input.charCodeAt(_position + 2)) {\n    _position += 3;\n    ch = state.input.charCodeAt(_position);\n    if (ch === 0 || is_WS_OR_EOL(ch)) {\n      return true;\n    }\n  }\n  return false;\n}\nfunction writeFoldedLines(state, count) {\n  if (count === 1) {\n    state.result += ' ';\n  } else if (count > 1) {\n    state.result += common.repeat('\\n', count - 1);\n  }\n}\nfunction readPlainScalar(state, nodeIndent, withinFlowCollection) {\n  var preceding,\n      following,\n      captureStart,\n      captureEnd,\n      hasPendingContent,\n      _line,\n      _lineStart,\n      _lineIndent,\n      _kind = state.kind,\n      _result = state.result,\n      ch;\n  ch = state.input.charCodeAt(state.position);\n  if (is_WS_OR_EOL(ch)      ||\n      is_FLOW_INDICATOR(ch) ||\n      ch === 0x23/* # */    ||\n      ch === 0x26/* & */    ||\n      ch === 0x2A/* * */    ||\n      ch === 0x21/* ! */    ||\n      ch === 0x7C/* | */    ||\n      ch === 0x3E/* > */    ||\n      ch === 0x27/* ' */    ||\n      ch === 0x22/* \" */    ||\n      ch === 0x25/* % */    ||\n      ch === 0x40/* @ */    ||\n      ch === 0x60/* ` */) {\n    return false;\n  }\n  if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) {\n    following = state.input.charCodeAt(state.position + 1);\n    if (is_WS_OR_EOL(following) ||\n        withinFlowCollection && is_FLOW_INDICATOR(following)) {\n      return false;\n    }\n  }\n  state.kind = 'scalar';\n  state.result = '';\n  captureStart = captureEnd = state.position;\n  hasPendingContent = false;\n  while (ch !== 0) {\n    if (ch === 0x3A/* : */) {\n      following = state.input.charCodeAt(state.position + 1);\n      if (is_WS_OR_EOL(following) ||\n          withinFlowCollection && is_FLOW_INDICATOR(following)) {\n        break;\n      }\n    } else if (ch === 0x23/* # */) {\n      preceding = state.input.charCodeAt(state.position - 1);\n      if (is_WS_OR_EOL(preceding)) {\n        break;\n      }\n    } else if ((state.position === state.lineStart && testDocumentSeparator(state)) ||\n               withinFlowCollection && is_FLOW_INDICATOR(ch)) {\n      break;\n    } else if (is_EOL(ch)) {\n      _line = state.line;\n      _lineStart = state.lineStart;\n      _lineIndent = state.lineIndent;\n      skipSeparationSpace(state, false, -1);\n      if (state.lineIndent >= nodeIndent) {\n        hasPendingContent = true;\n        ch = state.input.charCodeAt(state.position);\n        continue;\n      } else {\n        state.position = captureEnd;\n        state.line = _line;\n        state.lineStart = _lineStart;\n        state.lineIndent = _lineIndent;\n        break;\n      }\n    }\n    if (hasPendingContent) {\n      captureSegment(state, captureStart, captureEnd, false);\n      writeFoldedLines(state, state.line - _line);\n      captureStart = captureEnd = state.position;\n      hasPendingContent = false;\n    }\n    if (!is_WHITE_SPACE(ch)) {\n      captureEnd = state.position + 1;\n    }\n    ch = state.input.charCodeAt(++state.position);\n  }\n  captureSegment(state, captureStart, captureEnd, false);\n  if (state.result) {\n    return true;\n  }\n  state.kind = _kind;\n  state.result = _result;\n  return false;\n}\nfunction readSingleQuotedScalar(state, nodeIndent) {\n  var ch,\n      captureStart, captureEnd;\n  ch = state.input.charCodeAt(state.position);\n  if (ch !== 0x27/* ' */) {\n    return false;\n  }\n  state.kind = 'scalar';\n  state.result = '';\n  state.position++;\n  captureStart = captureEnd = state.position;\n  while ((ch = state.input.charCodeAt(state.position)) !== 0) {\n    if (ch === 0x27/* ' */) {\n      captureSegment(state, captureStart, state.position, true);\n      ch = state.input.charCodeAt(++state.position);\n      if (ch === 0x27/* ' */) {\n        captureStart = state.position;\n        state.position++;\n        captureEnd = state.position;\n      } else {\n        return true;\n      }\n    } else if (is_EOL(ch)) {\n      captureSegment(state, captureStart, captureEnd, true);\n      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));\n      captureStart = captureEnd = state.position;\n    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {\n      throwError(state, 'unexpected end of the document within a single quoted scalar');\n    } else {\n      state.position++;\n      captureEnd = state.position;\n    }\n  }\n  throwError(state, 'unexpected end of the stream within a single quoted scalar');\n}\nfunction readDoubleQuotedScalar(state, nodeIndent) {\n  var captureStart,\n      captureEnd,\n      hexLength,\n      hexResult,\n      tmp,\n      ch;\n  ch = state.input.charCodeAt(state.position);\n  if (ch !== 0x22/* \" */) {\n    return false;\n  }\n  state.kind = 'scalar';\n  state.result = '';\n  state.position++;\n  captureStart = captureEnd = state.position;\n  while ((ch = state.input.charCodeAt(state.position)) !== 0) {\n    if (ch === 0x22/* \" */) {\n      captureSegment(state, captureStart, state.position, true);\n      state.position++;\n      return true;\n    } else if (ch === 0x5C/* \\ */) {\n      captureSegment(state, captureStart, state.position, true);\n      ch = state.input.charCodeAt(++state.position);\n      if (is_EOL(ch)) {\n        skipSeparationSpace(state, false, nodeIndent);\n        // TODO: rework to inline fn with no type cast?\n      } else if (ch < 256 && simpleEscapeCheck[ch]) {\n        state.result += simpleEscapeMap[ch];\n        state.position++;\n      } else if ((tmp = escapedHexLen(ch)) > 0) {\n        hexLength = tmp;\n        hexResult = 0;\n        for (; hexLength > 0; hexLength--) {\n          ch = state.input.charCodeAt(++state.position);\n          if ((tmp = fromHexCode(ch)) >= 0) {\n            hexResult = (hexResult << 4) + tmp;\n          } else {\n            throwError(state, 'expected hexadecimal character');\n          }\n        }\n        state.result += charFromCodepoint(hexResult);\n        state.position++;\n      } else {\n        throwError(state, 'unknown escape sequence');\n      }\n      captureStart = captureEnd = state.position;\n    } else if (is_EOL(ch)) {\n      captureSegment(state, captureStart, captureEnd, true);\n      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));\n      captureStart = captureEnd = state.position;\n    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {\n      throwError(state, 'unexpected end of the document within a double quoted scalar');\n    } else {\n      state.position++;\n      captureEnd = state.position;\n    }\n  }\n  throwError(state, 'unexpected end of the stream within a double quoted scalar');\n}\nfunction readFlowCollection(state, nodeIndent) {\n  var readNext = true,\n      _line,\n      _tag     = state.tag,\n      _result,\n      _anchor  = state.anchor,\n      following,\n      terminator,\n      isPair,\n      isExplicitPair,\n      isMapping,\n      overridableKeys = {},\n      keyNode,\n      keyTag,\n      valueNode,\n      ch;\n  ch = state.input.charCodeAt(state.position);\n  if (ch === 0x5B/* [ */) {\n    terminator = 0x5D;/* ] */\n    isMapping = false;\n    _result = [];\n  } else if (ch === 0x7B/* { */) {\n    terminator = 0x7D;/* } */\n    isMapping = true;\n    _result = {};\n  } else {\n    return false;\n  }\n  if (state.anchor !== null) {\n    state.anchorMap[state.anchor] = _result;\n  }\n  ch = state.input.charCodeAt(++state.position);\n  while (ch !== 0) {\n    skipSeparationSpace(state, true, nodeIndent);\n    ch = state.input.charCodeAt(state.position);\n    if (ch === terminator) {\n      state.position++;\n      state.tag = _tag;\n      state.anchor = _anchor;\n      state.kind = isMapping ? 'mapping' : 'sequence';\n      state.result = _result;\n      return true;\n    } else if (!readNext) {\n      throwError(state, 'missed comma between flow collection entries');\n    }\n    keyTag = keyNode = valueNode = null;\n    isPair = isExplicitPair = false;\n    if (ch === 0x3F/* ? */) {\n      following = state.input.charCodeAt(state.position + 1);\n      if (is_WS_OR_EOL(following)) {\n        isPair = isExplicitPair = true;\n        state.position++;\n        skipSeparationSpace(state, true, nodeIndent);\n      }\n    }\n    _line = state.line;\n    composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);\n    keyTag = state.tag;\n    keyNode = state.result;\n    skipSeparationSpace(state, true, nodeIndent);\n    ch = state.input.charCodeAt(state.position);\n    if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) {\n      isPair = true;\n      ch = state.input.charCodeAt(++state.position);\n      skipSeparationSpace(state, true, nodeIndent);\n      composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);\n      valueNode = state.result;\n    }\n    if (isMapping) {\n      storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode);\n    } else if (isPair) {\n      _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode));\n    } else {\n      _result.push(keyNode);\n    }\n    skipSeparationSpace(state, true, nodeIndent);\n    ch = state.input.charCodeAt(state.position);\n    if (ch === 0x2C/* , */) {\n      readNext = true;\n      ch = state.input.charCodeAt(++state.position);\n    } else {\n      readNext = false;\n    }\n  }\n  throwError(state, 'unexpected end of the stream within a flow collection');\n}\nfunction readBlockScalar(state, nodeIndent) {\n  var captureStart,\n      folding,\n      chomping       = CHOMPING_CLIP,\n      didReadContent = false,\n      detectedIndent = false,\n      textIndent     = nodeIndent,\n      emptyLines     = 0,\n      atMoreIndented = false,\n      tmp,\n      ch;\n  ch = state.input.charCodeAt(state.position);\n  if (ch === 0x7C/* | */) {\n    folding = false;\n  } else if (ch === 0x3E/* > */) {\n    folding = true;\n  } else {\n    return false;\n  }\n  state.kind = 'scalar';\n  state.result = '';\n  while (ch !== 0) {\n    ch = state.input.charCodeAt(++state.position);\n    if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {\n      if (CHOMPING_CLIP === chomping) {\n        chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP;\n      } else {\n        throwError(state, 'repeat of a chomping mode identifier');\n      }\n    } else if ((tmp = fromDecimalCode(ch)) >= 0) {\n      if (tmp === 0) {\n        throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');\n      } else if (!detectedIndent) {\n        textIndent = nodeIndent + tmp - 1;\n        detectedIndent = true;\n      } else {\n        throwError(state, 'repeat of an indentation width identifier');\n      }\n    } else {\n      break;\n    }\n  }\n  if (is_WHITE_SPACE(ch)) {\n    do { ch = state.input.charCodeAt(++state.position); }\n    while (is_WHITE_SPACE(ch));\n    if (ch === 0x23/* # */) {\n      do { ch = state.input.charCodeAt(++state.position); }\n      while (!is_EOL(ch) && (ch !== 0));\n    }\n  }\n  while (ch !== 0) {\n    readLineBreak(state);\n    state.lineIndent = 0;\n    ch = state.input.charCodeAt(state.position);\n    while ((!detectedIndent || state.lineIndent < textIndent) &&\n           (ch === 0x20/* Space */)) {\n      state.lineIndent++;\n      ch = state.input.charCodeAt(++state.position);\n    }\n    if (!detectedIndent && state.lineIndent > textIndent) {\n      textIndent = state.lineIndent;\n    }\n    if (is_EOL(ch)) {\n      emptyLines++;\n      continue;\n    }\n    // End of the scalar.\n    if (state.lineIndent < textIndent) {\n      // Perform the chomping.\n      if (chomping === CHOMPING_KEEP) {\n        state.result += common.repeat('\\n', didReadContent ? 1 + emptyLines : emptyLines);\n      } else if (chomping === CHOMPING_CLIP) {\n        if (didReadContent) { // i.e. only if the scalar is not empty.\n          state.result += '\\n';\n        }\n      }\n      // Break this `while` cycle and go to the funciton's epilogue.\n      break;\n    }\n    // Folded style: use fancy rules to handle line breaks.\n    if (folding) {\n      // Lines starting with white space characters (more-indented lines) are not folded.\n      if (is_WHITE_SPACE(ch)) {\n        atMoreIndented = true;\n        // except for the first content line (cf. Example 8.1)\n        state.result += common.repeat('\\n', didReadContent ? 1 + emptyLines : emptyLines);\n      // End of more-indented block.\n      } else if (atMoreIndented) {\n        atMoreIndented = false;\n        state.result += common.repeat('\\n', emptyLines + 1);\n      // Just one line break - perceive as the same line.\n      } else if (emptyLines === 0) {\n        if (didReadContent) { // i.e. only if we have already read some scalar content.\n          state.result += ' ';\n        }\n      // Several line breaks - perceive as different lines.\n      } else {\n        state.result += common.repeat('\\n', emptyLines);\n      }\n    // Literal style: just add exact number of line breaks between content lines.\n    } else {\n      // Keep all line breaks except the header line break.\n      state.result += common.repeat('\\n', didReadContent ? 1 + emptyLines : emptyLines);\n    }\n    didReadContent = true;\n    detectedIndent = true;\n    emptyLines = 0;\n    captureStart = state.position;\n    while (!is_EOL(ch) && (ch !== 0)) {\n      ch = state.input.charCodeAt(++state.position);\n    }\n    captureSegment(state, captureStart, state.position, false);\n  }\n  return true;\n}\nfunction readBlockSequence(state, nodeIndent) {\n  var _line,\n      _tag      = state.tag,\n      _anchor   = state.anchor,\n      _result   = [],\n      following,\n      detected  = false,\n      ch;\n  if (state.anchor !== null) {\n    state.anchorMap[state.anchor] = _result;\n  }\n  ch = state.input.charCodeAt(state.position);\n  while (ch !== 0) {\n    if (ch !== 0x2D/* - */) {\n      break;\n    }\n    following = state.input.charCodeAt(state.position + 1);\n    if (!is_WS_OR_EOL(following)) {\n      break;\n    }\n    detected = true;\n    state.position++;\n    if (skipSeparationSpace(state, true, -1)) {\n      if (state.lineIndent <= nodeIndent) {\n        _result.push(null);\n        ch = state.input.charCodeAt(state.position);\n        continue;\n      }\n    }\n    _line = state.line;\n    composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);\n    _result.push(state.result);\n    skipSeparationSpace(state, true, -1);\n    ch = state.input.charCodeAt(state.position);\n    if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {\n      throwError(state, 'bad indentation of a sequence entry');\n    } else if (state.lineIndent < nodeIndent) {\n      break;\n    }\n  }\n  if (detected) {\n    state.tag = _tag;\n    state.anchor = _anchor;\n    state.kind = 'sequence';\n    state.result = _result;\n    return true;\n  }\n  return false;\n}\nfunction readBlockMapping(state, nodeIndent, flowIndent) {\n  var following,\n      allowCompact,\n      _line,\n      _pos,\n      _tag          = state.tag,\n      _anchor       = state.anchor,\n      _result       = {},\n      overridableKeys = {},\n      keyTag        = null,\n      keyNode       = null,\n      valueNode     = null,\n      atExplicitKey = false,\n      detected      = false,\n      ch;\n  if (state.anchor !== null) {\n    state.anchorMap[state.anchor] = _result;\n  }\n  ch = state.input.charCodeAt(state.position);\n  while (ch !== 0) {\n    following = state.input.charCodeAt(state.position + 1);\n    _line = state.line; // Save the current line.\n    _pos = state.position;\n    //\n    // Explicit notation case. There are two separate blocks:\n    // first for the key (denoted by \"?\") and second for the value (denoted by \":\")\n    //\n    if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) {\n      if (ch === 0x3F/* ? */) {\n        if (atExplicitKey) {\n          storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);\n          keyTag = keyNode = valueNode = null;\n        }\n        detected = true;\n        atExplicitKey = true;\n        allowCompact = true;\n      } else if (atExplicitKey) {\n        // i.e. 0x3A/* : */ === character after the explicit key.\n        atExplicitKey = false;\n        allowCompact = true;\n      } else {\n        throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line');\n      }\n      state.position += 1;\n      ch = following;\n    //\n    // Implicit notation case. Flow-style node as the key first, then \":\", and the value.\n    //\n    } else if (composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {\n      if (state.line === _line) {\n        ch = state.input.charCodeAt(state.position);\n        while (is_WHITE_SPACE(ch)) {\n          ch = state.input.charCodeAt(++state.position);\n        }\n        if (ch === 0x3A/* : */) {\n          ch = state.input.charCodeAt(++state.position);\n          if (!is_WS_OR_EOL(ch)) {\n            throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping');\n          }\n          if (atExplicitKey) {\n            storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);\n            keyTag = keyNode = valueNode = null;\n          }\n          detected = true;\n          atExplicitKey = false;\n          allowCompact = false;\n          keyTag = state.tag;\n          keyNode = state.result;\n        } else if (detected) {\n          throwError(state, 'can not read an implicit mapping pair; a colon is missed');\n        } else {\n          state.tag = _tag;\n          state.anchor = _anchor;\n          return true; // Keep the result of `composeNode`.\n        }\n      } else if (detected) {\n        throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key');\n      } else {\n        state.tag = _tag;\n        state.anchor = _anchor;\n        return true; // Keep the result of `composeNode`.\n      }\n    } else {\n      break; // Reading is done. Go to the epilogue.\n    }\n    //\n    // Common reading code for both explicit and implicit notations.\n    //\n    if (state.line === _line || state.lineIndent > nodeIndent) {\n      if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {\n        if (atExplicitKey) {\n          keyNode = state.result;\n        } else {\n          valueNode = state.result;\n        }\n      }\n      if (!atExplicitKey) {\n        storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos);\n        keyTag = keyNode = valueNode = null;\n      }\n      skipSeparationSpace(state, true, -1);\n      ch = state.input.charCodeAt(state.position);\n    }\n    if (state.lineIndent > nodeIndent && (ch !== 0)) {\n      throwError(state, 'bad indentation of a mapping entry');\n    } else if (state.lineIndent < nodeIndent) {\n      break;\n    }\n  }\n  //\n  // Epilogue.\n  //\n  // Special case: last mapping's node contains only the key in explicit notation.\n  if (atExplicitKey) {\n    storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);\n  }\n  // Expose the resulting mapping.\n  if (detected) {\n    state.tag = _tag;\n    state.anchor = _anchor;\n    state.kind = 'mapping';\n    state.result = _result;\n  }\n  return detected;\n}\nfunction readTagProperty(state) {\n  var _position,\n      isVerbatim = false,\n      isNamed    = false,\n      tagHandle,\n      tagName,\n      ch;\n  ch = state.input.charCodeAt(state.position);\n  if (ch !== 0x21/* ! */) return false;\n  if (state.tag !== null) {\n    throwError(state, 'duplication of a tag property');\n  }\n  ch = state.input.charCodeAt(++state.position);\n  if (ch === 0x3C/* < */) {\n    isVerbatim = true;\n    ch = state.input.charCodeAt(++state.position);\n  } else if (ch === 0x21/* ! */) {\n    isNamed = true;\n    tagHandle = '!!';\n    ch = state.input.charCodeAt(++state.position);\n  } else {\n    tagHandle = '!';\n  }\n  _position = state.position;\n  if (isVerbatim) {\n    do { ch = state.input.charCodeAt(++state.position); }\n    while (ch !== 0 && ch !== 0x3E/* > */);\n    if (state.position < state.length) {\n      tagName = state.input.slice(_position, state.position);\n      ch = state.input.charCodeAt(++state.position);\n    } else {\n      throwError(state, 'unexpected end of the stream within a verbatim tag');\n    }\n  } else {\n    while (ch !== 0 && !is_WS_OR_EOL(ch)) {\n      if (ch === 0x21/* ! */) {\n        if (!isNamed) {\n          tagHandle = state.input.slice(_position - 1, state.position + 1);\n          if (!PATTERN_TAG_HANDLE.test(tagHandle)) {\n            throwError(state, 'named tag handle cannot contain such characters');\n          }\n          isNamed = true;\n          _position = state.position + 1;\n        } else {\n          throwError(state, 'tag suffix cannot contain exclamation marks');\n        }\n      }\n      ch = state.input.charCodeAt(++state.position);\n    }\n    tagName = state.input.slice(_position, state.position);\n    if (PATTERN_FLOW_INDICATORS.test(tagName)) {\n      throwError(state, 'tag suffix cannot contain flow indicator characters');\n    }\n  }\n  if (tagName && !PATTERN_TAG_URI.test(tagName)) {\n    throwError(state, 'tag name cannot contain such characters: ' + tagName);\n  }\n  if (isVerbatim) {\n    state.tag = tagName;\n  } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {\n    state.tag = state.tagMap[tagHandle] + tagName;\n  } else if (tagHandle === '!') {\n    state.tag = '!' + tagName;\n  } else if (tagHandle === '!!') {\n    state.tag = 'tag:yaml.org,2002:' + tagName;\n  } else {\n    throwError(state, 'undeclared tag handle \"' + tagHandle + '\"');\n  }\n  return true;\n}\nfunction readAnchorProperty(state) {\n  var _position,\n      ch;\n  ch = state.input.charCodeAt(state.position);\n  if (ch !== 0x26/* & */) return false;\n  if (state.anchor !== null) {\n    throwError(state, 'duplication of an anchor property');\n  }\n  ch = state.input.charCodeAt(++state.position);\n  _position = state.position;\n  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {\n    ch = state.input.charCodeAt(++state.position);\n  }\n  if (state.position === _position) {\n    throwError(state, 'name of an anchor node must contain at least one character');\n  }\n  state.anchor = state.input.slice(_position, state.position);\n  return true;\n}\nfunction readAlias(state) {\n  var _position, alias,\n      ch;\n  ch = state.input.charCodeAt(state.position);\n  if (ch !== 0x2A/* * */) return false;\n  ch = state.input.charCodeAt(++state.position);\n  _position = state.position;\n  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {\n    ch = state.input.charCodeAt(++state.position);\n  }\n  if (state.position === _position) {\n    throwError(state, 'name of an alias node must contain at least one character');\n  }\n  alias = state.input.slice(_position, state.position);\n  if (!state.anchorMap.hasOwnProperty(alias)) {\n    throwError(state, 'unidentified alias \"' + alias + '\"');\n  }\n  state.result = state.anchorMap[alias];\n  skipSeparationSpace(state, true, -1);\n  return true;\n}\nfunction composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {\n  var allowBlockStyles,\n      allowBlockScalars,\n      allowBlockCollections,\n      indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this<parent\n      atNewLine  = false,\n      hasContent = false,\n      typeIndex,\n      typeQuantity,\n      type,\n      flowIndent,\n      blockIndent;\n  if (state.listener !== null) {\n    state.listener('open', state);\n  }\n  state.tag    = null;\n  state.anchor = null;\n  state.kind   = null;\n  state.result = null;\n  allowBlockStyles = allowBlockScalars = allowBlockCollections =\n    CONTEXT_BLOCK_OUT === nodeContext ||\n    CONTEXT_BLOCK_IN  === nodeContext;\n  if (allowToSeek) {\n    if (skipSeparationSpace(state, true, -1)) {\n      atNewLine = true;\n      if (state.lineIndent > parentIndent) {\n        indentStatus = 1;\n      } else if (state.lineIndent === parentIndent) {\n        indentStatus = 0;\n      } else if (state.lineIndent < parentIndent) {\n        indentStatus = -1;\n      }\n    }\n  }\n  if (indentStatus === 1) {\n    while (readTagProperty(state) || readAnchorProperty(state)) {\n      if (skipSeparationSpace(state, true, -1)) {\n        atNewLine = true;\n        allowBlockCollections = allowBlockStyles;\n        if (state.lineIndent > parentIndent) {\n          indentStatus = 1;\n        } else if (state.lineIndent === parentIndent) {\n          indentStatus = 0;\n        } else if (state.lineIndent < parentIndent) {\n          indentStatus = -1;\n        }\n      } else {\n        allowBlockCollections = false;\n      }\n    }\n  }\n  if (allowBlockCollections) {\n    allowBlockCollections = atNewLine || allowCompact;\n  }\n  if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {\n    if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {\n      flowIndent = parentIndent;\n    } else {\n      flowIndent = parentIndent + 1;\n    }\n    blockIndent = state.position - state.lineStart;\n    if (indentStatus === 1) {\n      if (allowBlockCollections &&\n          (readBlockSequence(state, blockIndent) ||\n           readBlockMapping(state, blockIndent, flowIndent)) ||\n          readFlowCollection(state, flowIndent)) {\n        hasContent = true;\n      } else {\n        if ((allowBlockScalars && readBlockScalar(state, flowIndent)) ||\n            readSingleQuotedScalar(state, flowIndent) ||\n            readDoubleQuotedScalar(state, flowIndent)) {\n          hasContent = true;\n        } else if (readAlias(state)) {\n          hasContent = true;\n          if (state.tag !== null || state.anchor !== null) {\n            throwError(state, 'alias node should not have any properties');\n          }\n        } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {\n          hasContent = true;\n          if (state.tag === null) {\n            state.tag = '?';\n          }\n        }\n        if (state.anchor !== null) {\n          state.anchorMap[state.anchor] = state.result;\n        }\n      }\n    } else if (indentStatus === 0) {\n      // Special case: block sequences are allowed to have same indentation level as the parent.\n      // http://www.yaml.org/spec/1.2/spec.html#id2799784\n      hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);\n    }\n  }\n  if (state.tag !== null && state.tag !== '!') {\n    if (state.tag === '?') {\n      for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {\n        type = state.implicitTypes[typeIndex];\n        // Implicit resolving is not allowed for non-scalar types, and '?'\n        // non-specific tag is only assigned to plain scalars. So, it isn't\n        // needed to check for 'kind' conformity.\n        if (type.resolve(state.result)) { // `state.result` updated in resolver if matched\n          state.result = type.construct(state.result);\n          state.tag = type.tag;\n          if (state.anchor !== null) {\n            state.anchorMap[state.anchor] = state.result;\n          }\n          break;\n        }\n      }\n    } else if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) {\n      type = state.typeMap[state.kind || 'fallback'][state.tag];\n      if (state.result !== null && type.kind !== state.kind) {\n        throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be \"' + type.kind + '\", not \"' + state.kind + '\"');\n      }\n      if (!type.resolve(state.result)) { // `state.result` updated in resolver if matched\n        throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');\n      } else {\n        state.result = type.construct(state.result);\n        if (state.anchor !== null) {\n          state.anchorMap[state.anchor] = state.result;\n        }\n      }\n    } else {\n      throwError(state, 'unknown tag !<' + state.tag + '>');\n    }\n  }\n  if (state.listener !== null) {\n    state.listener('close', state);\n  }\n  return state.tag !== null ||  state.anchor !== null || hasContent;\n}\nfunction readDocument(state) {\n  var documentStart = state.position,\n      _position,\n      directiveName,\n      directiveArgs,\n      hasDirectives = false,\n      ch;\n  state.version = null;\n  state.checkLineBreaks = state.legacy;\n  state.tagMap = {};\n  state.anchorMap = {};\n  while ((ch = state.input.charCodeAt(state.position)) !== 0) {\n    skipSeparationSpace(state, true, -1);\n    ch = state.input.charCodeAt(state.position);\n    if (state.lineIndent > 0 || ch !== 0x25/* % */) {\n      break;\n    }\n    hasDirectives = true;\n    ch = state.input.charCodeAt(++state.position);\n    _position = state.position;\n    while (ch !== 0 && !is_WS_OR_EOL(ch)) {\n      ch = state.input.charCodeAt(++state.position);\n    }\n    directiveName = state.input.slice(_position, state.position);\n    directiveArgs = [];\n    if (directiveName.length < 1) {\n      throwError(state, 'directive name must not be less than one character in length');\n    }\n    while (ch !== 0) {\n      while (is_WHITE_SPACE(ch)) {\n        ch = state.input.charCodeAt(++state.position);\n      }\n      if (ch === 0x23/* # */) {\n        do { ch = state.input.charCodeAt(++state.position); }\n        while (ch !== 0 && !is_EOL(ch));\n        break;\n      }\n      if (is_EOL(ch)) break;\n      _position = state.position;\n      while (ch !== 0 && !is_WS_OR_EOL(ch)) {\n        ch = state.input.charCodeAt(++state.position);\n      }\n      directiveArgs.push(state.input.slice(_position, state.position));\n    }\n    if (ch !== 0) readLineBreak(state);\n    if (_hasOwnProperty.call(directiveHandlers, directiveName)) {\n      directiveHandlers[directiveName](state, directiveName, directiveArgs);\n    } else {\n      throwWarning(state, 'unknown document directive \"' + directiveName + '\"');\n    }\n  }\n  skipSeparationSpace(state, true, -1);\n  if (state.lineIndent === 0 &&\n      state.input.charCodeAt(state.position)     === 0x2D/* - */ &&\n      state.input.charCodeAt(state.position + 1) === 0x2D/* - */ &&\n      state.input.charCodeAt(state.position + 2) === 0x2D/* - */) {\n    state.position += 3;\n    skipSeparationSpace(state, true, -1);\n  } else if (hasDirectives) {\n    throwError(state, 'directives end mark is expected');\n  }\n  composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);\n  skipSeparationSpace(state, true, -1);\n  if (state.checkLineBreaks &&\n      PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {\n    throwWarning(state, 'non-ASCII line breaks are interpreted as content');\n  }\n  state.documents.push(state.result);\n  if (state.position === state.lineStart && testDocumentSeparator(state)) {\n    if (state.input.charCodeAt(state.position) === 0x2E/* . */) {\n      state.position += 3;\n      skipSeparationSpace(state, true, -1);\n    }\n    return;\n  }\n  if (state.position < (state.length - 1)) {\n    throwError(state, 'end of the stream or a document separator is expected');\n  } else {\n    return;\n  }\n}\nfunction loadDocuments(input, options) {\n  input = String(input);\n  options = options || {};\n  if (input.length !== 0) {\n    // Add tailing `\\n` if not exists\n    if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ &&\n        input.charCodeAt(input.length - 1) !== 0x0D/* CR */) {\n      input += '\\n';\n    }\n    // Strip BOM\n    if (input.charCodeAt(0) === 0xFEFF) {\n      input = input.slice(1);\n    }\n  }\n  var state = new State(input, options);\n  // Use 0 as string terminator. That significantly simplifies bounds check.\n  state.input += '\\0';\n  while (state.input.charCodeAt(state.position) === 0x20/* Space */) {\n    state.lineIndent += 1;\n    state.position += 1;\n  }\n  while (state.position < (state.length - 1)) {\n    readDocument(state);\n  }\n  return state.documents;\n}\nfunction loadAll(input, iterator, options) {\n  var documents = loadDocuments(input, options), index, length;\n  if (typeof iterator !== 'function') {\n    return documents;\n  }\n  for (index = 0, length = documents.length; index < length; index += 1) {\n    iterator(documents[index]);\n  }\n}\nfunction load(input, options) {\n  var documents = loadDocuments(input, options);\n  if (documents.length === 0) {\n    /*eslint-disable no-undefined*/\n    return undefined;\n  } else if (documents.length === 1) {\n    return documents[0];\n  }\n  throw new YAMLException('expected a single document in the stream, but found more');\n}\nfunction safeLoadAll(input, output, options) {\n  if (typeof output === 'function') {\n    loadAll(input, output, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));\n  } else {\n    return loadAll(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));\n  }\n}\nfunction safeLoad(input, options) {\n  return load(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));\n}\nmodule.exports.loadAll     = loadAll;\nmodule.exports.load        = load;\nmodule.exports.safeLoadAll = safeLoadAll;\nmodule.exports.safeLoad    = safeLoad;\n},{\"./common\":2,\"./exception\":4,\"./mark\":6,\"./schema/default_full\":9,\"./schema/default_safe\":10}],6:[function(require,module,exports){\n'use strict';\nvar common = require('./common');\nfunction Mark(name, buffer, position, line, column) {\n  this.name     = name;\n  this.buffer   = buffer;\n  this.position = position;\n  this.line     = line;\n  this.column   = column;\n}\nMark.prototype.getSnippet = function getSnippet(indent, maxLength) {\n  var head, start, tail, end, snippet;\n  if (!this.buffer) return null;\n  indent = indent || 4;\n  maxLength = maxLength || 75;\n  head = '';\n  start = this.position;\n  while (start > 0 && '\\x00\\r\\n\\x85\\u2028\\u2029'.indexOf(this.buffer.charAt(start - 1)) === -1) {\n    start -= 1;\n    if (this.position - start > (maxLength / 2 - 1)) {\n      head = ' ... ';\n      start += 5;\n      break;\n    }\n  }\n  tail = '';\n  end = this.position;\n  while (end < this.buffer.length && '\\x00\\r\\n\\x85\\u2028\\u2029'.indexOf(this.buffer.charAt(end)) === -1) {\n    end += 1;\n    if (end - this.position > (maxLength / 2 - 1)) {\n      tail = ' ... ';\n      end -= 5;\n      break;\n    }\n  }\n  snippet = this.buffer.slice(start, end);\n  return common.repeat(' ', indent) + head + snippet + tail + '\\n' +\n         common.repeat(' ', indent + this.position - start + head.length) + '^';\n};\nMark.prototype.toString = function toString(compact) {\n  var snippet, where = '';\n  if (this.name) {\n    where += 'in \"' + this.name + '\" ';\n  }\n  where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1);\n  if (!compact) {\n    snippet = this.getSnippet();\n    if (snippet) {\n      where += ':\\n' + snippet;\n    }\n  }\n  return where;\n};\nmodule.exports = Mark;\n},{\"./common\":2}],7:[function(require,module,exports){\n'use strict';\n/*eslint-disable max-len*/\nvar common        = require('./common');\nvar YAMLException = require('./exception');\nvar Type          = require('./type');\nfunction compileList(schema, name, result) {\n  var exclude = [];\n  schema.include.forEach(function (includedSchema) {\n    result = compileList(includedSchema, name, result);\n  });\n  schema[name].forEach(function (currentType) {\n    result.forEach(function (previousType, previousIndex) {\n      if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) {\n        exclude.push(previousIndex);\n      }\n    });\n    result.push(currentType);\n  });\n  return result.filter(function (type, index) {\n    return exclude.indexOf(index) === -1;\n  });\n}\nfunction compileMap(/* lists... */) {\n  var result = {\n        scalar: {},\n        sequence: {},\n        mapping: {},\n        fallback: {}\n      }, index, length;\n  function collectType(type) {\n    result[type.kind][type.tag] = result['fallback'][type.tag] = type;\n  }\n  for (index = 0, length = arguments.length; index < length; index += 1) {\n    arguments[index].forEach(collectType);\n  }\n  return result;\n}\nfunction Schema(definition) {\n  this.include  = definition.include  || [];\n  this.implicit = definition.implicit || [];\n  this.explicit = definition.explicit || [];\n  this.implicit.forEach(function (type) {\n    if (type.loadKind && type.loadKind !== 'scalar') {\n      throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');\n    }\n  });\n  this.compiledImplicit = compileList(this, 'implicit', []);\n  this.compiledExplicit = compileList(this, 'explicit', []);\n  this.compiledTypeMap  = compileMap(this.compiledImplicit, this.compiledExplicit);\n}\nSchema.DEFAULT = null;\nSchema.create = function createSchema() {\n  var schemas, types;\n  switch (arguments.length) {\n    case 1:\n      schemas = Schema.DEFAULT;\n      types = arguments[0];\n      break;\n    case 2:\n      schemas = arguments[0];\n      types = arguments[1];\n      break;\n    default:\n      throw new YAMLException('Wrong number of arguments for Schema.create function');\n  }\n  schemas = common.toArray(schemas);\n  types = common.toArray(types);\n  if (!schemas.every(function (schema) { return schema instanceof Schema; })) {\n    throw new YAMLException('Specified list of super schemas (or a single Schema object) contains a non-Schema object.');\n  }\n  if (!types.every(function (type) { return type instanceof Type; })) {\n    throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.');\n  }\n  return new Schema({\n    include: schemas,\n    explicit: types\n  });\n};\nmodule.exports = Schema;\n},{\"./common\":2,\"./exception\":4,\"./type\":13}],8:[function(require,module,exports){\n// Standard YAML's Core schema.\n// http://www.yaml.org/spec/1.2/spec.html#id2804923\n//\n// NOTE: JS-YAML does not support schema-specific tag resolution restrictions.\n// So, Core schema has no distinctions from JSON schema is JS-YAML.\n'use strict';\nvar Schema = require('../schema');\nmodule.exports = new Schema({\n  include: [\n    require('./json')\n  ]\n});\n},{\"../schema\":7,\"./json\":12}],9:[function(require,module,exports){\n// JS-YAML's default schema for `load` function.\n// It is not described in the YAML specification.\n//\n// This schema is based on JS-YAML's default safe schema and includes\n// JavaScript-specific types: !!js/undefined, !!js/regexp and !!js/function.\n//\n// Also this schema is used as default base schema at `Schema.create` function.\n'use strict';\nvar Schema = require('../schema');\nmodule.exports = Schema.DEFAULT = new Schema({\n  include: [\n    require('./default_safe')\n  ],\n  explicit: [\n    require('../type/js/undefined'),\n    require('../type/js/regexp'),\n    require('../type/js/function')\n  ]\n});\n},{\"../schema\":7,\"../type/js/function\":18,\"../type/js/regexp\":19,\"../type/js/undefined\":20,\"./default_safe\":10}],10:[function(require,module,exports){\n// JS-YAML's default schema for `safeLoad` function.\n// It is not described in the YAML specification.\n//\n// This schema is based on standard YAML's Core schema and includes most of\n// extra types described at YAML tag repository. (http://yaml.org/type/)\n'use strict';\nvar Schema = require('../schema');\nmodule.exports = new Schema({\n  include: [\n    require('./core')\n  ],\n  implicit: [\n    require('../type/timestamp'),\n    require('../type/merge')\n  ],\n  explicit: [\n    require('../type/binary'),\n    require('../type/omap'),\n    require('../type/pairs'),\n    require('../type/set')\n  ]\n});\n},{\"../schema\":7,\"../type/binary\":14,\"../type/merge\":22,\"../type/omap\":24,\"../type/pairs\":25,\"../type/set\":27,\"../type/timestamp\":29,\"./core\":8}],11:[function(require,module,exports){\n// Standard YAML's Failsafe schema.\n// http://www.yaml.org/spec/1.2/spec.html#id2802346\n'use strict';\nvar Schema = require('../schema');\nmodule.exports = new Schema({\n  explicit: [\n    require('../type/str'),\n    require('../type/seq'),\n    require('../type/map')\n  ]\n});\n},{\"../schema\":7,\"../type/map\":21,\"../type/seq\":26,\"../type/str\":28}],12:[function(require,module,exports){\n// Standard YAML's JSON schema.\n// http://www.yaml.org/spec/1.2/spec.html#id2803231\n//\n// NOTE: JS-YAML does not support schema-specific tag resolution restrictions.\n// So, this schema is not such strict as defined in the YAML specification.\n// It allows numbers in binary notaion, use `Null` and `NULL` as `null`, etc.\n'use strict';\nvar Schema = require('../schema');\nmodule.exports = new Schema({\n  include: [\n    require('./failsafe')\n  ],\n  implicit: [\n    require('../type/null'),\n    require('../type/bool'),\n    require('../type/int'),\n    require('../type/float')\n  ]\n});\n},{\"../schema\":7,\"../type/bool\":15,\"../type/float\":16,\"../type/int\":17,\"../type/null\":23,\"./failsafe\":11}],13:[function(require,module,exports){\n'use strict';\nvar YAMLException = require('./exception');\nvar TYPE_CONSTRUCTOR_OPTIONS = [\n  'kind',\n  'resolve',\n  'construct',\n  'instanceOf',\n  'predicate',\n  'represent',\n  'defaultStyle',\n  'styleAliases'\n];\nvar YAML_NODE_KINDS = [\n  'scalar',\n  'sequence',\n  'mapping'\n];\nfunction compileStyleAliases(map) {\n  var result = {};\n  if (map !== null) {\n    Object.keys(map).forEach(function (style) {\n      map[style].forEach(function (alias) {\n        result[String(alias)] = style;\n      });\n    });\n  }\n  return result;\n}\nfunction Type(tag, options) {\n  options = options || {};\n  Object.keys(options).forEach(function (name) {\n    if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {\n      throw new YAMLException('Unknown option \"' + name + '\" is met in definition of \"' + tag + '\" YAML type.');\n    }\n  });\n  // TODO: Add tag format check.\n  this.tag          = tag;\n  this.kind         = options['kind']         || null;\n  this.resolve      = options['resolve']      || function () { return true; };\n  this.construct    = options['construct']    || function (data) { return data; };\n  this.instanceOf   = options['instanceOf']   || null;\n  this.predicate    = options['predicate']    || null;\n  this.represent    = options['represent']    || null;\n  this.defaultStyle = options['defaultStyle'] || null;\n  this.styleAliases = compileStyleAliases(options['styleAliases'] || null);\n  if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {\n    throw new YAMLException('Unknown kind \"' + this.kind + '\" is specified for \"' + tag + '\" YAML type.');\n  }\n}\nmodule.exports = Type;\n},{\"./exception\":4}],14:[function(require,module,exports){\n'use strict';\n/*eslint-disable no-bitwise*/\nvar NodeBuffer;\ntry {\n  // A trick for browserified version, to not include `Buffer` shim\n  var _require = require;\n  NodeBuffer = _require('buffer').Buffer;\n} catch (__) {}\nvar Type       = require('../type');\n// [ 64, 65, 66 ] -> [ padding, CR, LF ]\nvar BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\\n\\r';\nfunction resolveYamlBinary(data) {\n  if (data === null) return false;\n  var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;\n  // Convert one by one.\n  for (idx = 0; idx < max; idx++) {\n    code = map.indexOf(data.charAt(idx));\n    // Skip CR/LF\n    if (code > 64) continue;\n    // Fail on illegal characters\n    if (code < 0) return false;\n    bitlen += 6;\n  }\n  // If there are any bits left, source was corrupted\n  return (bitlen % 8) === 0;\n}\nfunction constructYamlBinary(data) {\n  var idx, tailbits,\n      input = data.replace(/[\\r\\n=]/g, ''), // remove CR/LF & padding to simplify scan\n      max = input.length,\n      map = BASE64_MAP,\n      bits = 0,\n      result = [];\n  // Collect by 6*4 bits (3 bytes)\n  for (idx = 0; idx < max; idx++) {\n    if ((idx % 4 === 0) && idx) {\n      result.push((bits >> 16) & 0xFF);\n      result.push((bits >> 8) & 0xFF);\n      result.push(bits & 0xFF);\n    }\n    bits = (bits << 6) | map.indexOf(input.charAt(idx));\n  }\n  // Dump tail\n  tailbits = (max % 4) * 6;\n  if (tailbits === 0) {\n    result.push((bits >> 16) & 0xFF);\n    result.push((bits >> 8) & 0xFF);\n    result.push(bits & 0xFF);\n  } else if (tailbits === 18) {\n    result.push((bits >> 10) & 0xFF);\n    result.push((bits >> 2) & 0xFF);\n  } else if (tailbits === 12) {\n    result.push((bits >> 4) & 0xFF);\n  }\n  // Wrap into Buffer for NodeJS and leave Array for browser\n  if (NodeBuffer) {\n    // Support node 6.+ Buffer API when available\n    return NodeBuffer.from ? NodeBuffer.from(result) : new NodeBuffer(result);\n  }\n  return result;\n}\nfunction representYamlBinary(object /*, style*/) {\n  var result = '', bits = 0, idx, tail,\n      max = object.length,\n      map = BASE64_MAP;\n  // Convert every three bytes to 4 ASCII characters.\n  for (idx = 0; idx < max; idx++) {\n    if ((idx % 3 === 0) && idx) {\n      result += map[(bits >> 18) & 0x3F];\n      result += map[(bits >> 12) & 0x3F];\n      result += map[(bits >> 6) & 0x3F];\n      result += map[bits & 0x3F];\n    }\n    bits = (bits << 8) + object[idx];\n  }\n  // Dump tail\n  tail = max % 3;\n  if (tail === 0) {\n    result += map[(bits >> 18) & 0x3F];\n    result += map[(bits >> 12) & 0x3F];\n    result += map[(bits >> 6) & 0x3F];\n    result += map[bits & 0x3F];\n  } else if (tail === 2) {\n    result += map[(bits >> 10) & 0x3F];\n    result += map[(bits >> 4) & 0x3F];\n    result += map[(bits << 2) & 0x3F];\n    result += map[64];\n  } else if (tail === 1) {\n    result += map[(bits >> 2) & 0x3F];\n    result += map[(bits << 4) & 0x3F];\n    result += map[64];\n    result += map[64];\n  }\n  return result;\n}\nfunction isBinary(object) {\n  return NodeBuffer && NodeBuffer.isBuffer(object);\n}\nmodule.exports = new Type('tag:yaml.org,2002:binary', {\n  kind: 'scalar',\n  resolve: resolveYamlBinary,\n  construct: constructYamlBinary,\n  predicate: isBinary,\n  represent: representYamlBinary\n});\n},{\"../type\":13}],15:[function(require,module,exports){\n'use strict';\nvar Type = require('../type');\nfunction resolveYamlBoolean(data) {\n  if (data === null) return false;\n  var max = data.length;\n  return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) ||\n         (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'));\n}\nfunction constructYamlBoolean(data) {\n  return data === 'true' ||\n         data === 'True' ||\n         data === 'TRUE';\n}\nfunction isBoolean(object) {\n  return Object.prototype.toString.call(object) === '[object Boolean]';\n}\nmodule.exports = new Type('tag:yaml.org,2002:bool', {\n  kind: 'scalar',\n  resolve: resolveYamlBoolean,\n  construct: constructYamlBoolean,\n  predicate: isBoolean,\n  represent: {\n    lowercase: function (object) { return object ? 'true' : 'false'; },\n    uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; },\n    camelcase: function (object) { return object ? 'True' : 'False'; }\n  },\n  defaultStyle: 'lowercase'\n});\n},{\"../type\":13}],16:[function(require,module,exports){\n'use strict';\nvar common = require('../common');\nvar Type   = require('../type');\nvar YAML_FLOAT_PATTERN = new RegExp(\n  // 2.5e4, 2.5 and integers\n  '^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' +\n  // .2e4, .2\n  // special case, seems not from spec\n  '|\\\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' +\n  // 20:59\n  '|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\\\.[0-9_]*' +\n  // .inf\n  '|[-+]?\\\\.(?:inf|Inf|INF)' +\n  // .nan\n  '|\\\\.(?:nan|NaN|NAN))$');\nfunction resolveYamlFloat(data) {\n  if (data === null) return false;\n  if (!YAML_FLOAT_PATTERN.test(data) ||\n      // Quick hack to not allow integers end with `_`\n      // Probably should update regexp & check speed\n      data[data.length - 1] === '_') {\n    return false;\n  }\n  return true;\n}\nfunction constructYamlFloat(data) {\n  var value, sign, base, digits;\n  value  = data.replace(/_/g, '').toLowerCase();\n  sign   = value[0] === '-' ? -1 : 1;\n  digits = [];\n  if ('+-'.indexOf(value[0]) >= 0) {\n    value = value.slice(1);\n  }\n  if (value === '.inf') {\n    return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;\n  } else if (value === '.nan') {\n    return NaN;\n  } else if (value.indexOf(':') >= 0) {\n    value.split(':').forEach(function (v) {\n      digits.unshift(parseFloat(v, 10));\n    });\n    value = 0.0;\n    base = 1;\n    digits.forEach(function (d) {\n      value += d * base;\n      base *= 60;\n    });\n    return sign * value;\n  }\n  return sign * parseFloat(value, 10);\n}\nvar SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;\nfunction representYamlFloat(object, style) {\n  var res;\n  if (isNaN(object)) {\n    switch (style) {\n      case 'lowercase': return '.nan';\n      case 'uppercase': return '.NAN';\n      case 'camelcase': return '.NaN';\n    }\n  } else if (Number.POSITIVE_INFINITY === object) {\n    switch (style) {\n      case 'lowercase': return '.inf';\n      case 'uppercase': return '.INF';\n      case 'camelcase': return '.Inf';\n    }\n  } else if (Number.NEGATIVE_INFINITY === object) {\n    switch (style) {\n      case 'lowercase': return '-.inf';\n      case 'uppercase': return '-.INF';\n      case 'camelcase': return '-.Inf';\n    }\n  } else if (common.isNegativeZero(object)) {\n    return '-0.0';\n  }\n  res = object.toString(10);\n  // JS stringifier can build scientific format without dots: 5e-100,\n  // while YAML requres dot: 5.e-100. Fix it with simple hack\n  return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res;\n}\nfunction isFloat(object) {\n  return (Object.prototype.toString.call(object) === '[object Number]') &&\n         (object % 1 !== 0 || common.isNegativeZero(object));\n}\nmodule.exports = new Type('tag:yaml.org,2002:float', {\n  kind: 'scalar',\n  resolve: resolveYamlFloat,\n  construct: constructYamlFloat,\n  predicate: isFloat,\n  represent: representYamlFloat,\n  defaultStyle: 'lowercase'\n});\n},{\"../common\":2,\"../type\":13}],17:[function(require,module,exports){\n'use strict';\nvar common = require('../common');\nvar Type   = require('../type');\nfunction isHexCode(c) {\n  return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) ||\n         ((0x41/* A */ <= c) && (c <= 0x46/* F */)) ||\n         ((0x61/* a */ <= c) && (c <= 0x66/* f */));\n}\nfunction isOctCode(c) {\n  return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */));\n}\nfunction isDecCode(c) {\n  return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */));\n}\nfunction resolveYamlInteger(data) {\n  if (data === null) return false;\n  var max = data.length,\n      index = 0,\n      hasDigits = false,\n      ch;\n  if (!max) return false;\n  ch = data[index];\n  // sign\n  if (ch === '-' || ch === '+') {\n    ch = data[++index];\n  }\n  if (ch === '0') {\n    // 0\n    if (index + 1 === max) return true;\n    ch = data[++index];\n    // base 2, base 8, base 16\n    if (ch === 'b') {\n      // base 2\n      index++;\n      for (; index < max; index++) {\n        ch = data[index];\n        if (ch === '_') continue;\n        if (ch !== '0' && ch !== '1') return false;\n        hasDigits = true;\n      }\n      return hasDigits && ch !== '_';\n    }\n    if (ch === 'x') {\n      // base 16\n      index++;\n      for (; index < max; index++) {\n        ch = data[index];\n        if (ch === '_') continue;\n        if (!isHexCode(data.charCodeAt(index))) return false;\n        hasDigits = true;\n      }\n      return hasDigits && ch !== '_';\n    }\n    // base 8\n    for (; index < max; index++) {\n      ch = data[index];\n      if (ch === '_') continue;\n      if (!isOctCode(data.charCodeAt(index))) return false;\n      hasDigits = true;\n    }\n    return hasDigits && ch !== '_';\n  }\n  // base 10 (except 0) or base 60\n  // value should not start with `_`;\n  if (ch === '_') return false;\n  for (; index < max; index++) {\n    ch = data[index];\n    if (ch === '_') continue;\n    if (ch === ':') break;\n    if (!isDecCode(data.charCodeAt(index))) {\n      return false;\n    }\n    hasDigits = true;\n  }\n  // Should have digits and should not end with `_`\n  if (!hasDigits || ch === '_') return false;\n  // if !base60 - done;\n  if (ch !== ':') return true;\n  // base60 almost not used, no needs to optimize\n  return /^(:[0-5]?[0-9])+$/.test(data.slice(index));\n}\nfunction constructYamlInteger(data) {\n  var value = data, sign = 1, ch, base, digits = [];\n  if (value.indexOf('_') !== -1) {\n    value = value.replace(/_/g, '');\n  }\n  ch = value[0];\n  if (ch === '-' || ch === '+') {\n    if (ch === '-') sign = -1;\n    value = value.slice(1);\n    ch = value[0];\n  }\n  if (value === '0') return 0;\n  if (ch === '0') {\n    if (value[1] === 'b') return sign * parseInt(value.slice(2), 2);\n    if (value[1] === 'x') return sign * parseInt(value, 16);\n    return sign * parseInt(value, 8);\n  }\n  if (value.indexOf(':') !== -1) {\n    value.split(':').forEach(function (v) {\n      digits.unshift(parseInt(v, 10));\n    });\n    value = 0;\n    base = 1;\n    digits.forEach(function (d) {\n      value += (d * base);\n      base *= 60;\n    });\n    return sign * value;\n  }\n  return sign * parseInt(value, 10);\n}\nfunction isInteger(object) {\n  return (Object.prototype.toString.call(object)) === '[object Number]' &&\n         (object % 1 === 0 && !common.isNegativeZero(object));\n}\nmodule.exports = new Type('tag:yaml.org,2002:int', {\n  kind: 'scalar',\n  resolve: resolveYamlInteger,\n  construct: constructYamlInteger,\n  predicate: isInteger,\n  represent: {\n    binary:      function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1); },\n    octal:       function (obj) { return obj >= 0 ? '0'  + obj.toString(8) : '-0'  + obj.toString(8).slice(1); },\n    decimal:     function (obj) { return obj.toString(10); },\n    /* eslint-disable max-len */\n    hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() :  '-0x' + obj.toString(16).toUpperCase().slice(1); }\n  },\n  defaultStyle: 'decimal',\n  styleAliases: {\n    binary:      [ 2,  'bin' ],\n    octal:       [ 8,  'oct' ],\n    decimal:     [ 10, 'dec' ],\n    hexadecimal: [ 16, 'hex' ]\n  }\n});\n},{\"../common\":2,\"../type\":13}],18:[function(require,module,exports){\n'use strict';\nvar esprima;\n// Browserified version does not have esprima\n//\n// 1. For node.js just require module as deps\n// 2. For browser try to require mudule via external AMD system.\n//    If not found - try to fallback to window.esprima. If not\n//    found too - then fail to parse.\n//\ntry {\n  // workaround to exclude package from browserify list.\n  var _require = require;\n  esprima = _require('esprima');\n} catch (_) {\n  /*global window */\n  if (typeof window !== 'undefined') esprima = window.esprima;\n}\nvar Type = require('../../type');\nfunction resolveJavascriptFunction(data) {\n  if (data === null) return false;\n  try {\n    var source = '(' + data + ')',\n        ast    = esprima.parse(source, { range: true });\n    if (ast.type                    !== 'Program'             ||\n        ast.body.length             !== 1                     ||\n        ast.body[0].type            !== 'ExpressionStatement' ||\n        (ast.body[0].expression.type !== 'ArrowFunctionExpression' &&\n          ast.body[0].expression.type !== 'FunctionExpression')) {\n      return false;\n    }\n    return true;\n  } catch (err) {\n    return false;\n  }\n}\nfunction constructJavascriptFunction(data) {\n  /*jslint evil:true*/\n  var source = '(' + data + ')',\n      ast    = esprima.parse(source, { range: true }),\n      params = [],\n      body;\n  if (ast.type                    !== 'Program'             ||\n      ast.body.length             !== 1                     ||\n      ast.body[0].type            !== 'ExpressionStatement' ||\n      (ast.body[0].expression.type !== 'ArrowFunctionExpression' &&\n        ast.body[0].expression.type !== 'FunctionExpression')) {\n    throw new Error('Failed to resolve function');\n  }\n  ast.body[0].expression.params.forEach(function (param) {\n    params.push(param.name);\n  });\n  body = ast.body[0].expression.body.range;\n  // Esprima's ranges include the first '{' and the last '}' characters on\n  // function expressions. So cut them out.\n  if (ast.body[0].expression.body.type === 'BlockStatement') {\n    /*eslint-disable no-new-func*/\n    return new Function(params, source.slice(body[0] + 1, body[1] - 1));\n  }\n  // ES6 arrow functions can omit the BlockStatement. In that case, just return\n  // the body.\n  /*eslint-disable no-new-func*/\n  return new Function(params, 'return ' + source.slice(body[0], body[1]));\n}\nfunction representJavascriptFunction(object /*, style*/) {\n  return object.toString();\n}\nfunction isFunction(object) {\n  return Object.prototype.toString.call(object) === '[object Function]';\n}\nmodule.exports = new Type('tag:yaml.org,2002:js/function', {\n  kind: 'scalar',\n  resolve: resolveJavascriptFunction,\n  construct: constructJavascriptFunction,\n  predicate: isFunction,\n  represent: representJavascriptFunction\n});\n},{\"../../type\":13}],19:[function(require,module,exports){\n'use strict';\nvar Type = require('../../type');\nfunction resolveJavascriptRegExp(data) {\n  if (data === null) return false;\n  if (data.length === 0) return false;\n  var regexp = data,\n      tail   = /\\/([gim]*)$/.exec(data),\n      modifiers = '';\n  // if regexp starts with '/' it can have modifiers and must be properly closed\n  // `/foo/gim` - modifiers tail can be maximum 3 chars\n  if (regexp[0] === '/') {\n    if (tail) modifiers = tail[1];\n    if (modifiers.length > 3) return false;\n    // if expression starts with /, is should be properly terminated\n    if (regexp[regexp.length - modifiers.length - 1] !== '/') return false;\n  }\n  return true;\n}\nfunction constructJavascriptRegExp(data) {\n  var regexp = data,\n      tail   = /\\/([gim]*)$/.exec(data),\n      modifiers = '';\n  // `/foo/gim` - tail can be maximum 4 chars\n  if (regexp[0] === '/') {\n    if (tail) modifiers = tail[1];\n    regexp = regexp.slice(1, regexp.length - modifiers.length - 1);\n  }\n  return new RegExp(regexp, modifiers);\n}\nfunction representJavascriptRegExp(object /*, style*/) {\n  var result = '/' + object.source + '/';\n  if (object.global) result += 'g';\n  if (object.multiline) result += 'm';\n  if (object.ignoreCase) result += 'i';\n  return result;\n}\nfunction isRegExp(object) {\n  return Object.prototype.toString.call(object) === '[object RegExp]';\n}\nmodule.exports = new Type('tag:yaml.org,2002:js/regexp', {\n  kind: 'scalar',\n  resolve: resolveJavascriptRegExp,\n  construct: constructJavascriptRegExp,\n  predicate: isRegExp,\n  represent: representJavascriptRegExp\n});\n},{\"../../type\":13}],20:[function(require,module,exports){\n'use strict';\nvar Type = require('../../type');\nfunction resolveJavascriptUndefined() {\n  return true;\n}\nfunction constructJavascriptUndefined() {\n  /*eslint-disable no-undefined*/\n  return undefined;\n}\nfunction representJavascriptUndefined() {\n  return '';\n}\nfunction isUndefined(object) {\n  return typeof object === 'undefined';\n}\nmodule.exports = new Type('tag:yaml.org,2002:js/undefined', {\n  kind: 'scalar',\n  resolve: resolveJavascriptUndefined,\n  construct: constructJavascriptUndefined,\n  predicate: isUndefined,\n  represent: representJavascriptUndefined\n});\n},{\"../../type\":13}],21:[function(require,module,exports){\n'use strict';\nvar Type = require('../type');\nmodule.exports = new Type('tag:yaml.org,2002:map', {\n  kind: 'mapping',\n  construct: function (data) { return data !== null ? data : {}; }\n});\n},{\"../type\":13}],22:[function(require,module,exports){\n'use strict';\nvar Type = require('../type');\nfunction resolveYamlMerge(data) {\n  return data === '<<' || data === null;\n}\nmodule.exports = new Type('tag:yaml.org,2002:merge', {\n  kind: 'scalar',\n  resolve: resolveYamlMerge\n});\n},{\"../type\":13}],23:[function(require,module,exports){\n'use strict';\nvar Type = require('../type');\nfunction resolveYamlNull(data) {\n  if (data === null) return true;\n  var max = data.length;\n  return (max === 1 && data === '~') ||\n         (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'));\n}\nfunction constructYamlNull() {\n  return null;\n}\nfunction isNull(object) {\n  return object === null;\n}\nmodule.exports = new Type('tag:yaml.org,2002:null', {\n  kind: 'scalar',\n  resolve: resolveYamlNull,\n  construct: constructYamlNull,\n  predicate: isNull,\n  represent: {\n    canonical: function () { return '~';    },\n    lowercase: function () { return 'null'; },\n    uppercase: function () { return 'NULL'; },\n    camelcase: function () { return 'Null'; }\n  },\n  defaultStyle: 'lowercase'\n});\n},{\"../type\":13}],24:[function(require,module,exports){\n'use strict';\nvar Type = require('../type');\nvar _hasOwnProperty = Object.prototype.hasOwnProperty;\nvar _toString       = Object.prototype.toString;\nfunction resolveYamlOmap(data) {\n  if (data === null) return true;\n  var objectKeys = [], index, length, pair, pairKey, pairHasKey,\n      object = data;\n  for (index = 0, length = object.length; index < length; index += 1) {\n    pair = object[index];\n    pairHasKey = false;\n    if (_toString.call(pair) !== '[object Object]') return false;\n    for (pairKey in pair) {\n      if (_hasOwnProperty.call(pair, pairKey)) {\n        if (!pairHasKey) pairHasKey = true;\n        else return false;\n      }\n    }\n    if (!pairHasKey) return false;\n    if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);\n    else return false;\n  }\n  return true;\n}\nfunction constructYamlOmap(data) {\n  return data !== null ? data : [];\n}\nmodule.exports = new Type('tag:yaml.org,2002:omap', {\n  kind: 'sequence',\n  resolve: resolveYamlOmap,\n  construct: constructYamlOmap\n});\n},{\"../type\":13}],25:[function(require,module,exports){\n'use strict';\nvar Type = require('../type');\nvar _toString = Object.prototype.toString;\nfunction resolveYamlPairs(data) {\n  if (data === null) return true;\n  var index, length, pair, keys, result,\n      object = data;\n  result = new Array(object.length);\n  for (index = 0, length = object.length; index < length; index += 1) {\n    pair = object[index];\n    if (_toString.call(pair) !== '[object Object]') return false;\n    keys = Object.keys(pair);\n    if (keys.length !== 1) return false;\n    result[index] = [ keys[0], pair[keys[0]] ];\n  }\n  return true;\n}\nfunction constructYamlPairs(data) {\n  if (data === null) return [];\n  var index, length, pair, keys, result,\n      object = data;\n  result = new Array(object.length);\n  for (index = 0, length = object.length; index < length; index += 1) {\n    pair = object[index];\n    keys = Object.keys(pair);\n    result[index] = [ keys[0], pair[keys[0]] ];\n  }\n  return result;\n}\nmodule.exports = new Type('tag:yaml.org,2002:pairs', {\n  kind: 'sequence',\n  resolve: resolveYamlPairs,\n  construct: constructYamlPairs\n});\n},{\"../type\":13}],26:[function(require,module,exports){\n'use strict';\nvar Type = require('../type');\nmodule.exports = new Type('tag:yaml.org,2002:seq', {\n  kind: 'sequence',\n  construct: function (data) { return data !== null ? data : []; }\n});\n},{\"../type\":13}],27:[function(require,module,exports){\n'use strict';\nvar Type = require('../type');\nvar _hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction resolveYamlSet(data) {\n  if (data === null) return true;\n  var key, object = data;\n  for (key in object) {\n    if (_hasOwnProperty.call(object, key)) {\n      if (object[key] !== null) return false;\n    }\n  }\n  return true;\n}\nfunction constructYamlSet(data) {\n  return data !== null ? data : {};\n}\nmodule.exports = new Type('tag:yaml.org,2002:set', {\n  kind: 'mapping',\n  resolve: resolveYamlSet,\n  construct: constructYamlSet\n});\n},{\"../type\":13}],28:[function(require,module,exports){\n'use strict';\nvar Type = require('../type');\nmodule.exports = new Type('tag:yaml.org,2002:str', {\n  kind: 'scalar',\n  construct: function (data) { return data !== null ? data : ''; }\n});\n},{\"../type\":13}],29:[function(require,module,exports){\n'use strict';\nvar Type = require('../type');\nvar YAML_DATE_REGEXP = new RegExp(\n  '^([0-9][0-9][0-9][0-9])'          + // [1] year\n  '-([0-9][0-9])'                    + // [2] month\n  '-([0-9][0-9])$');                   // [3] day\nvar YAML_TIMESTAMP_REGEXP = new RegExp(\n  '^([0-9][0-9][0-9][0-9])'          + // [1] year\n  '-([0-9][0-9]?)'                   + // [2] month\n  '-([0-9][0-9]?)'                   + // [3] day\n  '(?:[Tt]|[ \\\\t]+)'                 + // ...\n  '([0-9][0-9]?)'                    + // [4] hour\n  ':([0-9][0-9])'                    + // [5] minute\n  ':([0-9][0-9])'                    + // [6] second\n  '(?:\\\\.([0-9]*))?'                 + // [7] fraction\n  '(?:[ \\\\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour\n  '(?::([0-9][0-9]))?))?$');           // [11] tz_minute\nfunction resolveYamlTimestamp(data) {\n  if (data === null) return false;\n  if (YAML_DATE_REGEXP.exec(data) !== null) return true;\n  if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;\n  return false;\n}\nfunction constructYamlTimestamp(data) {\n  var match, year, month, day, hour, minute, second, fraction = 0,\n      delta = null, tz_hour, tz_minute, date;\n  match = YAML_DATE_REGEXP.exec(data);\n  if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);\n  if (match === null) throw new Error('Date resolve error');\n  // match: [1] year [2] month [3] day\n  year = +(match[1]);\n  month = +(match[2]) - 1; // JS month starts with 0\n  day = +(match[3]);\n  if (!match[4]) { // no hour\n    return new Date(Date.UTC(year, month, day));\n  }\n  // match: [4] hour [5] minute [6] second [7] fraction\n  hour = +(match[4]);\n  minute = +(match[5]);\n  second = +(match[6]);\n  if (match[7]) {\n    fraction = match[7].slice(0, 3);\n    while (fraction.length < 3) { // milli-seconds\n      fraction += '0';\n    }\n    fraction = +fraction;\n  }\n  // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute\n  if (match[9]) {\n    tz_hour = +(match[10]);\n    tz_minute = +(match[11] || 0);\n    delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds\n    if (match[9] === '-') delta = -delta;\n  }\n  date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));\n  if (delta) date.setTime(date.getTime() - delta);\n  return date;\n}\nfunction representYamlTimestamp(object /*, style*/) {\n  return object.toISOString();\n}\nmodule.exports = new Type('tag:yaml.org,2002:timestamp', {\n  kind: 'scalar',\n  resolve: resolveYamlTimestamp,\n  construct: constructYamlTimestamp,\n  instanceOf: Date,\n  represent: representYamlTimestamp\n});\n},{\"../type\":13}],\"/\":[function(require,module,exports){\n'use strict';\nvar yaml = require('./lib/js-yaml.js');\nmodule.exports = yaml;\n},{\"./lib/js-yaml.js\":1}]},{},[])(\"/\")\n});"
		},
		{
			"key": "testProductKey",
			"value": ""
		},
		{
			"key": "gopherId",
			"value": ""
		},
		{
			"key": "coll-stats",
			"value": ""
		}
	]
}