foreman_acd 0.4.0 → 0.9.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (237) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +84 -84
  3. data/app/controllers/foreman_acd/ansible_playbooks_controller.rb +103 -11
  4. data/app/controllers/foreman_acd/api/v2/ansible_playbooks_controller.rb +21 -3
  5. data/app/controllers/foreman_acd/api/v2/app_definitions_controller.rb +1 -0
  6. data/app/controllers/foreman_acd/api/v2/app_instances_controller.rb +9 -1
  7. data/app/controllers/foreman_acd/app_definitions_controller.rb +117 -15
  8. data/app/controllers/foreman_acd/app_instances_controller.rb +104 -30
  9. data/app/controllers/foreman_acd/concerns/ansible_playbook_parameters.rb +1 -1
  10. data/app/controllers/foreman_acd/concerns/app_definition_parameters.rb +1 -1
  11. data/app/controllers/foreman_acd/concerns/app_instance_mixins.rb +36 -0
  12. data/app/controllers/foreman_acd/concerns/app_instance_parameters.rb +1 -1
  13. data/app/controllers/foreman_acd/remote_execution_controller.rb +36 -23
  14. data/app/controllers/ui_acd_controller.rb +46 -0
  15. data/app/lib/actions/foreman_acd/deploy_all_hosts.rb +47 -0
  16. data/app/lib/actions/foreman_acd/run_configurator.rb +45 -0
  17. data/app/models/concerns/foreman_acd/host_managed_extensions.rb +39 -0
  18. data/app/models/foreman_acd/acd_provider.rb +36 -0
  19. data/app/models/foreman_acd/ansible_playbook.rb +32 -14
  20. data/app/models/foreman_acd/app_definition.rb +24 -1
  21. data/app/models/foreman_acd/app_instance.rb +85 -5
  22. data/app/models/foreman_acd/foreman_host.rb +31 -0
  23. data/app/models/foreman_acd/taxonomy_extensions.rb +17 -0
  24. data/app/services/foreman_acd/acd_proxy_proxy_selector.rb +17 -0
  25. data/app/services/foreman_acd/app_configurator.rb +64 -36
  26. data/app/services/foreman_acd/app_deployer.rb +83 -48
  27. data/app/services/foreman_acd/inventory_creator.rb +36 -25
  28. data/app/views/foreman_acd/ansible_playbooks/_form.html.erb +50 -7
  29. data/app/views/foreman_acd/ansible_playbooks/edit.html.erb +9 -1
  30. data/app/views/foreman_acd/ansible_playbooks/index.html.erb +3 -3
  31. data/app/views/foreman_acd/api/v2/ansible_playbooks/base.json.rabl +2 -0
  32. data/app/views/foreman_acd/api/v2/ansible_playbooks/index.json.rabl +2 -0
  33. data/app/views/foreman_acd/api/v2/ansible_playbooks/show.json.rabl +6 -0
  34. data/app/views/foreman_acd/api/v2/app_definitions/base.json.rabl +2 -0
  35. data/app/views/foreman_acd/api/v2/app_definitions/index.json.rabl +2 -0
  36. data/app/views/foreman_acd/api/v2/app_definitions/show.json.rabl +6 -0
  37. data/app/views/foreman_acd/api/v2/app_instances/base.json.rabl +3 -1
  38. data/app/views/foreman_acd/api/v2/app_instances/index.json.rabl +2 -0
  39. data/app/views/foreman_acd/api/v2/app_instances/show.json.rabl +2 -0
  40. data/app/views/foreman_acd/app_definitions/_form.html.erb +9 -1
  41. data/app/views/foreman_acd/app_definitions/edit.html.erb +10 -5
  42. data/app/views/foreman_acd/app_definitions/import.html.erb +20 -1
  43. data/app/views/foreman_acd/app_definitions/index.html.erb +5 -8
  44. data/app/views/foreman_acd/app_instances/_form.html.erb +4 -4
  45. data/app/views/foreman_acd/app_instances/edit.html.erb +10 -0
  46. data/app/views/foreman_acd/app_instances/index.html.erb +93 -14
  47. data/app/views/foreman_acd/app_instances/report.html.erb +12 -4
  48. data/app/views/templates/job/run_acd_ansible_playbook.erb +28 -15
  49. data/app/views/ui_acd/app_definition.json.rabl +1 -1
  50. data/app/views/ui_acd/host_report.json.rabl +4 -0
  51. data/app/views/ui_acd/report_data.json.rabl +10 -0
  52. data/app/views/ui_acd/validate_hostname.json.rabl +6 -0
  53. data/config/routes.rb +12 -3
  54. data/db/migrate/20200917120220_add_ansible_playbook_id.rb +1 -1
  55. data/db/migrate/20201016002819_add_ansible_vars_all_to_app_definitions.rb +3 -0
  56. data/db/migrate/20201016104338_add_ansible_vars_all_to_app_instances.rb +3 -0
  57. data/db/migrate/20210112111548_add_organization_to_app_instance.rb +22 -0
  58. data/db/migrate/20210112113853_add_location_to_app_instance.rb +8 -0
  59. data/db/migrate/20210202141658_create_foreman_hosts.rb +24 -0
  60. data/db/migrate/20210204111306_remove_hosts_from_app_instances.rb +8 -0
  61. data/db/migrate/20210209091014_rename_acd_tables.rb +16 -0
  62. data/db/migrate/20210216083522_add_last_progress_report.rb +8 -0
  63. data/db/migrate/20210216091529_add_last_deploy_task.rb +8 -0
  64. data/db/migrate/20210316151145_add_git_commit_to_ansible_playbooks.rb +8 -0
  65. data/db/migrate/20210503122809_add_git_url_to_ansible_playbooks.rb +8 -0
  66. data/db/migrate/20210818125913_add_is_existing_host_to_foreman_host.rb +8 -0
  67. data/db/migrate/20210902110645_add_initial_configure_task.rb +8 -0
  68. data/db/seeds.d/62_acd_proxy_feature.rb +4 -0
  69. data/db/seeds.d/75-job_templates.rb +6 -1
  70. data/lib/foreman_acd/engine.rb +40 -3
  71. data/lib/foreman_acd/plugin.rb +60 -45
  72. data/lib/foreman_acd/version.rb +1 -1
  73. data/lib/foreman_acd.rb +30 -0
  74. data/lib/tasks/foreman_acd_tasks.rake +0 -12
  75. data/locale/en/foreman_acd.edit.po +326 -0
  76. data/locale/en/foreman_acd.po +232 -2
  77. data/{app/controllers/foreman_acd/api/v2/app_playbooks_controller.rb → locale/en/foreman_acd.po.time_stamp} +0 -0
  78. data/locale/foreman_acd.pot +343 -8
  79. data/package.json +8 -8
  80. data/test/controllers/ansible_playbooks_controller_test.rb +27 -0
  81. data/test/controllers/app_instances_controller_test.rb +8 -3
  82. data/test/controllers/ui_acd_controller_test.rb +22 -6
  83. data/test/factories/foreman_acd_factories.rb +18 -4
  84. data/test/models/acd_provider_test.rb +37 -0
  85. data/test/models/ansible_playbook_test.rb +11 -0
  86. data/test/models/app_definition_test.rb +1 -1
  87. data/test/models/app_instance_test.rb +2 -0
  88. data/test/models/concerns/host_extensions_test.rb +26 -0
  89. data/test/models/foreman_host_test.rb +12 -0
  90. data/webpack/__mocks__/foremanReact/API.js +2 -0
  91. data/webpack/__mocks__/foremanReact/common/I18n.js +3 -0
  92. data/webpack/__mocks__/foremanReact/common/helpers.js +2 -0
  93. data/webpack/__mocks__/foremanReact/components/ForemanModal/ForemanModalActions.js +2 -0
  94. data/webpack/__mocks__/foremanReact/components/ForemanModal.js +7 -0
  95. data/webpack/__mocks__/foremanReact/components/common/forms/CommonForm.js +2 -0
  96. data/webpack/__mocks__/foremanReact/components/common/forms/TextInput.js +2 -0
  97. data/webpack/__mocks__/foremanReact/components/hosts/powerStatus.js +1 -0
  98. data/webpack/__snapshots__/helper.test.js.snap +14 -0
  99. data/webpack/components/ApplicationDefinition/ApplicationDefinition.js +55 -21
  100. data/webpack/components/ApplicationDefinition/ApplicationDefinitionActions.js +14 -0
  101. data/webpack/components/ApplicationDefinition/ApplicationDefinitionConstants.js +2 -0
  102. data/webpack/components/ApplicationDefinition/ApplicationDefinitionReducer.js +48 -1
  103. data/webpack/components/ApplicationDefinition/ApplicationDefinitionSelectors.js +4 -0
  104. data/webpack/components/ApplicationDefinition/__fixtures__/applicationDefinitionConfData_1.fixtures.js +288 -0
  105. data/webpack/components/ApplicationDefinition/__fixtures__/applicationDefinitionReducer.fixtures.js +79 -0
  106. data/webpack/components/ApplicationDefinition/__tests__/ApplicationDefinition.test.js +26 -0
  107. data/webpack/components/ApplicationDefinition/__tests__/ApplicationDefinitionReducer.test.js +119 -0
  108. data/webpack/components/ApplicationDefinition/__tests__/ApplicationDefinitionSelectors.test.js +41 -0
  109. data/webpack/components/ApplicationDefinition/__tests__/__snapshots__/ApplicationDefinition.test.js.snap +225 -0
  110. data/webpack/components/ApplicationDefinition/__tests__/__snapshots__/ApplicationDefinitionReducer.test.js.snap +3033 -0
  111. data/webpack/components/ApplicationDefinition/__tests__/__snapshots__/ApplicationDefinitionSelectors.test.js.snap +299 -0
  112. data/webpack/components/ApplicationDefinition/components/AnsiblePlaybookSelector.js +2 -1
  113. data/webpack/components/ApplicationDefinition/components/__tests__/AnsiblePlaybookSelector.test.js +41 -0
  114. data/webpack/components/ApplicationDefinition/components/__tests__/__snapshots__/AnsiblePlaybookSelector.test.js.snap +121 -0
  115. data/webpack/components/ApplicationDefinition/index.js +8 -0
  116. data/webpack/components/ApplicationDefinitionImport/ApplicationDefinitionImport.js +214 -0
  117. data/webpack/components/ApplicationDefinitionImport/ApplicationDefinitionImport.scss +1 -0
  118. data/webpack/components/ApplicationDefinitionImport/ApplicationDefinitionImportActions.js +161 -0
  119. data/webpack/components/ApplicationDefinitionImport/ApplicationDefinitionImportConstants.js +6 -0
  120. data/webpack/components/ApplicationDefinitionImport/ApplicationDefinitionImportReducer.js +79 -0
  121. data/webpack/components/ApplicationDefinitionImport/ApplicationDefinitionImportSelectors.js +8 -0
  122. data/webpack/components/ApplicationDefinitionImport/__fixtures__/applicationDefinitionImportConfData_1.fixtures.js +129 -0
  123. data/webpack/components/ApplicationDefinitionImport/__fixtures__/applicationDefinitionImportReducer.fixtures.js +29 -0
  124. data/webpack/components/ApplicationDefinitionImport/__tests__/ApplicationDefinitionImport.test.js +20 -0
  125. data/webpack/components/ApplicationDefinitionImport/__tests__/ApplicationDefinitionImportReducer.test.js +43 -0
  126. data/webpack/components/ApplicationDefinitionImport/__tests__/ApplicationDefinitionImportSelectors.test.js +29 -0
  127. data/webpack/components/ApplicationDefinitionImport/__tests__/__snapshots__/ApplicationDefinitionImport.test.js.snap +62 -0
  128. data/webpack/components/ApplicationDefinitionImport/__tests__/__snapshots__/ApplicationDefinitionImportReducer.test.js.snap +362 -0
  129. data/webpack/components/ApplicationDefinitionImport/__tests__/__snapshots__/ApplicationDefinitionImportSelectors.test.js.snap +130 -0
  130. data/webpack/components/ApplicationDefinitionImport/index.js +32 -0
  131. data/webpack/components/ApplicationInstance/ApplicationInstance.js +153 -45
  132. data/webpack/components/ApplicationInstance/ApplicationInstanceActions.js +120 -6
  133. data/webpack/components/ApplicationInstance/ApplicationInstanceConstants.js +5 -0
  134. data/webpack/components/ApplicationInstance/ApplicationInstanceHelper.js +15 -0
  135. data/webpack/components/ApplicationInstance/ApplicationInstanceReducer.js +77 -22
  136. data/webpack/components/ApplicationInstance/ApplicationInstanceSelectors.js +4 -0
  137. data/webpack/components/ApplicationInstance/__fixtures__/applicationInstanceConfData_1.fixtures.js +263 -0
  138. data/webpack/components/ApplicationInstance/__fixtures__/applicationInstanceReducer.fixtures.js +80 -0
  139. data/webpack/components/ApplicationInstance/__tests__/ApplicationInstance.test.js +24 -0
  140. data/webpack/components/ApplicationInstance/__tests__/ApplicationInstanceReducer.test.js +131 -0
  141. data/webpack/components/ApplicationInstance/__tests__/ApplicationInstanceSelectors.test.js +44 -0
  142. data/webpack/components/ApplicationInstance/__tests__/__snapshots__/ApplicationInstance.test.js.snap +299 -0
  143. data/webpack/components/ApplicationInstance/__tests__/__snapshots__/ApplicationInstanceReducer.test.js.snap +2990 -0
  144. data/webpack/components/ApplicationInstance/__tests__/__snapshots__/ApplicationInstanceSelectors.test.js.snap +276 -0
  145. data/webpack/components/ApplicationInstance/components/AppDefinitionSelector.js +1 -0
  146. data/webpack/components/ApplicationInstance/components/Service.js +1 -1
  147. data/webpack/components/ApplicationInstance/components/ServiceCounter.js +1 -1
  148. data/webpack/components/ApplicationInstance/helper.js +0 -0
  149. data/webpack/components/ApplicationInstance/index.js +8 -0
  150. data/webpack/components/ApplicationInstanceReport/ApplicationInstanceReport.js +128 -60
  151. data/webpack/components/ApplicationInstanceReport/ApplicationInstanceReport.scss +17 -0
  152. data/webpack/components/ApplicationInstanceReport/ApplicationInstanceReportActions.js +40 -50
  153. data/webpack/components/ApplicationInstanceReport/ApplicationInstanceReportConstants.js +5 -4
  154. data/webpack/components/ApplicationInstanceReport/ApplicationInstanceReportReducer.js +19 -14
  155. data/webpack/components/ApplicationInstanceReport/ApplicationInstanceReportSelectors.js +4 -1
  156. data/webpack/components/ApplicationInstanceReport/__fixtures__/applicationInstanceReportData_1.fixtures.js +349 -0
  157. data/webpack/components/ApplicationInstanceReport/__fixtures__/applicationInstanceReportReducer.fixtures.js +20 -0
  158. data/webpack/components/ApplicationInstanceReport/__tests__/ApplicationInstanceReport.test.js +47 -0
  159. data/webpack/components/ApplicationInstanceReport/__tests__/ApplicationInstanceReportReducer.test.js +41 -0
  160. data/webpack/components/ApplicationInstanceReport/__tests__/ApplicationInstanceReportSelectors.test.js +26 -0
  161. data/webpack/components/ApplicationInstanceReport/__tests__/__snapshots__/ApplicationInstanceReport.test.js.snap +7 -0
  162. data/webpack/components/ApplicationInstanceReport/__tests__/__snapshots__/ApplicationInstanceReportReducer.test.js.snap +718 -0
  163. data/webpack/components/ApplicationInstanceReport/__tests__/__snapshots__/ApplicationInstanceReportSelectors.test.js.snap +347 -0
  164. data/webpack/components/ApplicationInstanceReport/components/ReportViewer.js +1 -1
  165. data/webpack/components/ApplicationInstanceReport/components/__tests__/ReportViewer.test.js +24 -0
  166. data/webpack/components/ApplicationInstanceReport/components/__tests__/__snapshots__/ReportViewer.test.js.snap +24 -0
  167. data/webpack/components/ApplicationInstanceReport/index.js +8 -3
  168. data/webpack/components/ExistingHostSelection/ExistingHostSelection.js +104 -0
  169. data/webpack/components/ExistingHostSelection/ExistingHostSelection.scss +15 -0
  170. data/webpack/components/ExistingHostSelection/ExistingHostSelectionActions.js +71 -0
  171. data/webpack/components/ExistingHostSelection/ExistingHostSelectionConstants.js +4 -0
  172. data/webpack/components/ExistingHostSelection/ExistingHostSelectionHelper.js +0 -0
  173. data/webpack/components/ExistingHostSelection/ExistingHostSelectionReducer.js +90 -0
  174. data/webpack/components/ExistingHostSelection/ExistingHostSelectionSelectors.js +8 -0
  175. data/webpack/components/ExistingHostSelection/__fixtures__/existingHostSelectionConfData_1.fixtures.js +191 -0
  176. data/webpack/components/ExistingHostSelection/__fixtures__/existingHostSelectionReducer.fixtures.js +203 -0
  177. data/webpack/components/ExistingHostSelection/__tests__/ExistingHostSelection.test.js +19 -0
  178. data/webpack/components/ExistingHostSelection/__tests__/ExistingHostSelectionReducer.test.js +59 -0
  179. data/webpack/components/ExistingHostSelection/__tests__/ExistingHostSelectionSelectors.test.js +36 -0
  180. data/webpack/components/ExistingHostSelection/__tests__/__snapshots__/ExistingHostSelection.test.js.snap +35 -0
  181. data/webpack/components/ExistingHostSelection/__tests__/__snapshots__/ExistingHostSelectionReducer.test.js.snap +614 -0
  182. data/webpack/components/ExistingHostSelection/__tests__/__snapshots__/ExistingHostSelectionSelectors.test.js.snap +27 -0
  183. data/webpack/components/ExistingHostSelection/components/ServiceSelector.js +48 -0
  184. data/webpack/components/ExistingHostSelection/components/__tests__/ServiceSelector.test.js +35 -0
  185. data/webpack/components/ExistingHostSelection/components/__tests__/__snapshots__/ServiceSelector.test.js.snap +77 -0
  186. data/webpack/components/ExistingHostSelection/index.js +26 -0
  187. data/webpack/components/ParameterSelection/ParameterSelection.js +138 -15
  188. data/webpack/components/ParameterSelection/ParameterSelection.scss +7 -0
  189. data/webpack/components/ParameterSelection/ParameterSelectionActions.js +52 -9
  190. data/webpack/components/ParameterSelection/ParameterSelectionConstants.js +3 -0
  191. data/webpack/components/ParameterSelection/ParameterSelectionReducer.js +62 -25
  192. data/webpack/components/ParameterSelection/ParameterSelectionSelectors.js +1 -0
  193. data/webpack/components/ParameterSelection/__fixtures__/parameterSelectionData_1.fixtures.js +116 -84
  194. data/webpack/components/ParameterSelection/__fixtures__/parameterSelectionReducer.fixtures.js +10 -4
  195. data/webpack/components/ParameterSelection/__tests__/ParameterSelection.test.js +36 -46
  196. data/webpack/components/ParameterSelection/__tests__/ParameterSelectionReducer.test.js +33 -25
  197. data/webpack/components/ParameterSelection/__tests__/ParameterSelectionSelectors.test.js +6 -6
  198. data/webpack/components/ParameterSelection/__tests__/__snapshots__/ParameterSelection.test.js.snap +84 -112
  199. data/webpack/components/ParameterSelection/__tests__/__snapshots__/ParameterSelectionReducer.test.js.snap +1488 -872
  200. data/webpack/components/ParameterSelection/__tests__/__snapshots__/ParameterSelectionSelectors.test.js.snap +117 -79
  201. data/webpack/components/ParameterSelection/index.js +2 -1
  202. data/webpack/components/SyncGitRepo/SyncGitRepo.js +202 -0
  203. data/webpack/components/SyncGitRepo/SyncGitRepo.scss +1 -0
  204. data/webpack/components/SyncGitRepo/SyncGitRepoActions.js +123 -0
  205. data/webpack/components/SyncGitRepo/SyncGitRepoConstants.js +8 -0
  206. data/webpack/components/SyncGitRepo/SyncGitRepoReducer.js +80 -0
  207. data/webpack/components/SyncGitRepo/SyncGitRepoSelectors.js +6 -0
  208. data/webpack/components/SyncGitRepo/__fixtures__/syncGitRepoConfData_1.fixtures.js +7 -0
  209. data/webpack/components/SyncGitRepo/__fixtures__/syncGitRepoReducer.fixtures.js +44 -0
  210. data/webpack/components/SyncGitRepo/__tests__/SyncGitRepo.test.js +27 -0
  211. data/webpack/components/SyncGitRepo/__tests__/SyncGitRepoReducer.test.js +95 -0
  212. data/webpack/components/SyncGitRepo/__tests__/SyncGitRepoSelectors.test.js +32 -0
  213. data/webpack/components/SyncGitRepo/__tests__/__snapshots__/SyncGitRepo.test.js.snap +31 -0
  214. data/webpack/components/SyncGitRepo/__tests__/__snapshots__/SyncGitRepoReducer.test.js.snap +137 -0
  215. data/webpack/components/SyncGitRepo/__tests__/__snapshots__/SyncGitRepoSelectors.test.js.snap +13 -0
  216. data/webpack/components/SyncGitRepo/components/FormTextInput.js +42 -0
  217. data/webpack/components/SyncGitRepo/components/ScmTypeSelector.js +47 -0
  218. data/webpack/components/SyncGitRepo/index.js +28 -0
  219. data/webpack/components/common/DeleteTableEntry.js +18 -4
  220. data/webpack/components/common/EditTableEntry.js +50 -0
  221. data/webpack/components/common/ExtTextInput.js +43 -0
  222. data/webpack/components/common/LockTableEntry.js +60 -0
  223. data/webpack/components/common/__tests__/EditTableEntry.test.js +53 -0
  224. data/webpack/components/common/__tests__/LockTableEntry.test.js +35 -0
  225. data/webpack/components/common/__tests__/__snapshots__/DeleteTableEntry.test.js.snap +40 -2
  226. data/webpack/components/common/__tests__/__snapshots__/EditTableEntry.test.js.snap +81 -0
  227. data/webpack/components/common/__tests__/__snapshots__/LockTableEntry.test.js.snap +60 -0
  228. data/webpack/helper.js +20 -1
  229. data/webpack/helper.test.js +37 -0
  230. data/webpack/index.js +7 -0
  231. data/webpack/js-yaml.js +3874 -0
  232. data/webpack/reducer.js +16 -1
  233. metadata +182 -11
  234. data/app/views/foreman_acd/app_instances/deploy.html.erb +0 -19
  235. data/webpack/components/common/EasyHeaderFormatter.js +0 -18
  236. data/webpack/components/common/__tests__/__snapshots__/AddParameter.test.js.snap +0 -35
  237. data/webpack/components/common/__tests__/__snapshots__/DeleteParameter.test.js.snap +0 -41
