@swagger-api/apidom-ns-openapi-2 0.79.0

package/es/refractor/visitors/open-api-2/path-item/ParametersVisitor.mjs

@@ -0,0 +1,27 @@
+import stampit from 'stampit';
+import { BREAK } from '@swagger-api/apidom-core';
+import { isReferenceLikeElement } from "../../../predicates.mjs";
+import { isReferenceElement } from "../../../../predicates.mjs";
+import PathItemParametersElement from "../../../../elements/nces/PathItemParameters.mjs";
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+import SpecificationVisitor from "../../SpecificationVisitor.mjs";
+const ParametersVisitor = stampit(SpecificationVisitor, FallbackVisitor, {
+  init() {
+    this.element = new PathItemParametersElement();
+  },
+  methods: {
+    ArrayElement(arrayElement) {
+      arrayElement.forEach(item => {
+        const specPath = isReferenceLikeElement(item) ? ['document', 'objects', 'Reference'] : ['document', 'objects', 'Parameter'];
+        const element = this.toRefractedElement(specPath, item);
+        if (isReferenceElement(element)) {
+          element.setMetaProperty('referenced-element', 'parameter');
+        }
+        this.element.push(element);
+      });
+      this.copyMetaAndAttributes(arrayElement, this.element);
+      return BREAK;
+    }
+  }
+});
+export default ParametersVisitor;

package/es/refractor/visitors/open-api-2/path-item/index.mjs

@@ -0,0 +1,35 @@
+import stampit from 'stampit';
+import { always } from 'ramda';
+import { isStringElement, cloneDeep, toValue } from '@swagger-api/apidom-core';
+import PathItemElement from "../../../../elements/PathItem.mjs";
+import { isOperationElement } from "../../../../predicates.mjs";
+import FixedFieldsVisitor from "../../generics/FixedFieldsVisitor.mjs";
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+const PathItemVisitor = stampit(FixedFieldsVisitor, FallbackVisitor, {
+  props: {
+    specPath: always(['document', 'objects', 'PathItem'])
+  },
+  init() {
+    this.element = new PathItemElement();
+  },
+  methods: {
+    ObjectElement(objectElement) {
+      // @ts-ignore
+      const result = FixedFieldsVisitor.compose.methods.ObjectElement.call(this, objectElement);
+
+      // decorate Operation elements with HTTP method
+      this.element.filter(isOperationElement).forEach((operationElement, httpMethodElementCI) => {
+        const httpMethodElementCS = cloneDeep(httpMethodElementCI);
+        httpMethodElementCS.content = toValue(httpMethodElementCS).toUpperCase();
+        operationElement.setMetaProperty('http-method', httpMethodElementCS);
+      });
+
+      // mark this PathItemElement with reference metadata
+      if (isStringElement(this.element.$ref)) {
+        this.element.classes.push('reference-element');
+      }
+      return result;
+    }
+  }
+});
+export default PathItemVisitor;

package/es/refractor/visitors/open-api-2/paths/index.mjs

@@ -0,0 +1,30 @@
+import stampit from 'stampit';
+import { test, always } from 'ramda';
+import { cloneDeep } from '@swagger-api/apidom-core';
+import PathsElement from "../../../../elements/Paths.mjs";
+import PatternedFieldsVisitor from "../../generics/PatternedFieldsVisitor.mjs";
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+import { isPathItemElement } from "../../../../predicates.mjs";
+const PathsVisitor = stampit(PatternedFieldsVisitor, FallbackVisitor, {
+  props: {
+    fieldPatternPredicate: test(/^\/(?<path>.*)$/),
+    specPath: always(['document', 'objects', 'PathItem']),
+    canSupportSpecificationExtensions: true
+  },
+  init() {
+    this.element = new PathsElement();
+  },
+  methods: {
+    ObjectElement(objectElement) {
+      // @ts-ignore
+      const result = PatternedFieldsVisitor.compose.methods.ObjectElement.call(this, objectElement);
+
+      // decorate every PathItemElement with path metadata
+      this.element.filter(isPathItemElement).forEach((pathItemElement, key) => {
+        pathItemElement.setMetaProperty('path', cloneDeep(key));
+      });
+      return result;
+    }
+  }
+});
+export default PathsVisitor;