@@ -0,0 +1,3874 @@
1
+
2
+ /*! js-yaml 4.1.0 https://github.com/nodeca/js-yaml @license MIT */
3
+ (function (global, factory) {
4
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
5
+ typeof define === 'function' && define.amd ? define(['exports'], factory) :
6
+ (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.jsyaml = {}));
7
+ }(this, (function (exports) { 'use strict';
8
+
9
+ function isNothing(subject) {
10
+ return (typeof subject === 'undefined') || (subject === null);
11
+ }
12
+
13
+
14
+ function isObject(subject) {
15
+ return (typeof subject === 'object') && (subject !== null);
16
+ }
17
+
18
+
19
+ function toArray(sequence) {
20
+ if (Array.isArray(sequence)) return sequence;
21
+ else if (isNothing(sequence)) return [];
22
+
23
+ return [ sequence ];
24
+ }
25
+
26
+
27
+ function extend(target, source) {
28
+ var index, length, key, sourceKeys;
29
+
30
+ if (source) {
31
+ sourceKeys = Object.keys(source);
32
+
33
+ for (index = 0, length = sourceKeys.length; index < length; index += 1) {
34
+ key = sourceKeys[index];
35
+ target[key] = source[key];
36
+ }
37
+ }
38
+
39
+ return target;
40
+ }
41
+
42
+
43
+ function repeat(string, count) {
44
+ var result = '', cycle;
45
+
46
+ for (cycle = 0; cycle < count; cycle += 1) {
47
+ result += string;
48
+ }
49
+
50
+ return result;
51
+ }
52
+
53
+
54
+ function isNegativeZero(number) {
55
+ return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number);
56
+ }
57
+
58
+
59
+ var isNothing_1 = isNothing;
60
+ var isObject_1 = isObject;
61
+ var toArray_1 = toArray;
62
+ var repeat_1 = repeat;
63
+ var isNegativeZero_1 = isNegativeZero;
64
+ var extend_1 = extend;
65
+
66
+ var common = {
67
+ isNothing: isNothing_1,
68
+ isObject: isObject_1,
69
+ toArray: toArray_1,
70
+ repeat: repeat_1,
71
+ isNegativeZero: isNegativeZero_1,
72
+ extend: extend_1
73
+ };
74
+
75
+ // YAML error class. http://stackoverflow.com/questions/8458984
76
+
77
+
78
+ function formatError(exception, compact) {
79
+ var where = '', message = exception.reason || '(unknown reason)';
80
+
81
+ if (!exception.mark) return message;
82
+
83
+ if (exception.mark.name) {
84
+ where += 'in "' + exception.mark.name + '" ';
85
+ }
86
+
87
+ where += '(' + (exception.mark.line + 1) + ':' + (exception.mark.column + 1) + ')';
88
+
89
+ if (!compact && exception.mark.snippet) {
90
+ where += '\n\n' + exception.mark.snippet;
91
+ }
92
+
93
+ return message + ' ' + where;
94
+ }
95
+
96
+
97
+ function YAMLException$1(reason, mark) {
98
+ // Super constructor
99
+ Error.call(this);
100
+
101
+ this.name = 'YAMLException';
102
+ this.reason = reason;
103
+ this.mark = mark;
104
+ this.message = formatError(this, false);
105
+
106
+ // Include stack trace in error object
107
+ if (Error.captureStackTrace) {
108
+ // Chrome and NodeJS
109
+ Error.captureStackTrace(this, this.constructor);
110
+ } else {
111
+ // FF, IE 10+ and Safari 6+. Fallback for others
112
+ this.stack = (new Error()).stack || '';
113
+ }
114
+ }
115
+
116
+
117
+ // Inherit from Error
118
+ YAMLException$1.prototype = Object.create(Error.prototype);
119
+ YAMLException$1.prototype.constructor = YAMLException$1;
120
+
121
+
122
+ YAMLException$1.prototype.toString = function toString(compact) {
123
+ return this.name + ': ' + formatError(this, compact);
124
+ };
125
+
126
+
127
+ var exception = YAMLException$1;
128
+
129
+ // get snippet for a single line, respecting maxLength
130
+ function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
131
+ var head = '';
132
+ var tail = '';
133
+ var maxHalfLength = Math.floor(maxLineLength / 2) - 1;
134
+
135
+ if (position - lineStart > maxHalfLength) {
136
+ head = ' ... ';
137
+ lineStart = position - maxHalfLength + head.length;
138
+ }
139
+
140
+ if (lineEnd - position > maxHalfLength) {
141
+ tail = ' ...';
142
+ lineEnd = position + maxHalfLength - tail.length;
143
+ }
144
+
145
+ return {
146
+ str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, '→') + tail,
147
+ pos: position - lineStart + head.length // relative position
148
+ };
149
+ }
150
+
151
+
152
+ function padStart(string, max) {
153
+ return common.repeat(' ', max - string.length) + string;
154
+ }
155
+
156
+
157
+ function makeSnippet(mark, options) {
158
+ options = Object.create(options || null);
159
+
160
+ if (!mark.buffer) return null;
161
+
162
+ if (!options.maxLength) options.maxLength = 79;
163
+ if (typeof options.indent !== 'number') options.indent = 1;
164
+ if (typeof options.linesBefore !== 'number') options.linesBefore = 3;
165
+ if (typeof options.linesAfter !== 'number') options.linesAfter = 2;
166
+
167
+ var re = /\r?\n|\r|\0/g;
168
+ var lineStarts = [ 0 ];
169
+ var lineEnds = [];
170
+ var match;
171
+ var foundLineNo = -1;
172
+
173
+ while ((match = re.exec(mark.buffer))) {
174
+ lineEnds.push(match.index);
175
+ lineStarts.push(match.index + match[0].length);
176
+
177
+ if (mark.position <= match.index && foundLineNo < 0) {
178
+ foundLineNo = lineStarts.length - 2;
179
+ }
180
+ }
181
+
182
+ if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;
183
+
184
+ var result = '', i, line;
185
+ var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
186
+ var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);
187
+
188
+ for (i = 1; i <= options.linesBefore; i++) {
189
+ if (foundLineNo - i < 0) break;
190
+ line = getLine(
191
+ mark.buffer,
192
+ lineStarts[foundLineNo - i],
193
+ lineEnds[foundLineNo - i],
194
+ mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]),
195
+ maxLineLength
196
+ );
197
+ result = common.repeat(' ', options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) +
198
+ ' | ' + line.str + '\n' + result;
199
+ }
200
+
201
+ line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
202
+ result += common.repeat(' ', options.indent) + padStart((mark.line + 1).toString(), lineNoLength) +
203
+ ' | ' + line.str + '\n';
204
+ result += common.repeat('-', options.indent + lineNoLength + 3 + line.pos) + '^' + '\n';
205
+
206
+ for (i = 1; i <= options.linesAfter; i++) {
207
+ if (foundLineNo + i >= lineEnds.length) break;
208
+ line = getLine(
209
+ mark.buffer,
210
+ lineStarts[foundLineNo + i],
211
+ lineEnds[foundLineNo + i],
212
+ mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]),
213
+ maxLineLength
214
+ );
215
+ result += common.repeat(' ', options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) +
216
+ ' | ' + line.str + '\n';
217
+ }
218
+
219
+ return result.replace(/\n$/, '');
220
+ }
221
+
222
+
223
+ var snippet = makeSnippet;
224
+
225
+ var TYPE_CONSTRUCTOR_OPTIONS = [
226
+ 'kind',
227
+ 'multi',
228
+ 'resolve',
229
+ 'construct',
230
+ 'instanceOf',
231
+ 'predicate',
232
+ 'represent',
233
+ 'representName',
234
+ 'defaultStyle',
235
+ 'styleAliases'
236
+ ];
237
+
238
+ var YAML_NODE_KINDS = [
239
+ 'scalar',
240
+ 'sequence',
241
+ 'mapping'
242
+ ];
243
+
244
+ function compileStyleAliases(map) {
245
+ var result = {};
246
+
247
+ if (map !== null) {
248
+ Object.keys(map).forEach(function (style) {
249
+ map[style].forEach(function (alias) {
250
+ result[String(alias)] = style;
251
+ });
252
+ });
253
+ }
254
+
255
+ return result;
256
+ }
257
+
258
+ function Type$1(tag, options) {
259
+ options = options || {};
260
+
261
+ Object.keys(options).forEach(function (name) {
262
+ if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
263
+ throw new exception('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
264
+ }
265
+ });
266
+
267
+ // TODO: Add tag format check.
268
+ this.options = options; // keep original options in case user wants to extend this type later
269
+ this.tag = tag;
270
+ this.kind = options['kind'] || null;
271
+ this.resolve = options['resolve'] || function () { return true; };
272
+ this.construct = options['construct'] || function (data) { return data; };
273
+ this.instanceOf = options['instanceOf'] || null;
274
+ this.predicate = options['predicate'] || null;
275
+ this.represent = options['represent'] || null;
276
+ this.representName = options['representName'] || null;
277
+ this.defaultStyle = options['defaultStyle'] || null;
278
+ this.multi = options['multi'] || false;
279
+ this.styleAliases = compileStyleAliases(options['styleAliases'] || null);
280
+
281
+ if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
282
+ throw new exception('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
283
+ }
284
+ }
285
+
286
+ var type = Type$1;
287
+
288
+ /*eslint-disable max-len*/
289
+
290
+
291
+
292
+
293
+
294
+ function compileList(schema, name) {
295
+ var result = [];
296
+
297
+ schema[name].forEach(function (currentType) {
298
+ var newIndex = result.length;
299
+
300
+ result.forEach(function (previousType, previousIndex) {
301
+ if (previousType.tag === currentType.tag &&
302
+ previousType.kind === currentType.kind &&
303
+ previousType.multi === currentType.multi) {
304
+
305
+ newIndex = previousIndex;
306
+ }
307
+ });
308
+
309
+ result[newIndex] = currentType;
310
+ });
311
+
312
+ return result;
313
+ }
314
+
315
+
316
+ function compileMap(/* lists... */) {
317
+ var result = {
318
+ scalar: {},
319
+ sequence: {},
320
+ mapping: {},
321
+ fallback: {},
322
+ multi: {
323
+ scalar: [],
324
+ sequence: [],
325
+ mapping: [],
326
+ fallback: []
327
+ }
328
+ }, index, length;
329
+
330
+ function collectType(type) {
331
+ if (type.multi) {
332
+ result.multi[type.kind].push(type);
333
+ result.multi['fallback'].push(type);
334
+ } else {
335
+ result[type.kind][type.tag] = result['fallback'][type.tag] = type;
336
+ }
337
+ }
338
+
339
+ for (index = 0, length = arguments.length; index < length; index += 1) {
340
+ arguments[index].forEach(collectType);
341
+ }
342
+ return result;
343
+ }
344
+
345
+
346
+ function Schema$1(definition) {
347
+ return this.extend(definition);
348
+ }
349
+
350
+
351
+ Schema$1.prototype.extend = function extend(definition) {
352
+ var implicit = [];
353
+ var explicit = [];
354
+
355
+ if (definition instanceof type) {
356
+ // Schema.extend(type)
357
+ explicit.push(definition);
358
+
359
+ } else if (Array.isArray(definition)) {
360
+ // Schema.extend([ type1, type2, ... ])
361
+ explicit = explicit.concat(definition);
362
+
363
+ } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
364
+ // Schema.extend({ explicit: [ type1, type2, ... ], implicit: [ type1, type2, ... ] })
365
+ if (definition.implicit) implicit = implicit.concat(definition.implicit);
366
+ if (definition.explicit) explicit = explicit.concat(definition.explicit);
367
+
368
+ } else {
369
+ throw new exception('Schema.extend argument should be a Type, [ Type ], ' +
370
+ 'or a schema definition ({ implicit: [...], explicit: [...] })');
371
+ }
372
+
373
+ implicit.forEach(function (type$1) {
374
+ if (!(type$1 instanceof type)) {
375
+ throw new exception('Specified list of YAML types (or a single Type object) contains a non-Type object.');
376
+ }
377
+
378
+ if (type$1.loadKind && type$1.loadKind !== 'scalar') {
379
+ throw new exception('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');
380
+ }
381
+
382
+ if (type$1.multi) {
383
+ throw new exception('There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.');
384
+ }
385
+ });
386
+
387
+ explicit.forEach(function (type$1) {
388
+ if (!(type$1 instanceof type)) {
389
+ throw new exception('Specified list of YAML types (or a single Type object) contains a non-Type object.');
390
+ }
391
+ });
392
+
393
+ var result = Object.create(Schema$1.prototype);
394
+
395
+ result.implicit = (this.implicit || []).concat(implicit);
396
+ result.explicit = (this.explicit || []).concat(explicit);
397
+
398
+ result.compiledImplicit = compileList(result, 'implicit');
399
+ result.compiledExplicit = compileList(result, 'explicit');
400
+ result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit);
401
+
402
+ return result;
403
+ };
404
+
405
+
406
+ var schema = Schema$1;
407
+
408
+ var str = new type('tag:yaml.org,2002:str', {
409
+ kind: 'scalar',
410
+ construct: function (data) { return data !== null ? data : ''; }
411
+ });
412
+
413
+ var seq = new type('tag:yaml.org,2002:seq', {
414
+ kind: 'sequence',
415
+ construct: function (data) { return data !== null ? data : []; }
416
+ });
417
+
418
+ var map = new type('tag:yaml.org,2002:map', {
419
+ kind: 'mapping',
420
+ construct: function (data) { return data !== null ? data : {}; }
421
+ });
422
+
423
+ var failsafe = new schema({
424
+ explicit: [
425
+ str,
426
+ seq,
427
+ map
428
+ ]
429
+ });
430
+
431
+ function resolveYamlNull(data) {
432
+ if (data === null) return true;
433
+
434
+ var max = data.length;
435
+
436
+ return (max === 1 && data === '~') ||
437
+ (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'));
438
+ }
439
+
440
+ function constructYamlNull() {
441
+ return null;
442
+ }
443
+
444
+ function isNull(object) {
445
+ return object === null;
446
+ }
447
+
448
+ var _null = new type('tag:yaml.org,2002:null', {
449
+ kind: 'scalar',
450
+ resolve: resolveYamlNull,
451
+ construct: constructYamlNull,
452
+ predicate: isNull,
453
+ represent: {
454
+ canonical: function () { return '~'; },
455
+ lowercase: function () { return 'null'; },
456
+ uppercase: function () { return 'NULL'; },
457
+ camelcase: function () { return 'Null'; },
458
+ empty: function () { return ''; }
459
+ },
460
+ defaultStyle: 'lowercase'
461
+ });
462
+
463
+ function resolveYamlBoolean(data) {
464
+ if (data === null) return false;
465
+
466
+ var max = data.length;
467
+
468
+ return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) ||
469
+ (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'));
470
+ }
471
+
472
+ function constructYamlBoolean(data) {
473
+ return data === 'true' ||
474
+ data === 'True' ||
475
+ data === 'TRUE';
476
+ }
477
+
478
+ function isBoolean(object) {
479
+ return Object.prototype.toString.call(object) === '[object Boolean]';
480
+ }
481
+
482
+ var bool = new type('tag:yaml.org,2002:bool', {
483
+ kind: 'scalar',
484
+ resolve: resolveYamlBoolean,
485
+ construct: constructYamlBoolean,
486
+ predicate: isBoolean,
487
+ represent: {
488
+ lowercase: function (object) { return object ? 'true' : 'false'; },
489
+ uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; },
490
+ camelcase: function (object) { return object ? 'True' : 'False'; }
491
+ },
492
+ defaultStyle: 'lowercase'
493
+ });
494
+
495
+ function isHexCode(c) {
496
+ return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) ||
497
+ ((0x41/* A */ <= c) && (c <= 0x46/* F */)) ||
498
+ ((0x61/* a */ <= c) && (c <= 0x66/* f */));
499
+ }
500
+
501
+ function isOctCode(c) {
502
+ return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */));
503
+ }
504
+
505
+ function isDecCode(c) {
506
+ return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */));
507
+ }
508
+
509
+ function resolveYamlInteger(data) {
510
+ if (data === null) return false;
511
+
512
+ var max = data.length,
513
+ index = 0,
514
+ hasDigits = false,
515
+ ch;
516
+
517
+ if (!max) return false;
518
+
519
+ ch = data[index];
520
+
521
+ // sign
522
+ if (ch === '-' || ch === '+') {
523
+ ch = data[++index];
524
+ }
525
+
526
+ if (ch === '0') {
527
+ // 0
528
+ if (index + 1 === max) return true;
529
+ ch = data[++index];
530
+
531
+ // base 2, base 8, base 16
532
+
533
+ if (ch === 'b') {
534
+ // base 2
535
+ index++;
536
+
537
+ for (; index < max; index++) {
538
+ ch = data[index];
539
+ if (ch === '_') continue;
540
+ if (ch !== '0' && ch !== '1') return false;
541
+ hasDigits = true;
542
+ }
543
+ return hasDigits && ch !== '_';
544
+ }
545
+
546
+
547
+ if (ch === 'x') {
548
+ // base 16
549
+ index++;
550
+
551
+ for (; index < max; index++) {
552
+ ch = data[index];
553
+ if (ch === '_') continue;
554
+ if (!isHexCode(data.charCodeAt(index))) return false;
555
+ hasDigits = true;
556
+ }
557
+ return hasDigits && ch !== '_';
558
+ }
559
+
560
+
561
+ if (ch === 'o') {
562
+ // base 8
563
+ index++;
564
+
565
+ for (; index < max; index++) {
566
+ ch = data[index];
567
+ if (ch === '_') continue;
568
+ if (!isOctCode(data.charCodeAt(index))) return false;
569
+ hasDigits = true;
570
+ }
571
+ return hasDigits && ch !== '_';
572
+ }
573
+ }
574
+
575
+ // base 10 (except 0)
576
+
577
+ // value should not start with `_`;
578
+ if (ch === '_') return false;
579
+
580
+ for (; index < max; index++) {
581
+ ch = data[index];
582
+ if (ch === '_') continue;
583
+ if (!isDecCode(data.charCodeAt(index))) {
584
+ return false;
585
+ }
586
+ hasDigits = true;
587
+ }
588
+
589
+ // Should have digits and should not end with `_`
590
+ if (!hasDigits || ch === '_') return false;
591
+
592
+ return true;
593
+ }
594
+
595
+ function constructYamlInteger(data) {
596
+ var value = data, sign = 1, ch;
597
+
598
+ if (value.indexOf('_') !== -1) {
599
+ value = value.replace(/_/g, '');
600
+ }
601
+
602
+ ch = value[0];
603
+
604
+ if (ch === '-' || ch === '+') {
605
+ if (ch === '-') sign = -1;
606
+ value = value.slice(1);
607
+ ch = value[0];
608
+ }
609
+
610
+ if (value === '0') return 0;
611
+
612
+ if (ch === '0') {
613
+ if (value[1] === 'b') return sign * parseInt(value.slice(2), 2);
614
+ if (value[1] === 'x') return sign * parseInt(value.slice(2), 16);
615
+ if (value[1] === 'o') return sign * parseInt(value.slice(2), 8);
616
+ }
617
+
618
+ return sign * parseInt(value, 10);
619
+ }
620
+
621
+ function isInteger(object) {
622
+ return (Object.prototype.toString.call(object)) === '[object Number]' &&
623
+ (object % 1 === 0 && !common.isNegativeZero(object));
624
+ }
625
+
626
+ var int = new type('tag:yaml.org,2002:int', {
627
+ kind: 'scalar',
628
+ resolve: resolveYamlInteger,
629
+ construct: constructYamlInteger,
630
+ predicate: isInteger,
631
+ represent: {
632
+ binary: function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1); },
633
+ octal: function (obj) { return obj >= 0 ? '0o' + obj.toString(8) : '-0o' + obj.toString(8).slice(1); },
634
+ decimal: function (obj) { return obj.toString(10); },
635
+ /* eslint-disable max-len */
636
+ hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() : '-0x' + obj.toString(16).toUpperCase().slice(1); }
637
+ },
638
+ defaultStyle: 'decimal',
639
+ styleAliases: {
640
+ binary: [ 2, 'bin' ],
641
+ octal: [ 8, 'oct' ],
642
+ decimal: [ 10, 'dec' ],
643
+ hexadecimal: [ 16, 'hex' ]
644
+ }
645
+ });
646
+
647
+ var YAML_FLOAT_PATTERN = new RegExp(
648
+ // 2.5e4, 2.5 and integers
649
+ '^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' +
650
+ // .2e4, .2
651
+ // special case, seems not from spec
652
+ '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' +
653
+ // .inf
654
+ '|[-+]?\\.(?:inf|Inf|INF)' +
655
+ // .nan
656
+ '|\\.(?:nan|NaN|NAN))$');
657
+
658
+ function resolveYamlFloat(data) {
659
+ if (data === null) return false;
660
+
661
+ if (!YAML_FLOAT_PATTERN.test(data) ||
662
+ // Quick hack to not allow integers end with `_`
663
+ // Probably should update regexp & check speed
664
+ data[data.length - 1] === '_') {
665
+ return false;
666
+ }
667
+
668
+ return true;
669
+ }
670
+
671
+ function constructYamlFloat(data) {
672
+ var value, sign;
673
+
674
+ value = data.replace(/_/g, '').toLowerCase();
675
+ sign = value[0] === '-' ? -1 : 1;
676
+
677
+ if ('+-'.indexOf(value[0]) >= 0) {
678
+ value = value.slice(1);
679
+ }
680
+
681
+ if (value === '.inf') {
682
+ return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
683
+
684
+ } else if (value === '.nan') {
685
+ return NaN;
686
+ }
687
+ return sign * parseFloat(value, 10);
688
+ }
689
+
690
+
691
+ var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
692
+
693
+ function representYamlFloat(object, style) {
694
+ var res;
695
+
696
+ if (isNaN(object)) {
697
+ switch (style) {
698
+ case 'lowercase': return '.nan';
699
+ case 'uppercase': return '.NAN';
700
+ case 'camelcase': return '.NaN';
701
+ }
702
+ } else if (Number.POSITIVE_INFINITY === object) {
703
+ switch (style) {
704
+ case 'lowercase': return '.inf';
705
+ case 'uppercase': return '.INF';
706
+ case 'camelcase': return '.Inf';
707
+ }
708
+ } else if (Number.NEGATIVE_INFINITY === object) {
709
+ switch (style) {
710
+ case 'lowercase': return '-.inf';
711
+ case 'uppercase': return '-.INF';
712
+ case 'camelcase': return '-.Inf';
713
+ }
714
+ } else if (common.isNegativeZero(object)) {
715
+ return '-0.0';
716
+ }
717
+
718
+ res = object.toString(10);
719
+
720
+ // JS stringifier can build scientific format without dots: 5e-100,
721
+ // while YAML requres dot: 5.e-100. Fix it with simple hack
722
+
723
+ return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res;
724
+ }
725
+
726
+ function isFloat(object) {
727
+ return (Object.prototype.toString.call(object) === '[object Number]') &&
728
+ (object % 1 !== 0 || common.isNegativeZero(object));
729
+ }
730
+
731
+ var float = new type('tag:yaml.org,2002:float', {
732
+ kind: 'scalar',
733
+ resolve: resolveYamlFloat,
734
+ construct: constructYamlFloat,
735
+ predicate: isFloat,
736
+ represent: representYamlFloat,
737
+ defaultStyle: 'lowercase'
738
+ });
739
+
740
+ var json = failsafe.extend({
741
+ implicit: [
742
+ _null,
743
+ bool,
744
+ int,
745
+ float
746
+ ]
747
+ });
748
+
749
+ var core = json;
750
+
751
+ var YAML_DATE_REGEXP = new RegExp(
752
+ '^([0-9][0-9][0-9][0-9])' + // [1] year
753
+ '-([0-9][0-9])' + // [2] month
754
+ '-([0-9][0-9])$'); // [3] day
755
+
756
+ var YAML_TIMESTAMP_REGEXP = new RegExp(
757
+ '^([0-9][0-9][0-9][0-9])' + // [1] year
758
+ '-([0-9][0-9]?)' + // [2] month
759
+ '-([0-9][0-9]?)' + // [3] day
760
+ '(?:[Tt]|[ \\t]+)' + // ...
761
+ '([0-9][0-9]?)' + // [4] hour
762
+ ':([0-9][0-9])' + // [5] minute
763
+ ':([0-9][0-9])' + // [6] second
764
+ '(?:\\.([0-9]*))?' + // [7] fraction
765
+ '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour
766
+ '(?::([0-9][0-9]))?))?$'); // [11] tz_minute
767
+
768
+ function resolveYamlTimestamp(data) {
769
+ if (data === null) return false;
770
+ if (YAML_DATE_REGEXP.exec(data) !== null) return true;
771
+ if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
772
+ return false;
773
+ }
774
+
775
+ function constructYamlTimestamp(data) {
776
+ var match, year, month, day, hour, minute, second, fraction = 0,
777
+ delta = null, tz_hour, tz_minute, date;
778
+
779
+ match = YAML_DATE_REGEXP.exec(data);
780
+ if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
781
+
782
+ if (match === null) throw new Error('Date resolve error');
783
+
784
+ // match: [1] year [2] month [3] day
785
+
786
+ year = +(match[1]);
787
+ month = +(match[2]) - 1; // JS month starts with 0
788
+ day = +(match[3]);
789
+
790
+ if (!match[4]) { // no hour
791
+ return new Date(Date.UTC(year, month, day));
792
+ }
793
+
794
+ // match: [4] hour [5] minute [6] second [7] fraction
795
+
796
+ hour = +(match[4]);
797
+ minute = +(match[5]);
798
+ second = +(match[6]);
799
+
800
+ if (match[7]) {
801
+ fraction = match[7].slice(0, 3);
802
+ while (fraction.length < 3) { // milli-seconds
803
+ fraction += '0';
804
+ }
805
+ fraction = +fraction;
806
+ }
807
+
808
+ // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute
809
+
810
+ if (match[9]) {
811
+ tz_hour = +(match[10]);
812
+ tz_minute = +(match[11] || 0);
813
+ delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds
814
+ if (match[9] === '-') delta = -delta;
815
+ }
816
+
817
+ date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
818
+
819
+ if (delta) date.setTime(date.getTime() - delta);
820
+
821
+ return date;
822
+ }
823
+
824
+ function representYamlTimestamp(object /*, style*/) {
825
+ return object.toISOString();
826
+ }
827
+
828
+ var timestamp = new type('tag:yaml.org,2002:timestamp', {
829
+ kind: 'scalar',
830
+ resolve: resolveYamlTimestamp,
831
+ construct: constructYamlTimestamp,
832
+ instanceOf: Date,
833
+ represent: representYamlTimestamp
834
+ });
835
+
836
+ function resolveYamlMerge(data) {
837
+ return data === '<<' || data === null;
838
+ }
839
+
840
+ var merge = new type('tag:yaml.org,2002:merge', {
841
+ kind: 'scalar',
842
+ resolve: resolveYamlMerge
843
+ });
844
+
845
+ /*eslint-disable no-bitwise*/
846
+
847
+
848
+
849
+
850
+
851
+ // [ 64, 65, 66 ] -> [ padding, CR, LF ]
852
+ var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r';
853
+
854
+
855
+ function resolveYamlBinary(data) {
856
+ if (data === null) return false;
857
+
858
+ var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;
859
+
860
+ // Convert one by one.
861
+ for (idx = 0; idx < max; idx++) {
862
+ code = map.indexOf(data.charAt(idx));
863
+
864
+ // Skip CR/LF
865
+ if (code > 64) continue;
866
+
867
+ // Fail on illegal characters
868
+ if (code < 0) return false;
869
+
870
+ bitlen += 6;
871
+ }
872
+
873
+ // If there are any bits left, source was corrupted
874
+ return (bitlen % 8) === 0;
875
+ }
876
+
877
+ function constructYamlBinary(data) {
878
+ var idx, tailbits,
879
+ input = data.replace(/[\r\n=]/g, ''), // remove CR/LF & padding to simplify scan
880
+ max = input.length,
881
+ map = BASE64_MAP,
882
+ bits = 0,
883
+ result = [];
884
+
885
+ // Collect by 6*4 bits (3 bytes)
886
+
887
+ for (idx = 0; idx < max; idx++) {
888
+ if ((idx % 4 === 0) && idx) {
889
+ result.push((bits >> 16) & 0xFF);
890
+ result.push((bits >> 8) & 0xFF);
891
+ result.push(bits & 0xFF);
892
+ }
893
+
894
+ bits = (bits << 6) | map.indexOf(input.charAt(idx));
895
+ }
896
+
897
+ // Dump tail
898
+
899
+ tailbits = (max % 4) * 6;
900
+
901
+ if (tailbits === 0) {
902
+ result.push((bits >> 16) & 0xFF);
903
+ result.push((bits >> 8) & 0xFF);
904
+ result.push(bits & 0xFF);
905
+ } else if (tailbits === 18) {
906
+ result.push((bits >> 10) & 0xFF);
907
+ result.push((bits >> 2) & 0xFF);
908
+ } else if (tailbits === 12) {
909
+ result.push((bits >> 4) & 0xFF);
910
+ }
911
+
912
+ return new Uint8Array(result);
913
+ }
914
+
915
+ function representYamlBinary(object /*, style*/) {
916
+ var result = '', bits = 0, idx, tail,
917
+ max = object.length,
918
+ map = BASE64_MAP;
919
+
920
+ // Convert every three bytes to 4 ASCII characters.
921
+
922
+ for (idx = 0; idx < max; idx++) {
923
+ if ((idx % 3 === 0) && idx) {
924
+ result += map[(bits >> 18) & 0x3F];
925
+ result += map[(bits >> 12) & 0x3F];
926
+ result += map[(bits >> 6) & 0x3F];
927
+ result += map[bits & 0x3F];
928
+ }
929
+
930
+ bits = (bits << 8) + object[idx];
931
+ }
932
+
933
+ // Dump tail
934
+
935
+ tail = max % 3;
936
+
937
+ if (tail === 0) {
938
+ result += map[(bits >> 18) & 0x3F];
939
+ result += map[(bits >> 12) & 0x3F];
940
+ result += map[(bits >> 6) & 0x3F];
941
+ result += map[bits & 0x3F];
942
+ } else if (tail === 2) {
943
+ result += map[(bits >> 10) & 0x3F];
944
+ result += map[(bits >> 4) & 0x3F];
945
+ result += map[(bits << 2) & 0x3F];
946
+ result += map[64];
947
+ } else if (tail === 1) {
948
+ result += map[(bits >> 2) & 0x3F];
949
+ result += map[(bits << 4) & 0x3F];
950
+ result += map[64];
951
+ result += map[64];
952
+ }
953
+
954
+ return result;
955
+ }
956
+
957
+ function isBinary(obj) {
958
+ return Object.prototype.toString.call(obj) === '[object Uint8Array]';
959
+ }
960
+
961
+ var binary = new type('tag:yaml.org,2002:binary', {
962
+ kind: 'scalar',
963
+ resolve: resolveYamlBinary,
964
+ construct: constructYamlBinary,
965
+ predicate: isBinary,
966
+ represent: representYamlBinary
967
+ });
968
+
969
+ var _hasOwnProperty$3 = Object.prototype.hasOwnProperty;
970
+ var _toString$2 = Object.prototype.toString;
971
+
972
+ function resolveYamlOmap(data) {
973
+ if (data === null) return true;
974
+
975
+ var objectKeys = [], index, length, pair, pairKey, pairHasKey,
976
+ object = data;
977
+
978
+ for (index = 0, length = object.length; index < length; index += 1) {
979
+ pair = object[index];
980
+ pairHasKey = false;
981
+
982
+ if (_toString$2.call(pair) !== '[object Object]') return false;
983
+
984
+ for (pairKey in pair) {
985
+ if (_hasOwnProperty$3.call(pair, pairKey)) {
986
+ if (!pairHasKey) pairHasKey = true;
987
+ else return false;
988
+ }
989
+ }
990
+
991
+ if (!pairHasKey) return false;
992
+
993
+ if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
994
+ else return false;
995
+ }
996
+
997
+ return true;
998
+ }
999
+
1000
+ function constructYamlOmap(data) {
1001
+ return data !== null ? data : [];
1002
+ }
1003
+
1004
+ var omap = new type('tag:yaml.org,2002:omap', {
1005
+ kind: 'sequence',
1006
+ resolve: resolveYamlOmap,
1007
+ construct: constructYamlOmap
1008
+ });
1009
+
1010
+ var _toString$1 = Object.prototype.toString;
1011
+
1012
+ function resolveYamlPairs(data) {
1013
+ if (data === null) return true;
1014
+
1015
+ var index, length, pair, keys, result,
1016
+ object = data;
1017
+
1018
+ result = new Array(object.length);
1019
+
1020
+ for (index = 0, length = object.length; index < length; index += 1) {
1021
+ pair = object[index];
1022
+
1023
+ if (_toString$1.call(pair) !== '[object Object]') return false;
1024
+
1025
+ keys = Object.keys(pair);
1026
+
1027
+ if (keys.length !== 1) return false;
1028
+
1029
+ result[index] = [ keys[0], pair[keys[0]] ];
1030
+ }
1031
+
1032
+ return true;
1033
+ }
1034
+
1035
+ function constructYamlPairs(data) {
1036
+ if (data === null) return [];
1037
+
1038
+ var index, length, pair, keys, result,
1039
+ object = data;
1040
+
1041
+ result = new Array(object.length);
1042
+
1043
+ for (index = 0, length = object.length; index < length; index += 1) {
1044
+ pair = object[index];
1045
+
1046
+ keys = Object.keys(pair);
1047
+
1048
+ result[index] = [ keys[0], pair[keys[0]] ];
1049
+ }
1050
+
1051
+ return result;
1052
+ }
1053
+
1054
+ var pairs = new type('tag:yaml.org,2002:pairs', {
1055
+ kind: 'sequence',
1056
+ resolve: resolveYamlPairs,
1057
+ construct: constructYamlPairs
1058
+ });
1059
+
1060
+ var _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
1061
+
1062
+ function resolveYamlSet(data) {
1063
+ if (data === null) return true;
1064
+
1065
+ var key, object = data;
1066
+
1067
+ for (key in object) {
1068
+ if (_hasOwnProperty$2.call(object, key)) {
1069
+ if (object[key] !== null) return false;
1070
+ }
1071
+ }
1072
+
1073
+ return true;
1074
+ }
1075
+
1076
+ function constructYamlSet(data) {
1077
+ return data !== null ? data : {};
1078
+ }
1079
+
1080
+ var set = new type('tag:yaml.org,2002:set', {
1081
+ kind: 'mapping',
1082
+ resolve: resolveYamlSet,
1083
+ construct: constructYamlSet
1084
+ });
1085
+
1086
+ var _default = core.extend({
1087
+ implicit: [
1088
+ timestamp,
1089
+ merge
1090
+ ],
1091
+ explicit: [
1092
+ binary,
1093
+ omap,
1094
+ pairs,
1095
+ set
1096
+ ]
1097
+ });
1098
+
1099
+ /*eslint-disable max-len,no-use-before-define*/
1100
+
1101
+
1102
+
1103
+
1104
+
1105
+
1106
+
1107
+ var _hasOwnProperty$1 = Object.prototype.hasOwnProperty;
1108
+
1109
+
1110
+ var CONTEXT_FLOW_IN = 1;
1111
+ var CONTEXT_FLOW_OUT = 2;
1112
+ var CONTEXT_BLOCK_IN = 3;
1113
+ var CONTEXT_BLOCK_OUT = 4;
1114
+
1115
+
1116
+ var CHOMPING_CLIP = 1;
1117
+ var CHOMPING_STRIP = 2;
1118
+ var CHOMPING_KEEP = 3;
1119
+
1120
+
1121
+ var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
1122
+ var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
1123
+ var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
1124
+ var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
1125
+ var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
1126
+
1127
+
1128
+ function _class(obj) { return Object.prototype.toString.call(obj); }
1129
+
1130
+ function is_EOL(c) {
1131
+ return (c === 0x0A/* LF */) || (c === 0x0D/* CR */);
1132
+ }
1133
+
1134
+ function is_WHITE_SPACE(c) {
1135
+ return (c === 0x09/* Tab */) || (c === 0x20/* Space */);
1136
+ }
1137
+
1138
+ function is_WS_OR_EOL(c) {
1139
+ return (c === 0x09/* Tab */) ||
1140
+ (c === 0x20/* Space */) ||
1141
+ (c === 0x0A/* LF */) ||
1142
+ (c === 0x0D/* CR */);
1143
+ }
1144
+
1145
+ function is_FLOW_INDICATOR(c) {
1146
+ return c === 0x2C/* , */ ||
1147
+ c === 0x5B/* [ */ ||
1148
+ c === 0x5D/* ] */ ||
1149
+ c === 0x7B/* { */ ||
1150
+ c === 0x7D/* } */;
1151
+ }
1152
+
1153
+ function fromHexCode(c) {
1154
+ var lc;
1155
+
1156
+ if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
1157
+ return c - 0x30;
1158
+ }
1159
+
1160
+ /*eslint-disable no-bitwise*/
1161
+ lc = c | 0x20;
1162
+
1163
+ if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) {
1164
+ return lc - 0x61 + 10;
1165
+ }
1166
+
1167
+ return -1;
1168
+ }
1169
+
1170
+ function escapedHexLen(c) {
1171
+ if (c === 0x78/* x */) { return 2; }
1172
+ if (c === 0x75/* u */) { return 4; }
1173
+ if (c === 0x55/* U */) { return 8; }
1174
+ return 0;
1175
+ }
1176
+
1177
+ function fromDecimalCode(c) {
1178
+ if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
1179
+ return c - 0x30;
1180
+ }
1181
+
1182
+ return -1;
1183
+ }
1184
+
1185
+ function simpleEscapeSequence(c) {
1186
+ /* eslint-disable indent */
1187
+ return (c === 0x30/* 0 */) ? '\x00' :
1188
+ (c === 0x61/* a */) ? '\x07' :
1189
+ (c === 0x62/* b */) ? '\x08' :
1190
+ (c === 0x74/* t */) ? '\x09' :
1191
+ (c === 0x09/* Tab */) ? '\x09' :
1192
+ (c === 0x6E/* n */) ? '\x0A' :
1193
+ (c === 0x76/* v */) ? '\x0B' :
1194
+ (c === 0x66/* f */) ? '\x0C' :
1195
+ (c === 0x72/* r */) ? '\x0D' :
1196
+ (c === 0x65/* e */) ? '\x1B' :
1197
+ (c === 0x20/* Space */) ? ' ' :
1198
+ (c === 0x22/* " */) ? '\x22' :
1199
+ (c === 0x2F/* / */) ? '/' :
1200
+ (c === 0x5C/* \ */) ? '\x5C' :
1201
+ (c === 0x4E/* N */) ? '\x85' :
1202
+ (c === 0x5F/* _ */) ? '\xA0' :
1203
+ (c === 0x4C/* L */) ? '\u2028' :
1204
+ (c === 0x50/* P */) ? '\u2029' : '';
1205
+ }
1206
+
1207
+ function charFromCodepoint(c) {
1208
+ if (c <= 0xFFFF) {
1209
+ return String.fromCharCode(c);
1210
+ }
1211
+ // Encode UTF-16 surrogate pair
1212
+ // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF
1213
+ return String.fromCharCode(
1214
+ ((c - 0x010000) >> 10) + 0xD800,
1215
+ ((c - 0x010000) & 0x03FF) + 0xDC00
1216
+ );
1217
+ }
1218
+
1219
+ var simpleEscapeCheck = new Array(256); // integer, for fast access
1220
+ var simpleEscapeMap = new Array(256);
1221
+ for (var i = 0; i < 256; i++) {
1222
+ simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
1223
+ simpleEscapeMap[i] = simpleEscapeSequence(i);
1224
+ }
1225
+
1226
+
1227
+ function State$1(input, options) {
1228
+ this.input = input;
1229
+
1230
+ this.filename = options['filename'] || null;
1231
+ this.schema = options['schema'] || _default;
1232
+ this.onWarning = options['onWarning'] || null;
1233
+ // (Hidden) Remove? makes the loader to expect YAML 1.1 documents
1234
+ // if such documents have no explicit %YAML directive
1235
+ this.legacy = options['legacy'] || false;
1236
+
1237
+ this.json = options['json'] || false;
1238
+ this.listener = options['listener'] || null;
1239
+
1240
+ this.implicitTypes = this.schema.compiledImplicit;
1241
+ this.typeMap = this.schema.compiledTypeMap;
1242
+
1243
+ this.length = input.length;
1244
+ this.position = 0;
1245
+ this.line = 0;
1246
+ this.lineStart = 0;
1247
+ this.lineIndent = 0;
1248
+
1249
+ // position of first leading tab in the current line,
1250
+ // used to make sure there are no tabs in the indentation
1251
+ this.firstTabInLine = -1;
1252
+
1253
+ this.documents = [];
1254
+
1255
+ /*
1256
+ this.version;
1257
+ this.checkLineBreaks;
1258
+ this.tagMap;
1259
+ this.anchorMap;
1260
+ this.tag;
1261
+ this.anchor;
1262
+ this.kind;
1263
+ this.result;*/
1264
+
1265
+ }
1266
+
1267
+
1268
+ function generateError(state, message) {
1269
+ var mark = {
1270
+ name: state.filename,
1271
+ buffer: state.input.slice(0, -1), // omit trailing \0
1272
+ position: state.position,
1273
+ line: state.line,
1274
+ column: state.position - state.lineStart
1275
+ };
1276
+
1277
+ mark.snippet = snippet(mark);
1278
+
1279
+ return new exception(message, mark);
1280
+ }
1281
+
1282
+ function throwError(state, message) {
1283
+ throw generateError(state, message);
1284
+ }
1285
+
1286
+ function throwWarning(state, message) {
1287
+ if (state.onWarning) {
1288
+ state.onWarning.call(null, generateError(state, message));
1289
+ }
1290
+ }
1291
+
1292
+
1293
+ var directiveHandlers = {
1294
+
1295
+ YAML: function handleYamlDirective(state, name, args) {
1296
+
1297
+ var match, major, minor;
1298
+
1299
+ if (state.version !== null) {
1300
+ throwError(state, 'duplication of %YAML directive');
1301
+ }
1302
+
1303
+ if (args.length !== 1) {
1304
+ throwError(state, 'YAML directive accepts exactly one argument');
1305
+ }
1306
+
1307
+ match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
1308
+
1309
+ if (match === null) {
1310
+ throwError(state, 'ill-formed argument of the YAML directive');
1311
+ }
1312
+
1313
+ major = parseInt(match[1], 10);
1314
+ minor = parseInt(match[2], 10);
1315
+
1316
+ if (major !== 1) {
1317
+ throwError(state, 'unacceptable YAML version of the document');
1318
+ }
1319
+
1320
+ state.version = args[0];
1321
+ state.checkLineBreaks = (minor < 2);
1322
+
1323
+ if (minor !== 1 && minor !== 2) {
1324
+ throwWarning(state, 'unsupported YAML version of the document');
1325
+ }
1326
+ },
1327
+
1328
+ TAG: function handleTagDirective(state, name, args) {
1329
+
1330
+ var handle, prefix;
1331
+
1332
+ if (args.length !== 2) {
1333
+ throwError(state, 'TAG directive accepts exactly two arguments');
1334
+ }
1335
+
1336
+ handle = args[0];
1337
+ prefix = args[1];
1338
+
1339
+ if (!PATTERN_TAG_HANDLE.test(handle)) {
1340
+ throwError(state, 'ill-formed tag handle (first argument) of the TAG directive');
1341
+ }
1342
+
1343
+ if (_hasOwnProperty$1.call(state.tagMap, handle)) {
1344
+ throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
1345
+ }
1346
+
1347
+ if (!PATTERN_TAG_URI.test(prefix)) {
1348
+ throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive');
1349
+ }
1350
+
1351
+ try {
1352
+ prefix = decodeURIComponent(prefix);
1353
+ } catch (err) {
1354
+ throwError(state, 'tag prefix is malformed: ' + prefix);
1355
+ }
1356
+
1357
+ state.tagMap[handle] = prefix;
1358
+ }
1359
+ };
1360
+
1361
+
1362
+ function captureSegment(state, start, end, checkJson) {
1363
+ var _position, _length, _character, _result;
1364
+
1365
+ if (start < end) {
1366
+ _result = state.input.slice(start, end);
1367
+
1368
+ if (checkJson) {
1369
+ for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
1370
+ _character = _result.charCodeAt(_position);
1371
+ if (!(_character === 0x09 ||
1372
+ (0x20 <= _character && _character <= 0x10FFFF))) {
1373
+ throwError(state, 'expected valid JSON character');
1374
+ }
1375
+ }
1376
+ } else if (PATTERN_NON_PRINTABLE.test(_result)) {
1377
+ throwError(state, 'the stream contains non-printable characters');
1378
+ }
1379
+
1380
+ state.result += _result;
1381
+ }
1382
+ }
1383
+
1384
+ function mergeMappings(state, destination, source, overridableKeys) {
1385
+ var sourceKeys, key, index, quantity;
1386
+
1387
+ if (!common.isObject(source)) {
1388
+ throwError(state, 'cannot merge mappings; the provided source object is unacceptable');
1389
+ }
1390
+
1391
+ sourceKeys = Object.keys(source);
1392
+
1393
+ for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
1394
+ key = sourceKeys[index];
1395
+
1396
+ if (!_hasOwnProperty$1.call(destination, key)) {
1397
+ destination[key] = source[key];
1398
+ overridableKeys[key] = true;
1399
+ }
1400
+ }
1401
+ }
1402
+
1403
+ function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode,
1404
+ startLine, startLineStart, startPos) {
1405
+
1406
+ var index, quantity;
1407
+
1408
+ // The output is a plain object here, so keys can only be strings.
1409
+ // We need to convert keyNode to a string, but doing so can hang the process
1410
+ // (deeply nested arrays that explode exponentially using aliases).
1411
+ if (Array.isArray(keyNode)) {
1412
+ keyNode = Array.prototype.slice.call(keyNode);
1413
+
1414
+ for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
1415
+ if (Array.isArray(keyNode[index])) {
1416
+ throwError(state, 'nested arrays are not supported inside keys');
1417
+ }
1418
+
1419
+ if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') {
1420
+ keyNode[index] = '[object Object]';
1421
+ }
1422
+ }
1423
+ }
1424
+
1425
+ // Avoid code execution in load() via toString property
1426
+ // (still use its own toString for arrays, timestamps,
1427
+ // and whatever user schema extensions happen to have @@toStringTag)
1428
+ if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') {
1429
+ keyNode = '[object Object]';
1430
+ }
1431
+
1432
+
1433
+ keyNode = String(keyNode);
1434
+
1435
+ if (_result === null) {
1436
+ _result = {};
1437
+ }
1438
+
1439
+ if (keyTag === 'tag:yaml.org,2002:merge') {
1440
+ if (Array.isArray(valueNode)) {
1441
+ for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
1442
+ mergeMappings(state, _result, valueNode[index], overridableKeys);
1443
+ }
1444
+ } else {
1445
+ mergeMappings(state, _result, valueNode, overridableKeys);
1446
+ }
1447
+ } else {
1448
+ if (!state.json &&
1449
+ !_hasOwnProperty$1.call(overridableKeys, keyNode) &&
1450
+ _hasOwnProperty$1.call(_result, keyNode)) {
1451
+ state.line = startLine || state.line;
1452
+ state.lineStart = startLineStart || state.lineStart;
1453
+ state.position = startPos || state.position;
1454
+ throwError(state, 'duplicated mapping key');
1455
+ }
1456
+
1457
+ // used for this specific key only because Object.defineProperty is slow
1458
+ if (keyNode === '__proto__') {
1459
+ Object.defineProperty(_result, keyNode, {
1460
+ configurable: true,
1461
+ enumerable: true,
1462
+ writable: true,
1463
+ value: valueNode
1464
+ });
1465
+ } else {
1466
+ _result[keyNode] = valueNode;
1467
+ }
1468
+ delete overridableKeys[keyNode];
1469
+ }
1470
+
1471
+ return _result;
1472
+ }
1473
+
1474
+ function readLineBreak(state) {
1475
+ var ch;
1476
+
1477
+ ch = state.input.charCodeAt(state.position);
1478
+
1479
+ if (ch === 0x0A/* LF */) {
1480
+ state.position++;
1481
+ } else if (ch === 0x0D/* CR */) {
1482
+ state.position++;
1483
+ if (state.input.charCodeAt(state.position) === 0x0A/* LF */) {
1484
+ state.position++;
1485
+ }
1486
+ } else {
1487
+ throwError(state, 'a line break is expected');
1488
+ }
1489
+
1490
+ state.line += 1;
1491
+ state.lineStart = state.position;
1492
+ state.firstTabInLine = -1;
1493
+ }
1494
+
1495
+ function skipSeparationSpace(state, allowComments, checkIndent) {
1496
+ var lineBreaks = 0,
1497
+ ch = state.input.charCodeAt(state.position);
1498
+
1499
+ while (ch !== 0) {
1500
+ while (is_WHITE_SPACE(ch)) {
1501
+ if (ch === 0x09/* Tab */ && state.firstTabInLine === -1) {
1502
+ state.firstTabInLine = state.position;
1503
+ }
1504
+ ch = state.input.charCodeAt(++state.position);
1505
+ }
1506
+
1507
+ if (allowComments && ch === 0x23/* # */) {
1508
+ do {
1509
+ ch = state.input.charCodeAt(++state.position);
1510
+ } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0);
1511
+ }
1512
+
1513
+ if (is_EOL(ch)) {
1514
+ readLineBreak(state);
1515
+
1516
+ ch = state.input.charCodeAt(state.position);
1517
+ lineBreaks++;
1518
+ state.lineIndent = 0;
1519
+
1520
+ while (ch === 0x20/* Space */) {
1521
+ state.lineIndent++;
1522
+ ch = state.input.charCodeAt(++state.position);
1523
+ }
1524
+ } else {
1525
+ break;
1526
+ }
1527
+ }
1528
+
1529
+ if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
1530
+ throwWarning(state, 'deficient indentation');
1531
+ }
1532
+
1533
+ return lineBreaks;
1534
+ }
1535
+
1536
+ function testDocumentSeparator(state) {
1537
+ var _position = state.position,
1538
+ ch;
1539
+
1540
+ ch = state.input.charCodeAt(_position);
1541
+
1542
+ // Condition state.position === state.lineStart is tested
1543
+ // in parent on each call, for efficiency. No needs to test here again.
1544
+ if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) &&
1545
+ ch === state.input.charCodeAt(_position + 1) &&
1546
+ ch === state.input.charCodeAt(_position + 2)) {
1547
+
1548
+ _position += 3;
1549
+
1550
+ ch = state.input.charCodeAt(_position);
1551
+
1552
+ if (ch === 0 || is_WS_OR_EOL(ch)) {
1553
+ return true;
1554
+ }
1555
+ }
1556
+
1557
+ return false;
1558
+ }
1559
+
1560
+ function writeFoldedLines(state, count) {
1561
+ if (count === 1) {
1562
+ state.result += ' ';
1563
+ } else if (count > 1) {
1564
+ state.result += common.repeat('\n', count - 1);
1565
+ }
1566
+ }
1567
+
1568
+
1569
+ function readPlainScalar(state, nodeIndent, withinFlowCollection) {
1570
+ var preceding,
1571
+ following,
1572
+ captureStart,
1573
+ captureEnd,
1574
+ hasPendingContent,
1575
+ _line,
1576
+ _lineStart,
1577
+ _lineIndent,
1578
+ _kind = state.kind,
1579
+ _result = state.result,
1580
+ ch;
1581
+
1582
+ ch = state.input.charCodeAt(state.position);
1583
+
1584
+ if (is_WS_OR_EOL(ch) ||
1585
+ is_FLOW_INDICATOR(ch) ||
1586
+ ch === 0x23/* # */ ||
1587
+ ch === 0x26/* & */ ||
1588
+ ch === 0x2A/* * */ ||
1589
+ ch === 0x21/* ! */ ||
1590
+ ch === 0x7C/* | */ ||
1591
+ ch === 0x3E/* > */ ||
1592
+ ch === 0x27/* ' */ ||
1593
+ ch === 0x22/* " */ ||
1594
+ ch === 0x25/* % */ ||
1595
+ ch === 0x40/* @ */ ||
1596
+ ch === 0x60/* ` */) {
1597
+ return false;
1598
+ }
1599
+
1600
+ if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) {
1601
+ following = state.input.charCodeAt(state.position + 1);
1602
+
1603
+ if (is_WS_OR_EOL(following) ||
1604
+ withinFlowCollection && is_FLOW_INDICATOR(following)) {
1605
+ return false;
1606
+ }
1607
+ }
1608
+
1609
+ state.kind = 'scalar';
1610
+ state.result = '';
1611
+ captureStart = captureEnd = state.position;
1612
+ hasPendingContent = false;
1613
+
1614
+ while (ch !== 0) {
1615
+ if (ch === 0x3A/* : */) {
1616
+ following = state.input.charCodeAt(state.position + 1);
1617
+
1618
+ if (is_WS_OR_EOL(following) ||
1619
+ withinFlowCollection && is_FLOW_INDICATOR(following)) {
1620
+ break;
1621
+ }
1622
+
1623
+ } else if (ch === 0x23/* # */) {
1624
+ preceding = state.input.charCodeAt(state.position - 1);
1625
+
1626
+ if (is_WS_OR_EOL(preceding)) {
1627
+ break;
1628
+ }
1629
+
1630
+ } else if ((state.position === state.lineStart && testDocumentSeparator(state)) ||
1631
+ withinFlowCollection && is_FLOW_INDICATOR(ch)) {
1632
+ break;
1633
+
1634
+ } else if (is_EOL(ch)) {
1635
+ _line = state.line;
1636
+ _lineStart = state.lineStart;
1637
+ _lineIndent = state.lineIndent;
1638
+ skipSeparationSpace(state, false, -1);
1639
+
1640
+ if (state.lineIndent >= nodeIndent) {
1641
+ hasPendingContent = true;
1642
+ ch = state.input.charCodeAt(state.position);
1643
+ continue;
1644
+ } else {
1645
+ state.position = captureEnd;
1646
+ state.line = _line;
1647
+ state.lineStart = _lineStart;
1648
+ state.lineIndent = _lineIndent;
1649
+ break;
1650
+ }
1651
+ }
1652
+
1653
+ if (hasPendingContent) {
1654
+ captureSegment(state, captureStart, captureEnd, false);
1655
+ writeFoldedLines(state, state.line - _line);
1656
+ captureStart = captureEnd = state.position;
1657
+ hasPendingContent = false;
1658
+ }
1659
+
1660
+ if (!is_WHITE_SPACE(ch)) {
1661
+ captureEnd = state.position + 1;
1662
+ }
1663
+
1664
+ ch = state.input.charCodeAt(++state.position);
1665
+ }
1666
+
1667
+ captureSegment(state, captureStart, captureEnd, false);
1668
+
1669
+ if (state.result) {
1670
+ return true;
1671
+ }
1672
+
1673
+ state.kind = _kind;
1674
+ state.result = _result;
1675
+ return false;
1676
+ }
1677
+
1678
+ function readSingleQuotedScalar(state, nodeIndent) {
1679
+ var ch,
1680
+ captureStart, captureEnd;
1681
+
1682
+ ch = state.input.charCodeAt(state.position);
1683
+
1684
+ if (ch !== 0x27/* ' */) {
1685
+ return false;
1686
+ }
1687
+
1688
+ state.kind = 'scalar';
1689
+ state.result = '';
1690
+ state.position++;
1691
+ captureStart = captureEnd = state.position;
1692
+
1693
+ while ((ch = state.input.charCodeAt(state.position)) !== 0) {
1694
+ if (ch === 0x27/* ' */) {
1695
+ captureSegment(state, captureStart, state.position, true);
1696
+ ch = state.input.charCodeAt(++state.position);
1697
+
1698
+ if (ch === 0x27/* ' */) {
1699
+ captureStart = state.position;
1700
+ state.position++;
1701
+ captureEnd = state.position;
1702
+ } else {
1703
+ return true;
1704
+ }
1705
+
1706
+ } else if (is_EOL(ch)) {
1707
+ captureSegment(state, captureStart, captureEnd, true);
1708
+ writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
1709
+ captureStart = captureEnd = state.position;
1710
+
1711
+ } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
1712
+ throwError(state, 'unexpected end of the document within a single quoted scalar');
1713
+
1714
+ } else {
1715
+ state.position++;
1716
+ captureEnd = state.position;
1717
+ }
1718
+ }
1719
+
1720
+ throwError(state, 'unexpected end of the stream within a single quoted scalar');
1721
+ }
1722
+
1723
+ function readDoubleQuotedScalar(state, nodeIndent) {
1724
+ var captureStart,
1725
+ captureEnd,
1726
+ hexLength,
1727
+ hexResult,
1728
+ tmp,
1729
+ ch;
1730
+
1731
+ ch = state.input.charCodeAt(state.position);
1732
+
1733
+ if (ch !== 0x22/* " */) {
1734
+ return false;
1735
+ }
1736
+
1737
+ state.kind = 'scalar';
1738
+ state.result = '';
1739
+ state.position++;
1740
+ captureStart = captureEnd = state.position;
1741
+
1742
+ while ((ch = state.input.charCodeAt(state.position)) !== 0) {
1743
+ if (ch === 0x22/* " */) {
1744
+ captureSegment(state, captureStart, state.position, true);
1745
+ state.position++;
1746
+ return true;
1747
+
1748
+ } else if (ch === 0x5C/* \ */) {
1749
+ captureSegment(state, captureStart, state.position, true);
1750
+ ch = state.input.charCodeAt(++state.position);
1751
+
1752
+ if (is_EOL(ch)) {
1753
+ skipSeparationSpace(state, false, nodeIndent);
1754
+
1755
+ // TODO: rework to inline fn with no type cast?
1756
+ } else if (ch < 256 && simpleEscapeCheck[ch]) {
1757
+ state.result += simpleEscapeMap[ch];
1758
+ state.position++;
1759
+
1760
+ } else if ((tmp = escapedHexLen(ch)) > 0) {
1761
+ hexLength = tmp;
1762
+ hexResult = 0;
1763
+
1764
+ for (; hexLength > 0; hexLength--) {
1765
+ ch = state.input.charCodeAt(++state.position);
1766
+
1767
+ if ((tmp = fromHexCode(ch)) >= 0) {
1768
+ hexResult = (hexResult << 4) + tmp;
1769
+
1770
+ } else {
1771
+ throwError(state, 'expected hexadecimal character');
1772
+ }
1773
+ }
1774
+
1775
+ state.result += charFromCodepoint(hexResult);
1776
+
1777
+ state.position++;
1778
+
1779
+ } else {
1780
+ throwError(state, 'unknown escape sequence');
1781
+ }
1782
+
1783
+ captureStart = captureEnd = state.position;
1784
+
1785
+ } else if (is_EOL(ch)) {
1786
+ captureSegment(state, captureStart, captureEnd, true);
1787
+ writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
1788
+ captureStart = captureEnd = state.position;
1789
+
1790
+ } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
1791
+ throwError(state, 'unexpected end of the document within a double quoted scalar');
1792
+
1793
+ } else {
1794
+ state.position++;
1795
+ captureEnd = state.position;
1796
+ }
1797
+ }
1798
+
1799
+ throwError(state, 'unexpected end of the stream within a double quoted scalar');
1800
+ }
1801
+
1802
+ function readFlowCollection(state, nodeIndent) {
1803
+ var readNext = true,
1804
+ _line,
1805
+ _lineStart,
1806
+ _pos,
1807
+ _tag = state.tag,
1808
+ _result,
1809
+ _anchor = state.anchor,
1810
+ following,
1811
+ terminator,
1812
+ isPair,
1813
+ isExplicitPair,
1814
+ isMapping,
1815
+ overridableKeys = Object.create(null),
1816
+ keyNode,
1817
+ keyTag,
1818
+ valueNode,
1819
+ ch;
1820
+
1821
+ ch = state.input.charCodeAt(state.position);
1822
+
1823
+ if (ch === 0x5B/* [ */) {
1824
+ terminator = 0x5D;/* ] */
1825
+ isMapping = false;
1826
+ _result = [];
1827
+ } else if (ch === 0x7B/* { */) {
1828
+ terminator = 0x7D;/* } */
1829
+ isMapping = true;
1830
+ _result = {};
1831
+ } else {
1832
+ return false;
1833
+ }
1834
+
1835
+ if (state.anchor !== null) {
1836
+ state.anchorMap[state.anchor] = _result;
1837
+ }
1838
+
1839
+ ch = state.input.charCodeAt(++state.position);
1840
+
1841
+ while (ch !== 0) {
1842
+ skipSeparationSpace(state, true, nodeIndent);
1843
+
1844
+ ch = state.input.charCodeAt(state.position);
1845
+
1846
+ if (ch === terminator) {
1847
+ state.position++;
1848
+ state.tag = _tag;
1849
+ state.anchor = _anchor;
1850
+ state.kind = isMapping ? 'mapping' : 'sequence';
1851
+ state.result = _result;
1852
+ return true;
1853
+ } else if (!readNext) {
1854
+ throwError(state, 'missed comma between flow collection entries');
1855
+ } else if (ch === 0x2C/* , */) {
1856
+ // "flow collection entries can never be completely empty", as per YAML 1.2, section 7.4
1857
+ throwError(state, "expected the node content, but found ','");
1858
+ }
1859
+
1860
+ keyTag = keyNode = valueNode = null;
1861
+ isPair = isExplicitPair = false;
1862
+
1863
+ if (ch === 0x3F/* ? */) {
1864
+ following = state.input.charCodeAt(state.position + 1);
1865
+
1866
+ if (is_WS_OR_EOL(following)) {
1867
+ isPair = isExplicitPair = true;
1868
+ state.position++;
1869
+ skipSeparationSpace(state, true, nodeIndent);
1870
+ }
1871
+ }
1872
+
1873
+ _line = state.line; // Save the current line.
1874
+ _lineStart = state.lineStart;
1875
+ _pos = state.position;
1876
+ composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
1877
+ keyTag = state.tag;
1878
+ keyNode = state.result;
1879
+ skipSeparationSpace(state, true, nodeIndent);
1880
+
1881
+ ch = state.input.charCodeAt(state.position);
1882
+
1883
+ if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) {
1884
+ isPair = true;
1885
+ ch = state.input.charCodeAt(++state.position);
1886
+ skipSeparationSpace(state, true, nodeIndent);
1887
+ composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
1888
+ valueNode = state.result;
1889
+ }
1890
+
1891
+ if (isMapping) {
1892
+ storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos);
1893
+ } else if (isPair) {
1894
+ _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos));
1895
+ } else {
1896
+ _result.push(keyNode);
1897
+ }
1898
+
1899
+ skipSeparationSpace(state, true, nodeIndent);
1900
+
1901
+ ch = state.input.charCodeAt(state.position);
1902
+
1903
+ if (ch === 0x2C/* , */) {
1904
+ readNext = true;
1905
+ ch = state.input.charCodeAt(++state.position);
1906
+ } else {
1907
+ readNext = false;
1908
+ }
1909
+ }
1910
+
1911
+ throwError(state, 'unexpected end of the stream within a flow collection');
1912
+ }
1913
+
1914
+ function readBlockScalar(state, nodeIndent) {
1915
+ var captureStart,
1916
+ folding,
1917
+ chomping = CHOMPING_CLIP,
1918
+ didReadContent = false,
1919
+ detectedIndent = false,
1920
+ textIndent = nodeIndent,
1921
+ emptyLines = 0,
1922
+ atMoreIndented = false,
1923
+ tmp,
1924
+ ch;
1925
+
1926
+ ch = state.input.charCodeAt(state.position);
1927
+
1928
+ if (ch === 0x7C/* | */) {
1929
+ folding = false;
1930
+ } else if (ch === 0x3E/* > */) {
1931
+ folding = true;
1932
+ } else {
1933
+ return false;
1934
+ }
1935
+
1936
+ state.kind = 'scalar';
1937
+ state.result = '';
1938
+
1939
+ while (ch !== 0) {
1940
+ ch = state.input.charCodeAt(++state.position);
1941
+
1942
+ if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {
1943
+ if (CHOMPING_CLIP === chomping) {
1944
+ chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP;
1945
+ } else {
1946
+ throwError(state, 'repeat of a chomping mode identifier');
1947
+ }
1948
+
1949
+ } else if ((tmp = fromDecimalCode(ch)) >= 0) {
1950
+ if (tmp === 0) {
1951
+ throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');
1952
+ } else if (!detectedIndent) {
1953
+ textIndent = nodeIndent + tmp - 1;
1954
+ detectedIndent = true;
1955
+ } else {
1956
+ throwError(state, 'repeat of an indentation width identifier');
1957
+ }
1958
+
1959
+ } else {
1960
+ break;
1961
+ }
1962
+ }
1963
+
1964
+ if (is_WHITE_SPACE(ch)) {
1965
+ do { ch = state.input.charCodeAt(++state.position); }
1966
+ while (is_WHITE_SPACE(ch));
1967
+
1968
+ if (ch === 0x23/* # */) {
1969
+ do { ch = state.input.charCodeAt(++state.position); }
1970
+ while (!is_EOL(ch) && (ch !== 0));
1971
+ }
1972
+ }
1973
+
1974
+ while (ch !== 0) {
1975
+ readLineBreak(state);
1976
+ state.lineIndent = 0;
1977
+
1978
+ ch = state.input.charCodeAt(state.position);
1979
+
1980
+ while ((!detectedIndent || state.lineIndent < textIndent) &&
1981
+ (ch === 0x20/* Space */)) {
1982
+ state.lineIndent++;
1983
+ ch = state.input.charCodeAt(++state.position);
1984
+ }
1985
+
1986
+ if (!detectedIndent && state.lineIndent > textIndent) {
1987
+ textIndent = state.lineIndent;
1988
+ }
1989
+
1990
+ if (is_EOL(ch)) {
1991
+ emptyLines++;
1992
+ continue;
1993
+ }
1994
+
1995
+ // End of the scalar.
1996
+ if (state.lineIndent < textIndent) {
1997
+
1998
+ // Perform the chomping.
1999
+ if (chomping === CHOMPING_KEEP) {
2000
+ state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
2001
+ } else if (chomping === CHOMPING_CLIP) {
2002
+ if (didReadContent) { // i.e. only if the scalar is not empty.
2003
+ state.result += '\n';
2004
+ }
2005
+ }
2006
+
2007
+ // Break this `while` cycle and go to the funciton's epilogue.
2008
+ break;
2009
+ }
2010
+
2011
+ // Folded style: use fancy rules to handle line breaks.
2012
+ if (folding) {
2013
+
2014
+ // Lines starting with white space characters (more-indented lines) are not folded.
2015
+ if (is_WHITE_SPACE(ch)) {
2016
+ atMoreIndented = true;
2017
+ // except for the first content line (cf. Example 8.1)
2018
+ state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
2019
+
2020
+ // End of more-indented block.
2021
+ } else if (atMoreIndented) {
2022
+ atMoreIndented = false;
2023
+ state.result += common.repeat('\n', emptyLines + 1);
2024
+
2025
+ // Just one line break - perceive as the same line.
2026
+ } else if (emptyLines === 0) {
2027
+ if (didReadContent) { // i.e. only if we have already read some scalar content.
2028
+ state.result += ' ';
2029
+ }
2030
+
2031
+ // Several line breaks - perceive as different lines.
2032
+ } else {
2033
+ state.result += common.repeat('\n', emptyLines);
2034
+ }
2035
+
2036
+ // Literal style: just add exact number of line breaks between content lines.
2037
+ } else {
2038
+ // Keep all line breaks except the header line break.
2039
+ state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
2040
+ }
2041
+
2042
+ didReadContent = true;
2043
+ detectedIndent = true;
2044
+ emptyLines = 0;
2045
+ captureStart = state.position;
2046
+
2047
+ while (!is_EOL(ch) && (ch !== 0)) {
2048
+ ch = state.input.charCodeAt(++state.position);
2049
+ }
2050
+
2051
+ captureSegment(state, captureStart, state.position, false);
2052
+ }
2053
+
2054
+ return true;
2055
+ }
2056
+
2057
+ function readBlockSequence(state, nodeIndent) {
2058
+ var _line,
2059
+ _tag = state.tag,
2060
+ _anchor = state.anchor,
2061
+ _result = [],
2062
+ following,
2063
+ detected = false,
2064
+ ch;
2065
+
2066
+ // there is a leading tab before this token, so it can't be a block sequence/mapping;
2067
+ // it can still be flow sequence/mapping or a scalar
2068
+ if (state.firstTabInLine !== -1) return false;
2069
+
2070
+ if (state.anchor !== null) {
2071
+ state.anchorMap[state.anchor] = _result;
2072
+ }
2073
+
2074
+ ch = state.input.charCodeAt(state.position);
2075
+
2076
+ while (ch !== 0) {
2077
+ if (state.firstTabInLine !== -1) {
2078
+ state.position = state.firstTabInLine;
2079
+ throwError(state, 'tab characters must not be used in indentation');
2080
+ }
2081
+
2082
+ if (ch !== 0x2D/* - */) {
2083
+ break;
2084
+ }
2085
+
2086
+ following = state.input.charCodeAt(state.position + 1);
2087
+
2088
+ if (!is_WS_OR_EOL(following)) {
2089
+ break;
2090
+ }
2091
+
2092
+ detected = true;
2093
+ state.position++;
2094
+
2095
+ if (skipSeparationSpace(state, true, -1)) {
2096
+ if (state.lineIndent <= nodeIndent) {
2097
+ _result.push(null);
2098
+ ch = state.input.charCodeAt(state.position);
2099
+ continue;
2100
+ }
2101
+ }
2102
+
2103
+ _line = state.line;
2104
+ composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
2105
+ _result.push(state.result);
2106
+ skipSeparationSpace(state, true, -1);
2107
+
2108
+ ch = state.input.charCodeAt(state.position);
2109
+
2110
+ if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
2111
+ throwError(state, 'bad indentation of a sequence entry');
2112
+ } else if (state.lineIndent < nodeIndent) {
2113
+ break;
2114
+ }
2115
+ }
2116
+
2117
+ if (detected) {
2118
+ state.tag = _tag;
2119
+ state.anchor = _anchor;
2120
+ state.kind = 'sequence';
2121
+ state.result = _result;
2122
+ return true;
2123
+ }
2124
+ return false;
2125
+ }
2126
+
2127
+ function readBlockMapping(state, nodeIndent, flowIndent) {
2128
+ var following,
2129
+ allowCompact,
2130
+ _line,
2131
+ _keyLine,
2132
+ _keyLineStart,
2133
+ _keyPos,
2134
+ _tag = state.tag,
2135
+ _anchor = state.anchor,
2136
+ _result = {},
2137
+ overridableKeys = Object.create(null),
2138
+ keyTag = null,
2139
+ keyNode = null,
2140
+ valueNode = null,
2141
+ atExplicitKey = false,
2142
+ detected = false,
2143
+ ch;
2144
+
2145
+ // there is a leading tab before this token, so it can't be a block sequence/mapping;
2146
+ // it can still be flow sequence/mapping or a scalar
2147
+ if (state.firstTabInLine !== -1) return false;
2148
+
2149
+ if (state.anchor !== null) {
2150
+ state.anchorMap[state.anchor] = _result;
2151
+ }
2152
+
2153
+ ch = state.input.charCodeAt(state.position);
2154
+
2155
+ while (ch !== 0) {
2156
+ if (!atExplicitKey && state.firstTabInLine !== -1) {
2157
+ state.position = state.firstTabInLine;
2158
+ throwError(state, 'tab characters must not be used in indentation');
2159
+ }
2160
+
2161
+ following = state.input.charCodeAt(state.position + 1);
2162
+ _line = state.line; // Save the current line.
2163
+
2164
+ //
2165
+ // Explicit notation case. There are two separate blocks:
2166
+ // first for the key (denoted by "?") and second for the value (denoted by ":")
2167
+ //
2168
+ if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) {
2169
+
2170
+ if (ch === 0x3F/* ? */) {
2171
+ if (atExplicitKey) {
2172
+ storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
2173
+ keyTag = keyNode = valueNode = null;
2174
+ }
2175
+
2176
+ detected = true;
2177
+ atExplicitKey = true;
2178
+ allowCompact = true;
2179
+
2180
+ } else if (atExplicitKey) {
2181
+ // i.e. 0x3A/* : */ === character after the explicit key.
2182
+ atExplicitKey = false;
2183
+ allowCompact = true;
2184
+
2185
+ } else {
2186
+ throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line');
2187
+ }
2188
+
2189
+ state.position += 1;
2190
+ ch = following;
2191
+
2192
+ //
2193
+ // Implicit notation case. Flow-style node as the key first, then ":", and the value.
2194
+ //
2195
+ } else {
2196
+ _keyLine = state.line;
2197
+ _keyLineStart = state.lineStart;
2198
+ _keyPos = state.position;
2199
+
2200
+ if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
2201
+ // Neither implicit nor explicit notation.
2202
+ // Reading is done. Go to the epilogue.
2203
+ break;
2204
+ }
2205
+
2206
+ if (state.line === _line) {
2207
+ ch = state.input.charCodeAt(state.position);
2208
+
2209
+ while (is_WHITE_SPACE(ch)) {
2210
+ ch = state.input.charCodeAt(++state.position);
2211
+ }
2212
+
2213
+ if (ch === 0x3A/* : */) {
2214
+ ch = state.input.charCodeAt(++state.position);
2215
+
2216
+ if (!is_WS_OR_EOL(ch)) {
2217
+ throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping');
2218
+ }
2219
+
2220
+ if (atExplicitKey) {
2221
+ storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
2222
+ keyTag = keyNode = valueNode = null;
2223
+ }
2224
+
2225
+ detected = true;
2226
+ atExplicitKey = false;
2227
+ allowCompact = false;
2228
+ keyTag = state.tag;
2229
+ keyNode = state.result;
2230
+
2231
+ } else if (detected) {
2232
+ throwError(state, 'can not read an implicit mapping pair; a colon is missed');
2233
+
2234
+ } else {
2235
+ state.tag = _tag;
2236
+ state.anchor = _anchor;
2237
+ return true; // Keep the result of `composeNode`.
2238
+ }
2239
+
2240
+ } else if (detected) {
2241
+ throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key');
2242
+
2243
+ } else {
2244
+ state.tag = _tag;
2245
+ state.anchor = _anchor;
2246
+ return true; // Keep the result of `composeNode`.
2247
+ }
2248
+ }
2249
+
2250
+ //
2251
+ // Common reading code for both explicit and implicit notations.
2252
+ //
2253
+ if (state.line === _line || state.lineIndent > nodeIndent) {
2254
+ if (atExplicitKey) {
2255
+ _keyLine = state.line;
2256
+ _keyLineStart = state.lineStart;
2257
+ _keyPos = state.position;
2258
+ }
2259
+
2260
+ if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
2261
+ if (atExplicitKey) {
2262
+ keyNode = state.result;
2263
+ } else {
2264
+ valueNode = state.result;
2265
+ }
2266
+ }
2267
+
2268
+ if (!atExplicitKey) {
2269
+ storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos);
2270
+ keyTag = keyNode = valueNode = null;
2271
+ }
2272
+
2273
+ skipSeparationSpace(state, true, -1);
2274
+ ch = state.input.charCodeAt(state.position);
2275
+ }
2276
+
2277
+ if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
2278
+ throwError(state, 'bad indentation of a mapping entry');
2279
+ } else if (state.lineIndent < nodeIndent) {
2280
+ break;
2281
+ }
2282
+ }
2283
+
2284
+ //
2285
+ // Epilogue.
2286
+ //
2287
+
2288
+ // Special case: last mapping's node contains only the key in explicit notation.
2289
+ if (atExplicitKey) {
2290
+ storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
2291
+ }
2292
+
2293
+ // Expose the resulting mapping.
2294
+ if (detected) {
2295
+ state.tag = _tag;
2296
+ state.anchor = _anchor;
2297
+ state.kind = 'mapping';
2298
+ state.result = _result;
2299
+ }
2300
+
2301
+ return detected;
2302
+ }
2303
+
2304
+ function readTagProperty(state) {
2305
+ var _position,
2306
+ isVerbatim = false,
2307
+ isNamed = false,
2308
+ tagHandle,
2309
+ tagName,
2310
+ ch;
2311
+
2312
+ ch = state.input.charCodeAt(state.position);
2313
+
2314
+ if (ch !== 0x21/* ! */) return false;
2315
+
2316
+ if (state.tag !== null) {
2317
+ throwError(state, 'duplication of a tag property');
2318
+ }
2319
+
2320
+ ch = state.input.charCodeAt(++state.position);
2321
+
2322
+ if (ch === 0x3C/* < */) {
2323
+ isVerbatim = true;
2324
+ ch = state.input.charCodeAt(++state.position);
2325
+
2326
+ } else if (ch === 0x21/* ! */) {
2327
+ isNamed = true;
2328
+ tagHandle = '!!';
2329
+ ch = state.input.charCodeAt(++state.position);
2330
+
2331
+ } else {
2332
+ tagHandle = '!';
2333
+ }
2334
+
2335
+ _position = state.position;
2336
+
2337
+ if (isVerbatim) {
2338
+ do { ch = state.input.charCodeAt(++state.position); }
2339
+ while (ch !== 0 && ch !== 0x3E/* > */);
2340
+
2341
+ if (state.position < state.length) {
2342
+ tagName = state.input.slice(_position, state.position);
2343
+ ch = state.input.charCodeAt(++state.position);
2344
+ } else {
2345
+ throwError(state, 'unexpected end of the stream within a verbatim tag');
2346
+ }
2347
+ } else {
2348
+ while (ch !== 0 && !is_WS_OR_EOL(ch)) {
2349
+
2350
+ if (ch === 0x21/* ! */) {
2351
+ if (!isNamed) {
2352
+ tagHandle = state.input.slice(_position - 1, state.position + 1);
2353
+
2354
+ if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
2355
+ throwError(state, 'named tag handle cannot contain such characters');
2356
+ }
2357
+
2358
+ isNamed = true;
2359
+ _position = state.position + 1;
2360
+ } else {
2361
+ throwError(state, 'tag suffix cannot contain exclamation marks');
2362
+ }
2363
+ }
2364
+
2365
+ ch = state.input.charCodeAt(++state.position);
2366
+ }
2367
+
2368
+ tagName = state.input.slice(_position, state.position);
2369
+
2370
+ if (PATTERN_FLOW_INDICATORS.test(tagName)) {
2371
+ throwError(state, 'tag suffix cannot contain flow indicator characters');
2372
+ }
2373
+ }
2374
+
2375
+ if (tagName && !PATTERN_TAG_URI.test(tagName)) {
2376
+ throwError(state, 'tag name cannot contain such characters: ' + tagName);
2377
+ }
2378
+
2379
+ try {
2380
+ tagName = decodeURIComponent(tagName);
2381
+ } catch (err) {
2382
+ throwError(state, 'tag name is malformed: ' + tagName);
2383
+ }
2384
+
2385
+ if (isVerbatim) {
2386
+ state.tag = tagName;
2387
+
2388
+ } else if (_hasOwnProperty$1.call(state.tagMap, tagHandle)) {
2389
+ state.tag = state.tagMap[tagHandle] + tagName;
2390
+
2391
+ } else if (tagHandle === '!') {
2392
+ state.tag = '!' + tagName;
2393
+
2394
+ } else if (tagHandle === '!!') {
2395
+ state.tag = 'tag:yaml.org,2002:' + tagName;
2396
+
2397
+ } else {
2398
+ throwError(state, 'undeclared tag handle "' + tagHandle + '"');
2399
+ }
2400
+
2401
+ return true;
2402
+ }
2403
+
2404
+ function readAnchorProperty(state) {
2405
+ var _position,
2406
+ ch;
2407
+
2408
+ ch = state.input.charCodeAt(state.position);
2409
+
2410
+ if (ch !== 0x26/* & */) return false;
2411
+
2412
+ if (state.anchor !== null) {
2413
+ throwError(state, 'duplication of an anchor property');
2414
+ }
2415
+
2416
+ ch = state.input.charCodeAt(++state.position);
2417
+ _position = state.position;
2418
+
2419
+ while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
2420
+ ch = state.input.charCodeAt(++state.position);
2421
+ }
2422
+
2423
+ if (state.position === _position) {
2424
+ throwError(state, 'name of an anchor node must contain at least one character');
2425
+ }
2426
+
2427
+ state.anchor = state.input.slice(_position, state.position);
2428
+ return true;
2429
+ }
2430
+
2431
+ function readAlias(state) {
2432
+ var _position, alias,
2433
+ ch;
2434
+
2435
+ ch = state.input.charCodeAt(state.position);
2436
+
2437
+ if (ch !== 0x2A/* * */) return false;
2438
+
2439
+ ch = state.input.charCodeAt(++state.position);
2440
+ _position = state.position;
2441
+
2442
+ while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
2443
+ ch = state.input.charCodeAt(++state.position);
2444
+ }
2445
+
2446
+ if (state.position === _position) {
2447
+ throwError(state, 'name of an alias node must contain at least one character');
2448
+ }
2449
+
2450
+ alias = state.input.slice(_position, state.position);
2451
+
2452
+ if (!_hasOwnProperty$1.call(state.anchorMap, alias)) {
2453
+ throwError(state, 'unidentified alias "' + alias + '"');
2454
+ }
2455
+
2456
+ state.result = state.anchorMap[alias];
2457
+ skipSeparationSpace(state, true, -1);
2458
+ return true;
2459
+ }
2460
+
2461
+ function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
2462
+ var allowBlockStyles,
2463
+ allowBlockScalars,
2464
+ allowBlockCollections,
2465
+ indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this<parent
2466
+ atNewLine = false,
2467
+ hasContent = false,
2468
+ typeIndex,
2469
+ typeQuantity,
2470
+ typeList,
2471
+ type,
2472
+ flowIndent,
2473
+ blockIndent;
2474
+
2475
+ if (state.listener !== null) {
2476
+ state.listener('open', state);
2477
+ }
2478
+
2479
+ state.tag = null;
2480
+ state.anchor = null;
2481
+ state.kind = null;
2482
+ state.result = null;
2483
+
2484
+ allowBlockStyles = allowBlockScalars = allowBlockCollections =
2485
+ CONTEXT_BLOCK_OUT === nodeContext ||
2486
+ CONTEXT_BLOCK_IN === nodeContext;
2487
+
2488
+ if (allowToSeek) {
2489
+ if (skipSeparationSpace(state, true, -1)) {
2490
+ atNewLine = true;
2491
+
2492
+ if (state.lineIndent > parentIndent) {
2493
+ indentStatus = 1;
2494
+ } else if (state.lineIndent === parentIndent) {
2495
+ indentStatus = 0;
2496
+ } else if (state.lineIndent < parentIndent) {
2497
+ indentStatus = -1;
2498
+ }
2499
+ }
2500
+ }
2501
+
2502
+ if (indentStatus === 1) {
2503
+ while (readTagProperty(state) || readAnchorProperty(state)) {
2504
+ if (skipSeparationSpace(state, true, -1)) {
2505
+ atNewLine = true;
2506
+ allowBlockCollections = allowBlockStyles;
2507
+
2508
+ if (state.lineIndent > parentIndent) {
2509
+ indentStatus = 1;
2510
+ } else if (state.lineIndent === parentIndent) {
2511
+ indentStatus = 0;
2512
+ } else if (state.lineIndent < parentIndent) {
2513
+ indentStatus = -1;
2514
+ }
2515
+ } else {
2516
+ allowBlockCollections = false;
2517
+ }
2518
+ }
2519
+ }
2520
+
2521
+ if (allowBlockCollections) {
2522
+ allowBlockCollections = atNewLine || allowCompact;
2523
+ }
2524
+
2525
+ if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
2526
+ if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
2527
+ flowIndent = parentIndent;
2528
+ } else {
2529
+ flowIndent = parentIndent + 1;
2530
+ }
2531
+
2532
+ blockIndent = state.position - state.lineStart;
2533
+
2534
+ if (indentStatus === 1) {
2535
+ if (allowBlockCollections &&
2536
+ (readBlockSequence(state, blockIndent) ||
2537
+ readBlockMapping(state, blockIndent, flowIndent)) ||
2538
+ readFlowCollection(state, flowIndent)) {
2539
+ hasContent = true;
2540
+ } else {
2541
+ if ((allowBlockScalars && readBlockScalar(state, flowIndent)) ||
2542
+ readSingleQuotedScalar(state, flowIndent) ||
2543
+ readDoubleQuotedScalar(state, flowIndent)) {
2544
+ hasContent = true;
2545
+
2546
+ } else if (readAlias(state)) {
2547
+ hasContent = true;
2548
+
2549
+ if (state.tag !== null || state.anchor !== null) {
2550
+ throwError(state, 'alias node should not have any properties');
2551
+ }
2552
+
2553
+ } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
2554
+ hasContent = true;
2555
+
2556
+ if (state.tag === null) {
2557
+ state.tag = '?';
2558
+ }
2559
+ }
2560
+
2561
+ if (state.anchor !== null) {
2562
+ state.anchorMap[state.anchor] = state.result;
2563
+ }
2564
+ }
2565
+ } else if (indentStatus === 0) {
2566
+ // Special case: block sequences are allowed to have same indentation level as the parent.
2567
+ // http://www.yaml.org/spec/1.2/spec.html#id2799784
2568
+ hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
2569
+ }
2570
+ }
2571
+
2572
+ if (state.tag === null) {
2573
+ if (state.anchor !== null) {
2574
+ state.anchorMap[state.anchor] = state.result;
2575
+ }
2576
+
2577
+ } else if (state.tag === '?') {
2578
+ // Implicit resolving is not allowed for non-scalar types, and '?'
2579
+ // non-specific tag is only automatically assigned to plain scalars.
2580
+ //
2581
+ // We only need to check kind conformity in case user explicitly assigns '?'
2582
+ // tag, for example like this: "!<?> [0]"
2583
+ //
2584
+ if (state.result !== null && state.kind !== 'scalar') {
2585
+ throwError(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
2586
+ }
2587
+
2588
+ for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
2589
+ type = state.implicitTypes[typeIndex];
2590
+
2591
+ if (type.resolve(state.result)) { // `state.result` updated in resolver if matched
2592
+ state.result = type.construct(state.result);
2593
+ state.tag = type.tag;
2594
+ if (state.anchor !== null) {
2595
+ state.anchorMap[state.anchor] = state.result;
2596
+ }
2597
+ break;
2598
+ }
2599
+ }
2600
+ } else if (state.tag !== '!') {
2601
+ if (_hasOwnProperty$1.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
2602
+ type = state.typeMap[state.kind || 'fallback'][state.tag];
2603
+ } else {
2604
+ // looking for multi type
2605
+ type = null;
2606
+ typeList = state.typeMap.multi[state.kind || 'fallback'];
2607
+
2608
+ for (typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) {
2609
+ if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
2610
+ type = typeList[typeIndex];
2611
+ break;
2612
+ }
2613
+ }
2614
+ }
2615
+
2616
+ if (!type) {
2617
+ throwError(state, 'unknown tag !<' + state.tag + '>');
2618
+ }
2619
+
2620
+ if (state.result !== null && type.kind !== state.kind) {
2621
+ throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
2622
+ }
2623
+
2624
+ if (!type.resolve(state.result, state.tag)) { // `state.result` updated in resolver if matched
2625
+ throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');
2626
+ } else {
2627
+ state.result = type.construct(state.result, state.tag);
2628
+ if (state.anchor !== null) {
2629
+ state.anchorMap[state.anchor] = state.result;
2630
+ }
2631
+ }
2632
+ }
2633
+
2634
+ if (state.listener !== null) {
2635
+ state.listener('close', state);
2636
+ }
2637
+ return state.tag !== null || state.anchor !== null || hasContent;
2638
+ }
2639
+
2640
+ function readDocument(state) {
2641
+ var documentStart = state.position,
2642
+ _position,
2643
+ directiveName,
2644
+ directiveArgs,
2645
+ hasDirectives = false,
2646
+ ch;
2647
+
2648
+ state.version = null;
2649
+ state.checkLineBreaks = state.legacy;
2650
+ state.tagMap = Object.create(null);
2651
+ state.anchorMap = Object.create(null);
2652
+
2653
+ while ((ch = state.input.charCodeAt(state.position)) !== 0) {
2654
+ skipSeparationSpace(state, true, -1);
2655
+
2656
+ ch = state.input.charCodeAt(state.position);
2657
+
2658
+ if (state.lineIndent > 0 || ch !== 0x25/* % */) {
2659
+ break;
2660
+ }
2661
+
2662
+ hasDirectives = true;
2663
+ ch = state.input.charCodeAt(++state.position);
2664
+ _position = state.position;
2665
+
2666
+ while (ch !== 0 && !is_WS_OR_EOL(ch)) {
2667
+ ch = state.input.charCodeAt(++state.position);
2668
+ }
2669
+
2670
+ directiveName = state.input.slice(_position, state.position);
2671
+ directiveArgs = [];
2672
+
2673
+ if (directiveName.length < 1) {
2674
+ throwError(state, 'directive name must not be less than one character in length');
2675
+ }
2676
+
2677
+ while (ch !== 0) {
2678
+ while (is_WHITE_SPACE(ch)) {
2679
+ ch = state.input.charCodeAt(++state.position);
2680
+ }
2681
+
2682
+ if (ch === 0x23/* # */) {
2683
+ do { ch = state.input.charCodeAt(++state.position); }
2684
+ while (ch !== 0 && !is_EOL(ch));
2685
+ break;
2686
+ }
2687
+
2688
+ if (is_EOL(ch)) break;
2689
+
2690
+ _position = state.position;
2691
+
2692
+ while (ch !== 0 && !is_WS_OR_EOL(ch)) {
2693
+ ch = state.input.charCodeAt(++state.position);
2694
+ }
2695
+
2696
+ directiveArgs.push(state.input.slice(_position, state.position));
2697
+ }
2698
+
2699
+ if (ch !== 0) readLineBreak(state);
2700
+
2701
+ if (_hasOwnProperty$1.call(directiveHandlers, directiveName)) {
2702
+ directiveHandlers[directiveName](state, directiveName, directiveArgs);
2703
+ } else {
2704
+ throwWarning(state, 'unknown document directive "' + directiveName + '"');
2705
+ }
2706
+ }
2707
+
2708
+ skipSeparationSpace(state, true, -1);
2709
+
2710
+ if (state.lineIndent === 0 &&
2711
+ state.input.charCodeAt(state.position) === 0x2D/* - */ &&
2712
+ state.input.charCodeAt(state.position + 1) === 0x2D/* - */ &&
2713
+ state.input.charCodeAt(state.position + 2) === 0x2D/* - */) {
2714
+ state.position += 3;
2715
+ skipSeparationSpace(state, true, -1);
2716
+
2717
+ } else if (hasDirectives) {
2718
+ throwError(state, 'directives end mark is expected');
2719
+ }
2720
+
2721
+ composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
2722
+ skipSeparationSpace(state, true, -1);
2723
+
2724
+ if (state.checkLineBreaks &&
2725
+ PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
2726
+ throwWarning(state, 'non-ASCII line breaks are interpreted as content');
2727
+ }
2728
+
2729
+ state.documents.push(state.result);
2730
+
2731
+ if (state.position === state.lineStart && testDocumentSeparator(state)) {
2732
+
2733
+ if (state.input.charCodeAt(state.position) === 0x2E/* . */) {
2734
+ state.position += 3;
2735
+ skipSeparationSpace(state, true, -1);
2736
+ }
2737
+ return;
2738
+ }
2739
+
2740
+ if (state.position < (state.length - 1)) {
2741
+ throwError(state, 'end of the stream or a document separator is expected');
2742
+ } else {
2743
+ return;
2744
+ }
2745
+ }
2746
+
2747
+
2748
+ function loadDocuments(input, options) {
2749
+ input = String(input);
2750
+ options = options || {};
2751
+
2752
+ if (input.length !== 0) {
2753
+
2754
+ // Add tailing `\n` if not exists
2755
+ if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ &&
2756
+ input.charCodeAt(input.length - 1) !== 0x0D/* CR */) {
2757
+ input += '\n';
2758
+ }
2759
+
2760
+ // Strip BOM
2761
+ if (input.charCodeAt(0) === 0xFEFF) {
2762
+ input = input.slice(1);
2763
+ }
2764
+ }
2765
+
2766
+ var state = new State$1(input, options);
2767
+
2768
+ var nullpos = input.indexOf('\0');
2769
+
2770
+ if (nullpos !== -1) {
2771
+ state.position = nullpos;
2772
+ throwError(state, 'null byte is not allowed in input');
2773
+ }
2774
+
2775
+ // Use 0 as string terminator. That significantly simplifies bounds check.
2776
+ state.input += '\0';
2777
+
2778
+ while (state.input.charCodeAt(state.position) === 0x20/* Space */) {
2779
+ state.lineIndent += 1;
2780
+ state.position += 1;
2781
+ }
2782
+
2783
+ while (state.position < (state.length - 1)) {
2784
+ readDocument(state);
2785
+ }
2786
+
2787
+ return state.documents;
2788
+ }
2789
+
2790
+
2791
+ function loadAll$1(input, iterator, options) {
2792
+ if (iterator !== null && typeof iterator === 'object' && typeof options === 'undefined') {
2793
+ options = iterator;
2794
+ iterator = null;
2795
+ }
2796
+
2797
+ var documents = loadDocuments(input, options);
2798
+
2799
+ if (typeof iterator !== 'function') {
2800
+ return documents;
2801
+ }
2802
+
2803
+ for (var index = 0, length = documents.length; index < length; index += 1) {
2804
+ iterator(documents[index]);
2805
+ }
2806
+ }
2807
+
2808
+
2809
+ function load$1(input, options) {
2810
+ var documents = loadDocuments(input, options);
2811
+
2812
+ if (documents.length === 0) {
2813
+ /*eslint-disable no-undefined*/
2814
+ return undefined;
2815
+ } else if (documents.length === 1) {
2816
+ return documents[0];
2817
+ }
2818
+ throw new exception('expected a single document in the stream, but found more');
2819
+ }
2820
+
2821
+
2822
+ var loadAll_1 = loadAll$1;
2823
+ var load_1 = load$1;
2824
+
2825
+ var loader = {
2826
+ loadAll: loadAll_1,
2827
+ load: load_1
2828
+ };
2829
+
2830
+ /*eslint-disable no-use-before-define*/
2831
+
2832
+
2833
+
2834
+
2835
+
2836
+ var _toString = Object.prototype.toString;
2837
+ var _hasOwnProperty = Object.prototype.hasOwnProperty;
2838
+
2839
+ var CHAR_BOM = 0xFEFF;
2840
+ var CHAR_TAB = 0x09; /* Tab */
2841
+ var CHAR_LINE_FEED = 0x0A; /* LF */
2842
+ var CHAR_CARRIAGE_RETURN = 0x0D; /* CR */
2843
+ var CHAR_SPACE = 0x20; /* Space */
2844
+ var CHAR_EXCLAMATION = 0x21; /* ! */
2845
+ var CHAR_DOUBLE_QUOTE = 0x22; /* " */
2846
+ var CHAR_SHARP = 0x23; /* # */
2847
+ var CHAR_PERCENT = 0x25; /* % */
2848
+ var CHAR_AMPERSAND = 0x26; /* & */
2849
+ var CHAR_SINGLE_QUOTE = 0x27; /* ' */
2850
+ var CHAR_ASTERISK = 0x2A; /* * */
2851
+ var CHAR_COMMA = 0x2C; /* , */
2852
+ var CHAR_MINUS = 0x2D; /* - */
2853
+ var CHAR_COLON = 0x3A; /* : */
2854
+ var CHAR_EQUALS = 0x3D; /* = */
2855
+ var CHAR_GREATER_THAN = 0x3E; /* > */
2856
+ var CHAR_QUESTION = 0x3F; /* ? */
2857
+ var CHAR_COMMERCIAL_AT = 0x40; /* @ */
2858
+ var CHAR_LEFT_SQUARE_BRACKET = 0x5B; /* [ */
2859
+ var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */
2860
+ var CHAR_GRAVE_ACCENT = 0x60; /* ` */
2861
+ var CHAR_LEFT_CURLY_BRACKET = 0x7B; /* { */
2862
+ var CHAR_VERTICAL_LINE = 0x7C; /* | */
2863
+ var CHAR_RIGHT_CURLY_BRACKET = 0x7D; /* } */
2864
+
2865
+ var ESCAPE_SEQUENCES = {};
2866
+
2867
+ ESCAPE_SEQUENCES[0x00] = '\\0';
2868
+ ESCAPE_SEQUENCES[0x07] = '\\a';
2869
+ ESCAPE_SEQUENCES[0x08] = '\\b';
2870
+ ESCAPE_SEQUENCES[0x09] = '\\t';
2871
+ ESCAPE_SEQUENCES[0x0A] = '\\n';
2872
+ ESCAPE_SEQUENCES[0x0B] = '\\v';
2873
+ ESCAPE_SEQUENCES[0x0C] = '\\f';
2874
+ ESCAPE_SEQUENCES[0x0D] = '\\r';
2875
+ ESCAPE_SEQUENCES[0x1B] = '\\e';
2876
+ ESCAPE_SEQUENCES[0x22] = '\\"';
2877
+ ESCAPE_SEQUENCES[0x5C] = '\\\\';
2878
+ ESCAPE_SEQUENCES[0x85] = '\\N';
2879
+ ESCAPE_SEQUENCES[0xA0] = '\\_';
2880
+ ESCAPE_SEQUENCES[0x2028] = '\\L';
2881
+ ESCAPE_SEQUENCES[0x2029] = '\\P';
2882
+
2883
+ var DEPRECATED_BOOLEANS_SYNTAX = [
2884
+ 'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON',
2885
+ 'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'
2886
+ ];
2887
+
2888
+ var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
2889
+
2890
+ function compileStyleMap(schema, map) {
2891
+ var result, keys, index, length, tag, style, type;
2892
+
2893
+ if (map === null) return {};
2894
+
2895
+ result = {};
2896
+ keys = Object.keys(map);
2897
+
2898
+ for (index = 0, length = keys.length; index < length; index += 1) {
2899
+ tag = keys[index];
2900
+ style = String(map[tag]);
2901
+
2902
+ if (tag.slice(0, 2) === '!!') {
2903
+ tag = 'tag:yaml.org,2002:' + tag.slice(2);
2904
+ }
2905
+ type = schema.compiledTypeMap['fallback'][tag];
2906
+
2907
+ if (type && _hasOwnProperty.call(type.styleAliases, style)) {
2908
+ style = type.styleAliases[style];
2909
+ }
2910
+
2911
+ result[tag] = style;
2912
+ }
2913
+
2914
+ return result;
2915
+ }
2916
+
2917
+ function encodeHex(character) {
2918
+ var string, handle, length;
2919
+
2920
+ string = character.toString(16).toUpperCase();
2921
+
2922
+ if (character <= 0xFF) {
2923
+ handle = 'x';
2924
+ length = 2;
2925
+ } else if (character <= 0xFFFF) {
2926
+ handle = 'u';
2927
+ length = 4;
2928
+ } else if (character <= 0xFFFFFFFF) {
2929
+ handle = 'U';
2930
+ length = 8;
2931
+ } else {
2932
+ throw new exception('code point within a string may not be greater than 0xFFFFFFFF');
2933
+ }
2934
+
2935
+ return '\\' + handle + common.repeat('0', length - string.length) + string;
2936
+ }
2937
+
2938
+
2939
+ var QUOTING_TYPE_SINGLE = 1,
2940
+ QUOTING_TYPE_DOUBLE = 2;
2941
+
2942
+ function State(options) {
2943
+ this.schema = options['schema'] || _default;
2944
+ this.indent = Math.max(1, (options['indent'] || 2));
2945
+ this.noArrayIndent = options['noArrayIndent'] || false;
2946
+ this.skipInvalid = options['skipInvalid'] || false;
2947
+ this.flowLevel = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']);
2948
+ this.styleMap = compileStyleMap(this.schema, options['styles'] || null);
2949
+ this.sortKeys = options['sortKeys'] || false;
2950
+ this.lineWidth = options['lineWidth'] || 80;
2951
+ this.noRefs = options['noRefs'] || false;
2952
+ this.noCompatMode = options['noCompatMode'] || false;
2953
+ this.condenseFlow = options['condenseFlow'] || false;
2954
+ this.quotingType = options['quotingType'] === '"' ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE;
2955
+ this.forceQuotes = options['forceQuotes'] || false;
2956
+ this.replacer = typeof options['replacer'] === 'function' ? options['replacer'] : null;
2957
+
2958
+ this.implicitTypes = this.schema.compiledImplicit;
2959
+ this.explicitTypes = this.schema.compiledExplicit;
2960
+
2961
+ this.tag = null;
2962
+ this.result = '';
2963
+
2964
+ this.duplicates = [];
2965
+ this.usedDuplicates = null;
2966
+ }
2967
+
2968
+ // Indents every line in a string. Empty lines (\n only) are not indented.
2969
+ function indentString(string, spaces) {
2970
+ var ind = common.repeat(' ', spaces),
2971
+ position = 0,
2972
+ next = -1,
2973
+ result = '',
2974
+ line,
2975
+ length = string.length;
2976
+
2977
+ while (position < length) {
2978
+ next = string.indexOf('\n', position);
2979
+ if (next === -1) {
2980
+ line = string.slice(position);
2981
+ position = length;
2982
+ } else {
2983
+ line = string.slice(position, next + 1);
2984
+ position = next + 1;
2985
+ }
2986
+
2987
+ if (line.length && line !== '\n') result += ind;
2988
+
2989
+ result += line;
2990
+ }
2991
+
2992
+ return result;
2993
+ }
2994
+
2995
+ function generateNextLine(state, level) {
2996
+ return '\n' + common.repeat(' ', state.indent * level);
2997
+ }
2998
+
2999
+ function testImplicitResolving(state, str) {
3000
+ var index, length, type;
3001
+
3002
+ for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
3003
+ type = state.implicitTypes[index];
3004
+
3005
+ if (type.resolve(str)) {
3006
+ return true;
3007
+ }
3008
+ }
3009
+
3010
+ return false;
3011
+ }
3012
+
3013
+ // [33] s-white ::= s-space | s-tab
3014
+ function isWhitespace(c) {
3015
+ return c === CHAR_SPACE || c === CHAR_TAB;
3016
+ }
3017
+
3018
+ // Returns true if the character can be printed without escaping.
3019
+ // From YAML 1.2: "any allowed characters known to be non-printable
3020
+ // should also be escaped. [However,] This isn’t mandatory"
3021
+ // Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029.
3022
+ function isPrintable(c) {
3023
+ return (0x00020 <= c && c <= 0x00007E)
3024
+ || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029)
3025
+ || ((0x0E000 <= c && c <= 0x00FFFD) && c !== CHAR_BOM)
3026
+ || (0x10000 <= c && c <= 0x10FFFF);
3027
+ }
3028
+
3029
+ // [34] ns-char ::= nb-char - s-white
3030
+ // [27] nb-char ::= c-printable - b-char - c-byte-order-mark
3031
+ // [26] b-char ::= b-line-feed | b-carriage-return
3032
+ // Including s-white (for some reason, examples doesn't match specs in this aspect)
3033
+ // ns-char ::= c-printable - b-line-feed - b-carriage-return - c-byte-order-mark
3034
+ function isNsCharOrWhitespace(c) {
3035
+ return isPrintable(c)
3036
+ && c !== CHAR_BOM
3037
+ // - b-char
3038
+ && c !== CHAR_CARRIAGE_RETURN
3039
+ && c !== CHAR_LINE_FEED;
3040
+ }
3041
+
3042
+ // [127] ns-plain-safe(c) ::= c = flow-out ⇒ ns-plain-safe-out
3043
+ // c = flow-in ⇒ ns-plain-safe-in
3044
+ // c = block-key ⇒ ns-plain-safe-out
3045
+ // c = flow-key ⇒ ns-plain-safe-in
3046
+ // [128] ns-plain-safe-out ::= ns-char
3047
+ // [129] ns-plain-safe-in ::= ns-char - c-flow-indicator
3048
+ // [130] ns-plain-char(c) ::= ( ns-plain-safe(c) - “:” - “#” )
3049
+ // | ( /* An ns-char preceding */ “#” )
3050
+ // | ( “:” /* Followed by an ns-plain-safe(c) */ )
3051
+ function isPlainSafe(c, prev, inblock) {
3052
+ var cIsNsCharOrWhitespace = isNsCharOrWhitespace(c);
3053
+ var cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c);
3054
+ return (
3055
+ // ns-plain-safe
3056
+ inblock ? // c = flow-in
3057
+ cIsNsCharOrWhitespace
3058
+ : cIsNsCharOrWhitespace
3059
+ // - c-flow-indicator
3060
+ && c !== CHAR_COMMA
3061
+ && c !== CHAR_LEFT_SQUARE_BRACKET
3062
+ && c !== CHAR_RIGHT_SQUARE_BRACKET
3063
+ && c !== CHAR_LEFT_CURLY_BRACKET
3064
+ && c !== CHAR_RIGHT_CURLY_BRACKET
3065
+ )
3066
+ // ns-plain-char
3067
+ && c !== CHAR_SHARP // false on '#'
3068
+ && !(prev === CHAR_COLON && !cIsNsChar) // false on ': '
3069
+ || (isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP) // change to true on '[^ ]#'
3070
+ || (prev === CHAR_COLON && cIsNsChar); // change to true on ':[^ ]'
3071
+ }
3072
+
3073
+ // Simplified test for values allowed as the first character in plain style.
3074
+ function isPlainSafeFirst(c) {
3075
+ // Uses a subset of ns-char - c-indicator
3076
+ // where ns-char = nb-char - s-white.
3077
+ // No support of ( ( “?” | “:” | “-” ) /* Followed by an ns-plain-safe(c)) */ ) part
3078
+ return isPrintable(c) && c !== CHAR_BOM
3079
+ && !isWhitespace(c) // - s-white
3080
+ // - (c-indicator ::=
3081
+ // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}”
3082
+ && c !== CHAR_MINUS
3083
+ && c !== CHAR_QUESTION
3084
+ && c !== CHAR_COLON
3085
+ && c !== CHAR_COMMA
3086
+ && c !== CHAR_LEFT_SQUARE_BRACKET
3087
+ && c !== CHAR_RIGHT_SQUARE_BRACKET
3088
+ && c !== CHAR_LEFT_CURLY_BRACKET
3089
+ && c !== CHAR_RIGHT_CURLY_BRACKET
3090
+ // | “#” | “&” | “*” | “!” | “|” | “=” | “>” | “'” | “"”
3091
+ && c !== CHAR_SHARP
3092
+ && c !== CHAR_AMPERSAND
3093
+ && c !== CHAR_ASTERISK
3094
+ && c !== CHAR_EXCLAMATION
3095
+ && c !== CHAR_VERTICAL_LINE
3096
+ && c !== CHAR_EQUALS
3097
+ && c !== CHAR_GREATER_THAN
3098
+ && c !== CHAR_SINGLE_QUOTE
3099
+ && c !== CHAR_DOUBLE_QUOTE
3100
+ // | “%” | “@” | “`”)
3101
+ && c !== CHAR_PERCENT
3102
+ && c !== CHAR_COMMERCIAL_AT
3103
+ && c !== CHAR_GRAVE_ACCENT;
3104
+ }
3105
+
3106
+ // Simplified test for values allowed as the last character in plain style.
3107
+ function isPlainSafeLast(c) {
3108
+ // just not whitespace or colon, it will be checked to be plain character later
3109
+ return !isWhitespace(c) && c !== CHAR_COLON;
3110
+ }
3111
+
3112
+ // Same as 'string'.codePointAt(pos), but works in older browsers.
3113
+ function codePointAt(string, pos) {
3114
+ var first = string.charCodeAt(pos), second;
3115
+ if (first >= 0xD800 && first <= 0xDBFF && pos + 1 < string.length) {
3116
+ second = string.charCodeAt(pos + 1);
3117
+ if (second >= 0xDC00 && second <= 0xDFFF) {
3118
+ // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
3119
+ return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
3120
+ }
3121
+ }
3122
+ return first;
3123
+ }
3124
+
3125
+ // Determines whether block indentation indicator is required.
3126
+ function needIndentIndicator(string) {
3127
+ var leadingSpaceRe = /^\n* /;
3128
+ return leadingSpaceRe.test(string);
3129
+ }
3130
+
3131
+ var STYLE_PLAIN = 1,
3132
+ STYLE_SINGLE = 2,
3133
+ STYLE_LITERAL = 3,
3134
+ STYLE_FOLDED = 4,
3135
+ STYLE_DOUBLE = 5;
3136
+
3137
+ // Determines which scalar styles are possible and returns the preferred style.
3138
+ // lineWidth = -1 => no limit.
3139
+ // Pre-conditions: str.length > 0.
3140
+ // Post-conditions:
3141
+ // STYLE_PLAIN or STYLE_SINGLE => no \n are in the string.
3142
+ // STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1).
3143
+ // STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1).
3144
+ function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth,
3145
+ testAmbiguousType, quotingType, forceQuotes, inblock) {
3146
+
3147
+ var i;
3148
+ var char = 0;
3149
+ var prevChar = null;
3150
+ var hasLineBreak = false;
3151
+ var hasFoldableLine = false; // only checked if shouldTrackWidth
3152
+ var shouldTrackWidth = lineWidth !== -1;
3153
+ var previousLineBreak = -1; // count the first line correctly
3154
+ var plain = isPlainSafeFirst(codePointAt(string, 0))
3155
+ && isPlainSafeLast(codePointAt(string, string.length - 1));
3156
+
3157
+ if (singleLineOnly || forceQuotes) {
3158
+ // Case: no block styles.
3159
+ // Check for disallowed characters to rule out plain and single.
3160
+ for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
3161
+ char = codePointAt(string, i);
3162
+ if (!isPrintable(char)) {
3163
+ return STYLE_DOUBLE;
3164
+ }
3165
+ plain = plain && isPlainSafe(char, prevChar, inblock);
3166
+ prevChar = char;
3167
+ }
3168
+ } else {
3169
+ // Case: block styles permitted.
3170
+ for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
3171
+ char = codePointAt(string, i);
3172
+ if (char === CHAR_LINE_FEED) {
3173
+ hasLineBreak = true;
3174
+ // Check if any line can be folded.
3175
+ if (shouldTrackWidth) {
3176
+ hasFoldableLine = hasFoldableLine ||
3177
+ // Foldable line = too long, and not more-indented.
3178
+ (i - previousLineBreak - 1 > lineWidth &&
3179
+ string[previousLineBreak + 1] !== ' ');
3180
+ previousLineBreak = i;
3181
+ }
3182
+ } else if (!isPrintable(char)) {
3183
+ return STYLE_DOUBLE;
3184
+ }
3185
+ plain = plain && isPlainSafe(char, prevChar, inblock);
3186
+ prevChar = char;
3187
+ }
3188
+ // in case the end is missing a \n
3189
+ hasFoldableLine = hasFoldableLine || (shouldTrackWidth &&
3190
+ (i - previousLineBreak - 1 > lineWidth &&
3191
+ string[previousLineBreak + 1] !== ' '));
3192
+ }
3193
+ // Although every style can represent \n without escaping, prefer block styles
3194
+ // for multiline, since they're more readable and they don't add empty lines.
3195
+ // Also prefer folding a super-long line.
3196
+ if (!hasLineBreak && !hasFoldableLine) {
3197
+ // Strings interpretable as another type have to be quoted;
3198
+ // e.g. the string 'true' vs. the boolean true.
3199
+ if (plain && !forceQuotes && !testAmbiguousType(string)) {
3200
+ return STYLE_PLAIN;
3201
+ }
3202
+ return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
3203
+ }
3204
+ // Edge case: block indentation indicator can only have one digit.
3205
+ if (indentPerLevel > 9 && needIndentIndicator(string)) {
3206
+ return STYLE_DOUBLE;
3207
+ }
3208
+ // At this point we know block styles are valid.
3209
+ // Prefer literal style unless we want to fold.
3210
+ if (!forceQuotes) {
3211
+ return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
3212
+ }
3213
+ return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
3214
+ }
3215
+
3216
+ // Note: line breaking/folding is implemented for only the folded style.
3217
+ // NB. We drop the last trailing newline (if any) of a returned block scalar
3218
+ // since the dumper adds its own newline. This always works:
3219
+ // • No ending newline => unaffected; already using strip "-" chomping.
3220
+ // • Ending newline => removed then restored.
3221
+ // Importantly, this keeps the "+" chomp indicator from gaining an extra line.
3222
+ function writeScalar(state, string, level, iskey, inblock) {
3223
+ state.dump = (function () {
3224
+ if (string.length === 0) {
3225
+ return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''";
3226
+ }
3227
+ if (!state.noCompatMode) {
3228
+ if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) {
3229
+ return state.quotingType === QUOTING_TYPE_DOUBLE ? ('"' + string + '"') : ("'" + string + "'");
3230
+ }
3231
+ }
3232
+
3233
+ var indent = state.indent * Math.max(1, level); // no 0-indent scalars
3234
+ // As indentation gets deeper, let the width decrease monotonically
3235
+ // to the lower bound min(state.lineWidth, 40).
3236
+ // Note that this implies
3237
+ // state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound.
3238
+ // state.lineWidth > 40 + state.indent: width decreases until the lower bound.
3239
+ // This behaves better than a constant minimum width which disallows narrower options,
3240
+ // or an indent threshold which causes the width to suddenly increase.
3241
+ var lineWidth = state.lineWidth === -1
3242
+ ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
3243
+
3244
+ // Without knowing if keys are implicit/explicit, assume implicit for safety.
3245
+ var singleLineOnly = iskey
3246
+ // No block styles in flow mode.
3247
+ || (state.flowLevel > -1 && level >= state.flowLevel);
3248
+ function testAmbiguity(string) {
3249
+ return testImplicitResolving(state, string);
3250
+ }
3251
+
3252
+ switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth,
3253
+ testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) {
3254
+
3255
+ case STYLE_PLAIN:
3256
+ return string;
3257
+ case STYLE_SINGLE:
3258
+ return "'" + string.replace(/'/g, "''") + "'";
3259
+ case STYLE_LITERAL:
3260
+ return '|' + blockHeader(string, state.indent)
3261
+ + dropEndingNewline(indentString(string, indent));
3262
+ case STYLE_FOLDED:
3263
+ return '>' + blockHeader(string, state.indent)
3264
+ + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
3265
+ case STYLE_DOUBLE:
3266
+ return '"' + escapeString(string) + '"';
3267
+ default:
3268
+ throw new exception('impossible error: invalid scalar style');
3269
+ }
3270
+ }());
3271
+ }
3272
+
3273
+ // Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9.
3274
+ function blockHeader(string, indentPerLevel) {
3275
+ var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : '';
3276
+
3277
+ // note the special case: the string '\n' counts as a "trailing" empty line.
3278
+ var clip = string[string.length - 1] === '\n';
3279
+ var keep = clip && (string[string.length - 2] === '\n' || string === '\n');
3280
+ var chomp = keep ? '+' : (clip ? '' : '-');
3281
+
3282
+ return indentIndicator + chomp + '\n';
3283
+ }
3284
+
3285
+ // (See the note for writeScalar.)
3286
+ function dropEndingNewline(string) {
3287
+ return string[string.length - 1] === '\n' ? string.slice(0, -1) : string;
3288
+ }
3289
+
3290
+ // Note: a long line without a suitable break point will exceed the width limit.
3291
+ // Pre-conditions: every char in str isPrintable, str.length > 0, width > 0.
3292
+ function foldString(string, width) {
3293
+ // In folded style, $k$ consecutive newlines output as $k+1$ newlines—
3294
+ // unless they're before or after a more-indented line, or at the very
3295
+ // beginning or end, in which case $k$ maps to $k$.
3296
+ // Therefore, parse each chunk as newline(s) followed by a content line.
3297
+ var lineRe = /(\n+)([^\n]*)/g;
3298
+
3299
+ // first line (possibly an empty line)
3300
+ var result = (function () {
3301
+ var nextLF = string.indexOf('\n');
3302
+ nextLF = nextLF !== -1 ? nextLF : string.length;
3303
+ lineRe.lastIndex = nextLF;
3304
+ return foldLine(string.slice(0, nextLF), width);
3305
+ }());
3306
+ // If we haven't reached the first content line yet, don't add an extra \n.
3307
+ var prevMoreIndented = string[0] === '\n' || string[0] === ' ';
3308
+ var moreIndented;
3309
+
3310
+ // rest of the lines
3311
+ var match;
3312
+ while ((match = lineRe.exec(string))) {
3313
+ var prefix = match[1], line = match[2];
3314
+ moreIndented = (line[0] === ' ');
3315
+ result += prefix
3316
+ + (!prevMoreIndented && !moreIndented && line !== ''
3317
+ ? '\n' : '')
3318
+ + foldLine(line, width);
3319
+ prevMoreIndented = moreIndented;
3320
+ }
3321
+
3322
+ return result;
3323
+ }
3324
+
3325
+ // Greedy line breaking.
3326
+ // Picks the longest line under the limit each time,
3327
+ // otherwise settles for the shortest line over the limit.
3328
+ // NB. More-indented lines *cannot* be folded, as that would add an extra \n.
3329
+ function foldLine(line, width) {
3330
+ if (line === '' || line[0] === ' ') return line;
3331
+
3332
+ // Since a more-indented line adds a \n, breaks can't be followed by a space.
3333
+ var breakRe = / [^ ]/g; // note: the match index will always be <= length-2.
3334
+ var match;
3335
+ // start is an inclusive index. end, curr, and next are exclusive.
3336
+ var start = 0, end, curr = 0, next = 0;
3337
+ var result = '';
3338
+
3339
+ // Invariants: 0 <= start <= length-1.
3340
+ // 0 <= curr <= next <= max(0, length-2). curr - start <= width.
3341
+ // Inside the loop:
3342
+ // A match implies length >= 2, so curr and next are <= length-2.
3343
+ while ((match = breakRe.exec(line))) {
3344
+ next = match.index;
3345
+ // maintain invariant: curr - start <= width
3346
+ if (next - start > width) {
3347
+ end = (curr > start) ? curr : next; // derive end <= length-2
3348
+ result += '\n' + line.slice(start, end);
3349
+ // skip the space that was output as \n
3350
+ start = end + 1; // derive start <= length-1
3351
+ }
3352
+ curr = next;
3353
+ }
3354
+
3355
+ // By the invariants, start <= length-1, so there is something left over.
3356
+ // It is either the whole string or a part starting from non-whitespace.
3357
+ result += '\n';
3358
+ // Insert a break if the remainder is too long and there is a break available.
3359
+ if (line.length - start > width && curr > start) {
3360
+ result += line.slice(start, curr) + '\n' + line.slice(curr + 1);
3361
+ } else {
3362
+ result += line.slice(start);
3363
+ }
3364
+
3365
+ return result.slice(1); // drop extra \n joiner
3366
+ }
3367
+
3368
+ // Escapes a double-quoted string.
3369
+ function escapeString(string) {
3370
+ var result = '';
3371
+ var char = 0;
3372
+ var escapeSeq;
3373
+
3374
+ for (var i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
3375
+ char = codePointAt(string, i);
3376
+ escapeSeq = ESCAPE_SEQUENCES[char];
3377
+
3378
+ if (!escapeSeq && isPrintable(char)) {
3379
+ result += string[i];
3380
+ if (char >= 0x10000) result += string[i + 1];
3381
+ } else {
3382
+ result += escapeSeq || encodeHex(char);
3383
+ }
3384
+ }
3385
+
3386
+ return result;
3387
+ }
3388
+
3389
+ function writeFlowSequence(state, level, object) {
3390
+ var _result = '',
3391
+ _tag = state.tag,
3392
+ index,
3393
+ length,
3394
+ value;
3395
+
3396
+ for (index = 0, length = object.length; index < length; index += 1) {
3397
+ value = object[index];
3398
+
3399
+ if (state.replacer) {
3400
+ value = state.replacer.call(object, String(index), value);
3401
+ }
3402
+
3403
+ // Write only valid elements, put null instead of invalid elements.
3404
+ if (writeNode(state, level, value, false, false) ||
3405
+ (typeof value === 'undefined' &&
3406
+ writeNode(state, level, null, false, false))) {
3407
+
3408
+ if (_result !== '') _result += ',' + (!state.condenseFlow ? ' ' : '');
3409
+ _result += state.dump;
3410
+ }
3411
+ }
3412
+
3413
+ state.tag = _tag;
3414
+ state.dump = '[' + _result + ']';
3415
+ }
3416
+
3417
+ function writeBlockSequence(state, level, object, compact) {
3418
+ var _result = '',
3419
+ _tag = state.tag,
3420
+ index,
3421
+ length,
3422
+ value;
3423
+
3424
+ for (index = 0, length = object.length; index < length; index += 1) {
3425
+ value = object[index];
3426
+
3427
+ if (state.replacer) {
3428
+ value = state.replacer.call(object, String(index), value);
3429
+ }
3430
+
3431
+ // Write only valid elements, put null instead of invalid elements.
3432
+ if (writeNode(state, level + 1, value, true, true, false, true) ||
3433
+ (typeof value === 'undefined' &&
3434
+ writeNode(state, level + 1, null, true, true, false, true))) {
3435
+
3436
+ if (!compact || _result !== '') {
3437
+ _result += generateNextLine(state, level);
3438
+ }
3439
+
3440
+ if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
3441
+ _result += '-';
3442
+ } else {
3443
+ _result += '- ';
3444
+ }
3445
+
3446
+ _result += state.dump;
3447
+ }
3448
+ }
3449
+
3450
+ state.tag = _tag;
3451
+ state.dump = _result || '[]'; // Empty sequence if no valid values.
3452
+ }
3453
+
3454
+ function writeFlowMapping(state, level, object) {
3455
+ var _result = '',
3456
+ _tag = state.tag,
3457
+ objectKeyList = Object.keys(object),
3458
+ index,
3459
+ length,
3460
+ objectKey,
3461
+ objectValue,
3462
+ pairBuffer;
3463
+
3464
+ for (index = 0, length = objectKeyList.length; index < length; index += 1) {
3465
+
3466
+ pairBuffer = '';
3467
+ if (_result !== '') pairBuffer += ', ';
3468
+
3469
+ if (state.condenseFlow) pairBuffer += '"';
3470
+
3471
+ objectKey = objectKeyList[index];
3472
+ objectValue = object[objectKey];
3473
+
3474
+ if (state.replacer) {
3475
+ objectValue = state.replacer.call(object, objectKey, objectValue);
3476
+ }
3477
+
3478
+ if (!writeNode(state, level, objectKey, false, false)) {
3479
+ continue; // Skip this pair because of invalid key;
3480
+ }
3481
+
3482
+ if (state.dump.length > 1024) pairBuffer += '? ';
3483
+
3484
+ pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' ');
3485
+
3486
+ if (!writeNode(state, level, objectValue, false, false)) {
3487
+ continue; // Skip this pair because of invalid value.
3488
+ }
3489
+
3490
+ pairBuffer += state.dump;
3491
+
3492
+ // Both key and value are valid.
3493
+ _result += pairBuffer;
3494
+ }
3495
+
3496
+ state.tag = _tag;
3497
+ state.dump = '{' + _result + '}';
3498
+ }
3499
+
3500
+ function writeBlockMapping(state, level, object, compact) {
3501
+ var _result = '',
3502
+ _tag = state.tag,
3503
+ objectKeyList = Object.keys(object),
3504
+ index,
3505
+ length,
3506
+ objectKey,
3507
+ objectValue,
3508
+ explicitPair,
3509
+ pairBuffer;
3510
+
3511
+ // Allow sorting keys so that the output file is deterministic
3512
+ if (state.sortKeys === true) {
3513
+ // Default sorting
3514
+ objectKeyList.sort();
3515
+ } else if (typeof state.sortKeys === 'function') {
3516
+ // Custom sort function
3517
+ objectKeyList.sort(state.sortKeys);
3518
+ } else if (state.sortKeys) {
3519
+ // Something is wrong
3520
+ throw new exception('sortKeys must be a boolean or a function');
3521
+ }
3522
+
3523
+ for (index = 0, length = objectKeyList.length; index < length; index += 1) {
3524
+ pairBuffer = '';
3525
+
3526
+ if (!compact || _result !== '') {
3527
+ pairBuffer += generateNextLine(state, level);
3528
+ }
3529
+
3530
+ objectKey = objectKeyList[index];
3531
+ objectValue = object[objectKey];
3532
+
3533
+ if (state.replacer) {
3534
+ objectValue = state.replacer.call(object, objectKey, objectValue);
3535
+ }
3536
+
3537
+ if (!writeNode(state, level + 1, objectKey, true, true, true)) {
3538
+ continue; // Skip this pair because of invalid key.
3539
+ }
3540
+
3541
+ explicitPair = (state.tag !== null && state.tag !== '?') ||
3542
+ (state.dump && state.dump.length > 1024);
3543
+
3544
+ if (explicitPair) {
3545
+ if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
3546
+ pairBuffer += '?';
3547
+ } else {
3548
+ pairBuffer += '? ';
3549
+ }
3550
+ }
3551
+
3552
+ pairBuffer += state.dump;
3553
+
3554
+ if (explicitPair) {
3555
+ pairBuffer += generateNextLine(state, level);
3556
+ }
3557
+
3558
+ if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
3559
+ continue; // Skip this pair because of invalid value.
3560
+ }
3561
+
3562
+ if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
3563
+ pairBuffer += ':';
3564
+ } else {
3565
+ pairBuffer += ': ';
3566
+ }
3567
+
3568
+ pairBuffer += state.dump;
3569
+
3570
+ // Both key and value are valid.
3571
+ _result += pairBuffer;
3572
+ }
3573
+
3574
+ state.tag = _tag;
3575
+ state.dump = _result || '{}'; // Empty mapping if no valid pairs.
3576
+ }
3577
+
3578
+ function detectType(state, object, explicit) {
3579
+ var _result, typeList, index, length, type, style;
3580
+
3581
+ typeList = explicit ? state.explicitTypes : state.implicitTypes;
3582
+
3583
+ for (index = 0, length = typeList.length; index < length; index += 1) {
3584
+ type = typeList[index];
3585
+
3586
+ if ((type.instanceOf || type.predicate) &&
3587
+ (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) &&
3588
+ (!type.predicate || type.predicate(object))) {
3589
+
3590
+ if (explicit) {
3591
+ if (type.multi && type.representName) {
3592
+ state.tag = type.representName(object);
3593
+ } else {
3594
+ state.tag = type.tag;
3595
+ }
3596
+ } else {
3597
+ state.tag = '?';
3598
+ }
3599
+
3600
+ if (type.represent) {
3601
+ style = state.styleMap[type.tag] || type.defaultStyle;
3602
+
3603
+ if (_toString.call(type.represent) === '[object Function]') {
3604
+ _result = type.represent(object, style);
3605
+ } else if (_hasOwnProperty.call(type.represent, style)) {
3606
+ _result = type.represent[style](object, style);
3607
+ } else {
3608
+ throw new exception('!<' + type.tag + '> tag resolver accepts not "' + style + '" style');
3609
+ }
3610
+
3611
+ state.dump = _result;
3612
+ }
3613
+
3614
+ return true;
3615
+ }
3616
+ }
3617
+
3618
+ return false;
3619
+ }
3620
+
3621
+ // Serializes `object` and writes it to global `result`.
3622
+ // Returns true on success, or false on invalid object.
3623
+ //
3624
+ function writeNode(state, level, object, block, compact, iskey, isblockseq) {
3625
+ state.tag = null;
3626
+ state.dump = object;
3627
+
3628
+ if (!detectType(state, object, false)) {
3629
+ detectType(state, object, true);
3630
+ }
3631
+
3632
+ var type = _toString.call(state.dump);
3633
+ var inblock = block;
3634
+ var tagStr;
3635
+
3636
+ if (block) {
3637
+ block = (state.flowLevel < 0 || state.flowLevel > level);
3638
+ }
3639
+
3640
+ var objectOrArray = type === '[object Object]' || type === '[object Array]',
3641
+ duplicateIndex,
3642
+ duplicate;
3643
+
3644
+ if (objectOrArray) {
3645
+ duplicateIndex = state.duplicates.indexOf(object);
3646
+ duplicate = duplicateIndex !== -1;
3647
+ }
3648
+
3649
+ if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) {
3650
+ compact = false;
3651
+ }
3652
+
3653
+ if (duplicate && state.usedDuplicates[duplicateIndex]) {
3654
+ state.dump = '*ref_' + duplicateIndex;
3655
+ } else {
3656
+ if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
3657
+ state.usedDuplicates[duplicateIndex] = true;
3658
+ }
3659
+ if (type === '[object Object]') {
3660
+ if (block && (Object.keys(state.dump).length !== 0)) {
3661
+ writeBlockMapping(state, level, state.dump, compact);
3662
+ if (duplicate) {
3663
+ state.dump = '&ref_' + duplicateIndex + state.dump;
3664
+ }
3665
+ } else {
3666
+ writeFlowMapping(state, level, state.dump);
3667
+ if (duplicate) {
3668
+ state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
3669
+ }
3670
+ }
3671
+ } else if (type === '[object Array]') {
3672
+ if (block && (state.dump.length !== 0)) {
3673
+ if (state.noArrayIndent && !isblockseq && level > 0) {
3674
+ writeBlockSequence(state, level - 1, state.dump, compact);
3675
+ } else {
3676
+ writeBlockSequence(state, level, state.dump, compact);
3677
+ }
3678
+ if (duplicate) {
3679
+ state.dump = '&ref_' + duplicateIndex + state.dump;
3680
+ }
3681
+ } else {
3682
+ writeFlowSequence(state, level, state.dump);
3683
+ if (duplicate) {
3684
+ state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
3685
+ }
3686
+ }
3687
+ } else if (type === '[object String]') {
3688
+ if (state.tag !== '?') {
3689
+ writeScalar(state, state.dump, level, iskey, inblock);
3690
+ }
3691
+ } else if (type === '[object Undefined]') {
3692
+ return false;
3693
+ } else {
3694
+ if (state.skipInvalid) return false;
3695
+ throw new exception('unacceptable kind of an object to dump ' + type);
3696
+ }
3697
+
3698
+ if (state.tag !== null && state.tag !== '?') {
3699
+ // Need to encode all characters except those allowed by the spec:
3700
+ //
3701
+ // [35] ns-dec-digit ::= [#x30-#x39] /* 0-9 */
3702
+ // [36] ns-hex-digit ::= ns-dec-digit
3703
+ // | [#x41-#x46] /* A-F */ | [#x61-#x66] /* a-f */
3704
+ // [37] ns-ascii-letter ::= [#x41-#x5A] /* A-Z */ | [#x61-#x7A] /* a-z */
3705
+ // [38] ns-word-char ::= ns-dec-digit | ns-ascii-letter | “-”
3706
+ // [39] ns-uri-char ::= “%” ns-hex-digit ns-hex-digit | ns-word-char | “#”
3707
+ // | “;” | “/” | “?” | “:” | “@” | “&” | “=” | “+” | “$” | “,”
3708
+ // | “_” | “.” | “!” | “~” | “*” | “'” | “(” | “)” | “[” | “]”
3709
+ //
3710
+ // Also need to encode '!' because it has special meaning (end of tag prefix).
3711
+ //
3712
+ tagStr = encodeURI(
3713
+ state.tag[0] === '!' ? state.tag.slice(1) : state.tag
3714
+ ).replace(/!/g, '%21');
3715
+
3716
+ if (state.tag[0] === '!') {
3717
+ tagStr = '!' + tagStr;
3718
+ } else if (tagStr.slice(0, 18) === 'tag:yaml.org,2002:') {
3719
+ tagStr = '!!' + tagStr.slice(18);
3720
+ } else {
3721
+ tagStr = '!<' + tagStr + '>';
3722
+ }
3723
+
3724
+ state.dump = tagStr + ' ' + state.dump;
3725
+ }
3726
+ }
3727
+
3728
+ return true;
3729
+ }
3730
+
3731
+ function getDuplicateReferences(object, state) {
3732
+ var objects = [],
3733
+ duplicatesIndexes = [],
3734
+ index,
3735
+ length;
3736
+
3737
+ inspectNode(object, objects, duplicatesIndexes);
3738
+
3739
+ for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
3740
+ state.duplicates.push(objects[duplicatesIndexes[index]]);
3741
+ }
3742
+ state.usedDuplicates = new Array(length);
3743
+ }
3744
+
3745
+ function inspectNode(object, objects, duplicatesIndexes) {
3746
+ var objectKeyList,
3747
+ index,
3748
+ length;
3749
+
3750
+ if (object !== null && typeof object === 'object') {
3751
+ index = objects.indexOf(object);
3752
+ if (index !== -1) {
3753
+ if (duplicatesIndexes.indexOf(index) === -1) {
3754
+ duplicatesIndexes.push(index);
3755
+ }
3756
+ } else {
3757
+ objects.push(object);
3758
+
3759
+ if (Array.isArray(object)) {
3760
+ for (index = 0, length = object.length; index < length; index += 1) {
3761
+ inspectNode(object[index], objects, duplicatesIndexes);
3762
+ }
3763
+ } else {
3764
+ objectKeyList = Object.keys(object);
3765
+
3766
+ for (index = 0, length = objectKeyList.length; index < length; index += 1) {
3767
+ inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
3768
+ }
3769
+ }
3770
+ }
3771
+ }
3772
+ }
3773
+
3774
+ function dump$1(input, options) {
3775
+ options = options || {};
3776
+
3777
+ var state = new State(options);
3778
+
3779
+ if (!state.noRefs) getDuplicateReferences(input, state);
3780
+
3781
+ var value = input;
3782
+
3783
+ if (state.replacer) {
3784
+ value = state.replacer.call({ '': value }, '', value);
3785
+ }
3786
+
3787
+ if (writeNode(state, 0, value, true, true)) return state.dump + '\n';
3788
+
3789
+ return '';
3790
+ }
3791
+
3792
+ var dump_1 = dump$1;
3793
+
3794
+ var dumper = {
3795
+ dump: dump_1
3796
+ };
3797
+
3798
+ function renamed(from, to) {
3799
+ return function () {
3800
+ throw new Error('Function yaml.' + from + ' is removed in js-yaml 4. ' +
3801
+ 'Use yaml.' + to + ' instead, which is now safe by default.');
3802
+ };
3803
+ }
3804
+
3805
+
3806
+ var Type = type;
3807
+ var Schema = schema;
3808
+ var FAILSAFE_SCHEMA = failsafe;
3809
+ var JSON_SCHEMA = json;
3810
+ var CORE_SCHEMA = core;
3811
+ var DEFAULT_SCHEMA = _default;
3812
+ var load = loader.load;
3813
+ var loadAll = loader.loadAll;
3814
+ var dump = dumper.dump;
3815
+ var YAMLException = exception;
3816
+
3817
+ // Re-export all types in case user wants to create custom schema
3818
+ var types = {
3819
+ binary: binary,
3820
+ float: float,
3821
+ map: map,
3822
+ null: _null,
3823
+ pairs: pairs,
3824
+ set: set,
3825
+ timestamp: timestamp,
3826
+ bool: bool,
3827
+ int: int,
3828
+ merge: merge,
3829
+ omap: omap,
3830
+ seq: seq,
3831
+ str: str
3832
+ };
3833
+
3834
+ // Removed functions from JS-YAML 3.0.x
3835
+ var safeLoad = renamed('safeLoad', 'load');
3836
+ var safeLoadAll = renamed('safeLoadAll', 'loadAll');
3837
+ var safeDump = renamed('safeDump', 'dump');
3838
+
3839
+ var jsYaml = {
3840
+ Type: Type,
3841
+ Schema: Schema,
3842
+ FAILSAFE_SCHEMA: FAILSAFE_SCHEMA,
3843
+ JSON_SCHEMA: JSON_SCHEMA,
3844
+ CORE_SCHEMA: CORE_SCHEMA,
3845
+ DEFAULT_SCHEMA: DEFAULT_SCHEMA,
3846
+ load: load,
3847
+ loadAll: loadAll,
3848
+ dump: dump,
3849
+ YAMLException: YAMLException,
3850
+ types: types,
3851
+ safeLoad: safeLoad,
3852
+ safeLoadAll: safeLoadAll,
3853
+ safeDump: safeDump
3854
+ };
3855
+
3856
+ exports.CORE_SCHEMA = CORE_SCHEMA;
3857
+ exports.DEFAULT_SCHEMA = DEFAULT_SCHEMA;
3858
+ exports.FAILSAFE_SCHEMA = FAILSAFE_SCHEMA;
3859
+ exports.JSON_SCHEMA = JSON_SCHEMA;
3860
+ exports.Schema = Schema;
3861
+ exports.Type = Type;
3862
+ exports.YAMLException = YAMLException;
3863
+ exports.default = jsYaml;
3864
+ exports.dump = dump;
3865
+ exports.load = load;
3866
+ exports.loadAll = loadAll;
3867
+ exports.safeDump = safeDump;
3868
+ exports.safeLoad = safeLoad;
3869
+ exports.safeLoadAll = safeLoadAll;
3870
+ exports.types = types;
3871
+
3872
+ Object.defineProperty(exports, '__esModule', { value: true });
3873
+
3874
+ })));