package/es/refractor/visitors/open-api-2/reference/$RefVisitor.mjs

@@ -0,0 +1,13 @@
+import stampit from 'stampit';
+import { BREAK, cloneDeep } from '@swagger-api/apidom-core';
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+const $RefVisitor = stampit(FallbackVisitor, {
+  methods: {
+    StringElement(stringElement) {
+      this.element = cloneDeep(stringElement);
+      this.element.classes.push('reference-value');
+      return BREAK;
+    }
+  }
+});
+export default $RefVisitor;

package/es/refractor/visitors/open-api-2/reference/index.mjs

@@ -0,0 +1,28 @@
+import stampit from 'stampit';
+import { always } from 'ramda';
+import { isStringElement } from '@swagger-api/apidom-core';
+import ReferenceElement from "../../../../elements/Reference.mjs";
+import FixedFieldsVisitor from "../../generics/FixedFieldsVisitor.mjs";
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+const ReferenceVisitor = stampit(FixedFieldsVisitor, FallbackVisitor, {
+  props: {
+    specPath: always(['document', 'objects', 'Reference']),
+    canSupportSpecificationExtensions: false
+  },
+  init() {
+    this.element = new ReferenceElement();
+  },
+  methods: {
+    ObjectElement(objectElement) {
+      // @ts-ignore
+      const result = FixedFieldsVisitor.compose.methods.ObjectElement.call(this, objectElement);
+
+      // mark this ReferenceElement with reference metadata
+      if (isStringElement(this.element.$ref)) {
+        this.element.classes.push('reference-element');
+      }
+      return result;
+    }
+  }
+});
+export default ReferenceVisitor;

package/es/refractor/visitors/open-api-2/response/index.mjs

@@ -0,0 +1,15 @@
+import stampit from 'stampit';
+import { always } from 'ramda';
+import ResponseElement from "../../../../elements/Response.mjs";
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+import FixedFieldsVisitor from "../../generics/FixedFieldsVisitor.mjs";
+const ResponseVisitor = stampit(FixedFieldsVisitor, FallbackVisitor, {
+  props: {
+    specPath: always(['document', 'objects', 'Response']),
+    canSupportSpecificationExtensions: true
+  },
+  init() {
+    this.element = new ResponseElement();
+  }
+});
+export default ResponseVisitor;

package/es/refractor/visitors/open-api-2/responses/DefaultVisitor.mjs

@@ -0,0 +1,32 @@
+import stampit from 'stampit';
+import { T as stubTrue } from 'ramda';
+import { isReferenceLikeElement } from "../../../predicates.mjs";
+import { isReferenceElement, isResponseElement } from "../../../../predicates.mjs";
+import AlternatingVisitor from "../../generics/AlternatingVisitor.mjs";
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+const DefaultVisitor = stampit(AlternatingVisitor, FallbackVisitor, {
+  props: {
+    alternator: [{
+      predicate: isReferenceLikeElement,
+      specPath: ['document', 'objects', 'Reference']
+    }, {
+      predicate: stubTrue,
+      specPath: ['document', 'objects', 'Response']
+    }]
+  },
+  methods: {
+    ObjectElement(objectElement) {
+      // @ts-ignore
+      const result = AlternatingVisitor.compose.methods.enter.call(this, objectElement);
+
+      // decorate ReferenceElement with type of referencing element
+      if (isReferenceElement(this.element)) {
+        this.element.setMetaProperty('referenced-element', 'response');
+      } else if (isResponseElement(this.element)) {
+        this.element.setMetaProperty('http-status-code', 'default');
+      }
+      return result;
+    }
+  }
+});
+export default DefaultVisitor;

package/es/refractor/visitors/open-api-2/responses/index.mjs

@@ -0,0 +1,41 @@
+import stampit from 'stampit';
+import { test, always, range } from 'ramda';
+import { cloneDeep, toValue } from '@swagger-api/apidom-core';
+import ResponsesElement from "../../../../elements/Responses.mjs";
+import MixedFieldsVisitor from "../../generics/MixedFieldsVisitor.mjs";
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+import { isReferenceLikeElement } from "../../../predicates.mjs";
+import { isReferenceElement, isResponseElement } from "../../../../predicates.mjs";
+const ResponsesVisitor = stampit(MixedFieldsVisitor, FallbackVisitor, {
+  props: {
+    specPathFixedFields: always(['document', 'objects', 'Responses']),
+    specPathPatternedFields: element => {
+      return isReferenceLikeElement(element) ? ['document', 'objects', 'Reference'] : ['document', 'objects', 'Response'];
+    },
+    fieldPatternPredicate: test(new RegExp(`^(1XX|2XX|3XX|4XX|5XX|${range(100, 600).join('|')})$`)),
+    canSupportSpecificationExtensions: true
+  },
+  init() {
+    this.element = new ResponsesElement();
+  },
+  methods: {
+    ObjectElement(objectElement) {
+      // @ts-ignore
+      const result = MixedFieldsVisitor.compose.methods.ObjectElement.call(this, objectElement);
+
+      // decorate every ReferenceElement with metadata about their referencing type
+      this.element.filter(isReferenceElement).forEach(referenceElement => {
+        referenceElement.setMetaProperty('referenced-element', 'response');
+      });
+
+      // decorate every ResponseElement with metadata about their status code
+      this.element.filter(isResponseElement).forEach((value, key) => {
+        const httpStatusCode = cloneDeep(key);
+        if (!this.fieldPatternPredicate(toValue(httpStatusCode))) return;
+        value.setMetaProperty('http-status-code', httpStatusCode);
+      });
+      return result;
+    }
+  }
+});
+export default ResponsesVisitor;

package/es/refractor/visitors/open-api-2/responses-definitions/index.mjs

@@ -0,0 +1,14 @@
+import stampit from 'stampit';
+import { always } from 'ramda';
+import ResponsesDefinitionsElement from "../../../../elements/ResponsesDefinitions.mjs";
+import MapVisitor from "../../generics/MapVisitor.mjs";
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+const ResponsesDefinitionsVisitor = stampit(MapVisitor, FallbackVisitor, {
+  props: {
+    specPath: always(['document', 'objects', 'Response'])
+  },
+  init() {
+    this.element = new ResponsesDefinitionsElement();
+  }
+});
+export default ResponsesDefinitionsVisitor;

package/es/refractor/visitors/open-api-2/schema/AllOfVisitor.mjs

@@ -0,0 +1,18 @@
+import stampit from 'stampit';
+import { specificationObj as JSONSchemaDraft4Specification, isJSONReferenceElement } from '@swagger-api/apidom-ns-json-schema-draft-4';
+const {
+  allOf: JSONSchemaAllOfVisitor
+} = JSONSchemaDraft4Specification.visitors.document.objects.JSONSchema.fixedFields;
+const AllOfVisitor = stampit(JSONSchemaAllOfVisitor, {
+  methods: {
+    ArrayElement(arrayElement) {
+      // @ts-ignore
+      const result = JSONSchemaAllOfVisitor.compose.methods.ArrayElement.call(this, arrayElement);
+      this.element.filter(isJSONReferenceElement).forEach(referenceElement => {
+        referenceElement.setMetaProperty('referenced-element', 'schema');
+      });
+      return result;
+    }
+  }
+});
+export default AllOfVisitor;

package/es/refractor/visitors/open-api-2/schema/ItemsVisitor.mjs

@@ -0,0 +1,26 @@
+import stampit from 'stampit';
+import { specificationObj as JSONSchemaDraft4Specification, isJSONReferenceElement } from '@swagger-api/apidom-ns-json-schema-draft-4';
+const {
+  items: JSONSchemaItemsVisitor
+} = JSONSchemaDraft4Specification.visitors.document.objects.JSONSchema.fixedFields;
+const ItemsVisitor = stampit(JSONSchemaItemsVisitor, {
+  methods: {
+    ObjectElement(objectElement) {
+      // @ts-ignore
+      const result = JSONSchemaItemsVisitor.compose.methods.ObjectElement.call(this, objectElement);
+      if (isJSONReferenceElement(this.element)) {
+        this.element.setMetaProperty('referenced-element', 'schema');
+      }
+      return result;
+    },
+    ArrayElement(arrayElement) {
+      // @ts-ignore
+      const result = JSONSchemaItemsVisitor.compose.methods.ArrayElement.call(this, arrayElement);
+      this.element.filter(isJSONReferenceElement).forEach(referenceElement => {
+        referenceElement.setMetaProperty('referenced-element', 'schema');
+      });
+      return result;
+    }
+  }
+});
+export default ItemsVisitor;

package/es/refractor/visitors/open-api-2/schema/PropertiesVisitor.mjs

@@ -0,0 +1,18 @@
+import stampit from 'stampit';
+import { specificationObj as JSONSchemaDraft4Specification, isJSONReferenceElement } from '@swagger-api/apidom-ns-json-schema-draft-4';
+const {
+  properties: JSONSchemaPropertiesVisitor
+} = JSONSchemaDraft4Specification.visitors.document.objects.JSONSchema.fixedFields;
+const PropertiesVisitor = stampit(JSONSchemaPropertiesVisitor, {
+  methods: {
+    ObjectElement(objectElement) {
+      // @ts-ignore
+      const result = JSONSchemaPropertiesVisitor.compose.methods.ObjectElement.call(this, objectElement);
+      this.element.filter(isJSONReferenceElement).forEach(referenceElement => {
+        referenceElement.setMetaProperty('referenced-element', 'schema');
+      });
+      return result;
+    }
+  }
+});
+export default PropertiesVisitor;

package/es/refractor/visitors/open-api-2/schema/SchemaOrJSONReferenceVisitor.mjs

@@ -0,0 +1,18 @@
+import stampit from 'stampit';
+import { specificationObj as JSONSchemaDraft4Specification, isJSONReferenceElement } from '@swagger-api/apidom-ns-json-schema-draft-4';
+const {
+  JSONSchemaOrJSONReferenceVisitor
+} = JSONSchemaDraft4Specification.visitors;
+const SchemaOrJSONReferenceVisitor = stampit(JSONSchemaOrJSONReferenceVisitor, {
+  methods: {
+    ObjectElement(objectElement) {
+      // @ts-ignore
+      const result = JSONSchemaOrJSONReferenceVisitor.compose.methods.enter.call(this, objectElement);
+      if (isJSONReferenceElement(this.element)) {
+        this.element.setMetaProperty('referenced-element', 'schema');
+      }
+      return result;
+    }
+  }
+});
+export default SchemaOrJSONReferenceVisitor;

package/es/refractor/visitors/open-api-2/schema/index.mjs

@@ -0,0 +1,15 @@
+import stampit from 'stampit';
+import { always } from 'ramda';
+import SchemaElement from "../../../../elements/Schema.mjs";
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+import FixedFieldsVisitor from "../../generics/FixedFieldsVisitor.mjs";
+const SchemaVisitor = stampit(FixedFieldsVisitor, FallbackVisitor, {
+  props: {
+    specPath: always(['document', 'objects', 'Schema']),
+    canSupportSpecificationExtensions: true
+  },
+  init() {
+    this.element = new SchemaElement();
+  }
+});
+export default SchemaVisitor;

package/es/refractor/visitors/open-api-2/scopes/index.mjs

@@ -0,0 +1,15 @@
+import stampit from 'stampit';
+import { always } from 'ramda';
+import ScopesElement from "../../../../elements/Scopes.mjs";
+import MapVisitor from "../../generics/MapVisitor.mjs";
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+const ScopesVisitor = stampit(MapVisitor, FallbackVisitor, {
+  props: {
+    specPath: always(['value']),
+    canSupportSpecificationExtensions: true
+  },
+  init() {
+    this.element = new ScopesElement();
+  }
+});
+export default ScopesVisitor;

package/es/refractor/visitors/open-api-2/security-definitions/index.mjs

@@ -0,0 +1,14 @@
+import stampit from 'stampit';
+import { always } from 'ramda';
+import SecurityDefinitionsElement from "../../../../elements/SecurityDefinitions.mjs";
+import MapVisitor from "../../generics/MapVisitor.mjs";
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+const SecurityDefinitionsVisitor = stampit(MapVisitor, FallbackVisitor, {
+  props: {
+    specPath: always(['document', 'objects', 'SecurityScheme'])
+  },
+  init() {
+    this.element = new SecurityDefinitionsElement();
+  }
+});
+export default SecurityDefinitionsVisitor;

package/es/refractor/visitors/open-api-2/security-requirement/index.mjs

@@ -0,0 +1,14 @@
+import stampit from 'stampit';
+import { always } from 'ramda';
+import SecurityRequirementElement from "../../../../elements/SecurityRequirement.mjs";
+import MapVisitor from "../../generics/MapVisitor.mjs";
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+const SecurityRequirementVisitor = stampit(MapVisitor, FallbackVisitor, {
+  props: {
+    specPath: always(['value'])
+  },
+  init() {
+    this.element = new SecurityRequirementElement();
+  }
+});
+export default SecurityRequirementVisitor;

package/es/refractor/visitors/open-api-2/security-scheme/index.mjs

@@ -0,0 +1,15 @@
+import stampit from 'stampit';
+import { always } from 'ramda';
+import SecuritySchemeElement from "../../../../elements/SecurityScheme.mjs";
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+import FixedFieldsVisitor from "../../generics/FixedFieldsVisitor.mjs";
+const SecuritySchemeVisitor = stampit(FixedFieldsVisitor, FallbackVisitor, {
+  props: {
+    specPath: always(['document', 'objects', 'SecurityScheme']),
+    canSupportSpecificationExtensions: true
+  },
+  init() {
+    this.element = new SecuritySchemeElement();
+  }
+});
+export default SecuritySchemeVisitor;

package/es/refractor/visitors/open-api-2/tag/index.mjs

@@ -0,0 +1,15 @@
+import stampit from 'stampit';
+import { always } from 'ramda';
+import TagElement from "../../../../elements/Tag.mjs";
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+import FixedFieldsVisitor from "../../generics/FixedFieldsVisitor.mjs";
+const TagVisitor = stampit(FixedFieldsVisitor, FallbackVisitor, {
+  props: {
+    specPath: always(['document', 'objects', 'Tag']),
+    canSupportSpecificationExtensions: true
+  },
+  init() {
+    this.element = new TagElement();
+  }
+});
+export default TagVisitor;

package/es/refractor/visitors/open-api-2/xml/index.mjs

@@ -0,0 +1,15 @@
+import stampit from 'stampit';
+import { always } from 'ramda';
+import XmlElement from "../../../../elements/Xml.mjs";
+import FallbackVisitor from "../../FallbackVisitor.mjs";
+import FixedFieldsVisitor from "../../generics/FixedFieldsVisitor.mjs";
+const XmlVisitor = stampit(FixedFieldsVisitor, FallbackVisitor, {
+  props: {
+    specPath: always(['document', 'objects', 'XML']),
+    canSupportSpecificationExtensions: true
+  },
+  init() {
+    this.element = new XmlElement();
+  }
+});
+export default XmlVisitor;

package/es/traversal/visitor.mjs

@@ -0,0 +1,50 @@
+import { keyMap as keyMapBase, isElement } from '@swagger-api/apidom-core';
+
+// getNodeType :: Node -> String
+export const getNodeType = element => {
+  if (!isElement(element)) {
+    return undefined;
+  }
+  return `${element.element.charAt(0).toUpperCase() + element.element.slice(1)}Element`;
+};
+
+/**
+ * There are unfortunately two `LinkElement` types. One is from base namespace
+ * and the other one if from this namespace. `LinkElement` from base namespace
+ * is used extremely rarely, so it's almost always safe during traversing
+ * to assume that `LinkElement` is element from this namespace.
+ *
+ * To be 100% sure that currently visiting `LinkElement` is from this namespace
+ * use `isLinkElement` predicate from this namespace to assert for it.
+ */
+
+export const keyMap = {
+  SwaggerElement: ['content'],
+  InfoElement: ['content'],
+  ContactElement: ['content'],
+  LicenseElement: ['content'],
+  PathsElement: ['content'],
+  PathItemElement: ['content'],
+  OperationElement: ['content'],
+  ExternalDocumentationElement: ['content'],
+  ParameterElement: ['content'],
+  ItemsElement: ['content'],
+  ExampleElement: ['content'],
+  ResponsesElement: ['content'],
+  ResponseElement: ['content'],
+  HeadersElement: ['content'],
+  HeaderElement: ['content'],
+  TagElement: ['content'],
+  ReferenceElement: ['content'],
+  JSONReferenceElement: ['content'],
+  SchemaElement: ['content'],
+  XmlElement: ['content'],
+  DefinitionsElement: ['content'],
+  ParametersDefinitionsElement: ['content'],
+  ResponsesDefinitionsElement: ['content'],
+  SecurityDefinitionsElement: ['content'],
+  SecuritySchemeElement: ['content'],
+  ScopesElement: ['content'],
+  SecurityRequirementElement: ['content'],
+  ...keyMapBase
+};

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@swagger-api/apidom-ns-openapi-2",
+  "version": "0.79.0",
+  "description": "OpenAPI 2.0 namespace for ApiDOM.",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "type": "module",
+  "sideEffects": [
+    "./es/refractor/registration.mjs",
+    "./cjs/refractor/registration.cjs"
+  ],
+  "unpkg": "./dist/apidom-ns-openapi-2.browser.min.js",
+  "main": "./cjs/index.cjs",
+  "exports": {
+    "types": "./types/dist.d.ts",
+    "import": "./es/index.mjs",
+    "require": "./cjs/index.cjs"
+  },
+  "types": "./types/dist.d.ts",
+  "scripts": {
+    "build": "npm run clean && run-p --max-parallel ${CPU_CORES:-2} typescript:declaration build:es build:cjs build:umd:browser",
+    "build:es": "cross-env BABEL_ENV=es babel src --out-dir es --extensions '.ts' --out-file-extension '.mjs' --root-mode 'upward'",
+    "build:cjs": "cross-env BABEL_ENV=cjs babel src --out-dir cjs --extensions '.ts' --out-file-extension '.cjs' --root-mode 'upward'",
+    "build:umd:browser": "cross-env BABEL_ENV=browser webpack --config config/webpack/browser.config.js --progress",
+    "lint": "eslint ./",
+    "lint:fix": "eslint ./ --fix",
+    "clean": "rimraf ./es ./cjs ./dist ./types",
+    "test": "cross-env NODE_ENV=test BABEL_ENV=cjs mocha",
+    "test:update-snapshots": "cross-env UPDATE_SNAPSHOT=1 BABEL_ENV=cjs mocha",
+    "typescript:check-types": "tsc --noEmit",
+    "typescript:declaration": "tsc -p declaration.tsconfig.json && rollup -c config/rollup/types.dist.js",
+    "prepack": "copyfiles -u 3 ../../LICENSES/* LICENSES && copyfiles -u 2 ../../NOTICE .",
+    "postpack": "rimraf NOTICE LICENSES"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/swagger-api/apidom.git"
+  },
+  "author": "Vladimir Gorej",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@babel/runtime-corejs3": "^7.20.7",
+    "@swagger-api/apidom-core": "^0.79.0",
+    "@swagger-api/apidom-error": "^0.79.0",
+    "@swagger-api/apidom-ns-json-schema-draft-4": "^0.79.0",
+    "@types/ramda": "~0.29.6",
+    "ramda": "~0.29.0",
+    "ramda-adjunct": "^4.1.1",
+    "stampit": "^4.3.2"
+  },
+  "files": [
+    "cjs/",
+    "dist/",
+    "es/",
+    "types/dist.d.ts",
+    "LICENSES",
+    "NOTICE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "gitHead": "8f93ee46d79e57833709f548fa6634f7e62d0aec"
+}