@atlaspack/utils 2.16.2-noselfbuild-3f2849b52.0 → 2.16.2-noselfbuild-8c516162e.0

package/lib/schema.js

@@ -0,0 +1,336 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.fuzzySearch = fuzzySearch;
+function _diagnostic() {
+  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function levenshtein() {
+  const data = _interopRequireWildcard(require("fastest-levenshtein"));
+  levenshtein = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function validateSchema(schema, data) {
+  function walk(schemaAncestors, dataNode, dataPath) {
+    let [schemaNode] = schemaAncestors;
+    if (schemaNode.type) {
+      let type = Array.isArray(dataNode) ? 'array' : typeof dataNode;
+      if (schemaNode.type !== type) {
+        return {
+          type: 'type',
+          dataType: 'value',
+          dataPath,
+          expectedTypes: [schemaNode.type],
+          ancestors: schemaAncestors,
+          prettyType: schemaNode.__type
+        };
+      } else {
+        switch (schemaNode.type) {
+          case 'array':
+            {
+              if (schemaNode.items) {
+                let results = [];
+                // $FlowFixMe type was already checked
+                for (let i = 0; i < dataNode.length; i++) {
+                  let result = walk([schemaNode.items].concat(schemaAncestors),
+                  // $FlowFixMe type was already checked
+                  dataNode[i], dataPath + '/' + i);
+                  if (result) results.push(result);
+                }
+                if (results.length) return results.reduce((acc, v) => acc.concat(v), []);
+              }
+              break;
+            }
+          case 'string':
+            {
+              // $FlowFixMe type was already checked
+              let value = dataNode;
+              if (schemaNode.enum) {
+                if (!schemaNode.enum.includes(value)) {
+                  return {
+                    type: 'enum',
+                    dataType: 'value',
+                    dataPath,
+                    expectedValues: schemaNode.enum,
+                    actualValue: value,
+                    ancestors: schemaAncestors
+                  };
+                }
+              } else if (schemaNode.__validate) {
+                let validationError = schemaNode.__validate(value);
+                if (typeof validationError == 'string') {
+                  return {
+                    type: 'other',
+                    dataType: 'value',
+                    dataPath,
+                    message: validationError,
+                    actualValue: value,
+                    ancestors: schemaAncestors
+                  };
+                }
+              }
+              break;
+            }
+          case 'number':
+            {
+              // $FlowFixMe type was already checked
+              let value = dataNode;
+              if (schemaNode.enum) {
+                if (!schemaNode.enum.includes(value)) {
+                  return {
+                    type: 'enum',
+                    dataType: 'value',
+                    dataPath,
+                    expectedValues: schemaNode.enum,
+                    actualValue: value,
+                    ancestors: schemaAncestors
+                  };
+                }
+              }
+              break;
+            }
+          case 'object':
+            {
+              let results = [];
+              let invalidProps;
+              if (schemaNode.__forbiddenProperties) {
+                // $FlowFixMe type was already checked
+                let keys = Object.keys(dataNode);
+                invalidProps = schemaNode.__forbiddenProperties.filter(val => keys.includes(val));
+                results.push(...invalidProps.map(k => ({
+                  type: 'forbidden-prop',
+                  dataPath: dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k),
+                  dataType: 'key',
+                  prop: k,
+                  expectedProps: Object.keys(schemaNode.properties),
+                  actualProps: keys,
+                  ancestors: schemaAncestors
+                })));
+              }
+              if (schemaNode.required) {
+                // $FlowFixMe type was already checked
+                let keys = Object.keys(dataNode);
+                let missingKeys = schemaNode.required.filter(val => !keys.includes(val));
+                results.push(...missingKeys.map(k => ({
+                  type: 'missing-prop',
+                  dataPath,
+                  dataType: 'value',
+                  prop: k,
+                  expectedProps: schemaNode.required,
+                  actualProps: keys,
+                  ancestors: schemaAncestors
+                })));
+              }
+              if (schemaNode.properties) {
+                let {
+                  additionalProperties = true
+                } = schemaNode;
+                // $FlowFixMe type was already checked
+                for (let k in dataNode) {
+                  if (invalidProps && invalidProps.includes(k)) {
+                    // Don't check type on forbidden props
+                    continue;
+                  } else if (k in schemaNode.properties) {
+                    let result = walk([schemaNode.properties[k]].concat(schemaAncestors),
+                    // $FlowFixMe type was already checked
+                    dataNode[k], dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k));
+                    if (result) results.push(result);
+                  } else {
+                    if (typeof additionalProperties === 'boolean') {
+                      if (!additionalProperties) {
+                        results.push({
+                          type: 'enum',
+                          dataType: 'key',
+                          dataPath: dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k),
+                          expectedValues: Object.keys(schemaNode.properties).filter(
+                          // $FlowFixMe type was already checked
+                          p => !(p in dataNode)),
+                          actualValue: k,
+                          ancestors: schemaAncestors,
+                          prettyType: schemaNode.__type
+                        });
+                      }
+                    } else {
+                      let result = walk([additionalProperties].concat(schemaAncestors),
+                      // $FlowFixMe type was already checked
+                      dataNode[k], dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k));
+                      if (result) results.push(result);
+                    }
+                  }
+                }
+              }
+              if (results.length) return results.reduce((acc, v) => acc.concat(v), []);
+              break;
+            }
+          case 'boolean':
+            // NOOP, type was checked already
+            break;
+          default:
+            throw new Error(`Unimplemented schema type ${type}?`);
+        }
+      }
+    } else {
+      if (schemaNode.enum && !schemaNode.enum.includes(dataNode)) {
+        return {
+          type: 'enum',
+          dataType: 'value',
+          dataPath: dataPath,
+          expectedValues: schemaNode.enum,
+          actualValue: schemaNode,
+          ancestors: schemaAncestors
+        };
+      }
+      if (schemaNode.oneOf || schemaNode.allOf) {
+        let list = schemaNode.oneOf || schemaNode.allOf;
+        let results = [];
+        for (let f of list) {
+          let result = walk([f].concat(schemaAncestors), dataNode, dataPath);
+          if (result) results.push(result);
+        }
+        if (schemaNode.oneOf ? results.length == schemaNode.oneOf.length : results.length > 0) {
+          // return the result with more values / longer key
+          results.sort((a, b) => Array.isArray(a) || Array.isArray(b) ? Array.isArray(a) && !Array.isArray(b) ? -1 : !Array.isArray(a) && Array.isArray(b) ? 1 : Array.isArray(a) && Array.isArray(b) ? b.length - a.length : 0 : b.dataPath.length - a.dataPath.length);
+          return results[0];
+        }
+      } else if (schemaNode.not) {
+        let result = walk([schemaNode.not].concat(schemaAncestors), dataNode, dataPath);
+        if (!result || result.length == 0) {
+          return {
+            type: 'other',
+            dataPath,
+            dataType: null,
+            message: schemaNode.__message,
+            actualValue: dataNode,
+            ancestors: schemaAncestors
+          };
+        }
+      }
+    }
+    return undefined;
+  }
+  let result = walk([schema], data, '');
+  return Array.isArray(result) ? result : result ? [result] : [];
+}
+var _default = exports.default = validateSchema;
+function fuzzySearch(expectedValues, actualValue) {
+  let result = expectedValues.map(exp => [exp, levenshtein().distance(exp, actualValue)]).filter(
+  // Remove if more than half of the string would need to be changed
+  ([, d]) => d * 2 < actualValue.length);
+  result.sort(([, a], [, b]) => a - b);
+  return result.map(([v]) => v);
+}
+validateSchema.diagnostic = function (schema, data, origin, message) {
+  if ('source' in data && 'data' in data && typeof data.source !== 'string' && !data) {
+    throw new Error('At least one of data.source and data.data must be defined!');
+  }
+  let object = data.map ? data.map.data :
+  // $FlowFixMe we can assume it's a JSON object
+  data.data ?? JSON.parse(data.source);
+  let errors = validateSchema(schema, object);
+  if (errors.length) {
+    let keys = errors.map(e => {
+      let message;
+      if (e.type === 'enum') {
+        let {
+          actualValue
+        } = e;
+        let expectedValues = e.expectedValues.map(String);
+        let likely = actualValue != null ? fuzzySearch(expectedValues, String(actualValue)) : [];
+        if (likely.length > 0) {
+          message = `Did you mean ${likely.map(v => JSON.stringify(v)).join(', ')}?`;
+        } else if (expectedValues.length > 0) {
+          message = `Possible values: ${expectedValues.map(v => JSON.stringify(v)).join(', ')}`;
+        } else {
+          message = 'Unexpected value';
+        }
+      } else if (e.type === 'forbidden-prop') {
+        let {
+          prop,
+          expectedProps,
+          actualProps
+        } = e;
+        let likely = fuzzySearch(expectedProps, prop).filter(v => !actualProps.includes(v));
+        if (likely.length > 0) {
+          message = `Did you mean ${likely.map(v => JSON.stringify(v)).join(', ')}?`;
+        } else {
+          message = 'Unexpected property';
+        }
+      } else if (e.type === 'missing-prop') {
+        let {
+          prop,
+          actualProps
+        } = e;
+        let likely = fuzzySearch(actualProps, prop);
+        if (likely.length > 0) {
+          message = `Did you mean ${JSON.stringify(prop)}?`;
+          e.dataPath += '/' + likely[0];
+          e.dataType = 'key';
+        } else {
+          message = `Missing property ${prop}`;
+        }
+      } else if (e.type === 'type') {
+        if (e.prettyType != null) {
+          message = `Expected ${e.prettyType}`;
+        } else {
+          message = `Expected type ${e.expectedTypes.join(', ')}`;
+        }
+      } else {
+        message = e.message;
+      }
+      return {
+        key: e.dataPath,
+        type: e.dataType,
+        message
+      };
+    });
+    let map, code;
+    if (data.map) {
+      map = data.map;
+      code = data.source;
+    } else {
+      // $FlowFixMe we can assume that data is valid JSON
+      map = data.source ?? JSON.stringify((0, _nullthrows().default)(data.data), 0, '\t');
+      code = map;
+    }
+    let codeFrames = [{
+      filePath: data.filePath ?? undefined,
+      language: 'json',
+      code,
+      codeHighlights: (0, _diagnostic().generateJSONCodeHighlights)(map, keys.map(({
+        key,
+        type,
+        message
+      }) => ({
+        key: (data.prependKey ?? '') + key,
+        type: type,
+        message: message != null ? (0, _diagnostic().escapeMarkdown)(message) : message
+      })))
+    }];
+    throw new (_diagnostic().default)({
+      diagnostic: {
+        message: message,
+        origin,
+        codeFrames
+      }
+    });
+  }
+};

package/lib/shared-buffer.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SharedBuffer = void 0;
+let SharedBuffer = exports.SharedBuffer = void 0;
+
+// $FlowFixMe[prop-missing]
+if (process.browser) {
+  exports.SharedBuffer = SharedBuffer = ArrayBuffer;
+  // Safari has removed the constructor
+  if (typeof SharedArrayBuffer !== 'undefined') {
+    let channel = new MessageChannel();
+    try {
+      // Firefox might throw when sending the Buffer over a MessagePort
+      channel.port1.postMessage(new SharedArrayBuffer(0));
+      exports.SharedBuffer = SharedBuffer = SharedArrayBuffer;
+    } catch (_) {
+      // NOOP
+    }
+    channel.port1.close();
+    channel.port2.close();
+  }
+} else {
+  exports.SharedBuffer = SharedBuffer = SharedArrayBuffer;
+}

package/lib/sourcemap.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SOURCEMAP_RE = exports.SOURCEMAP_EXTENSIONS = void 0;
+exports.loadSourceMap = loadSourceMap;
+exports.loadSourceMapUrl = loadSourceMapUrl;
+exports.matchSourceMappingURL = matchSourceMappingURL;
+exports.remapSourceLocation = remapSourceLocation;
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@parcel/source-map"));
+  _sourceMap = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+var _path2 = require("./path");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const SOURCEMAP_RE = exports.SOURCEMAP_RE = /(?:\/\*|\/\/)\s*[@#]\s*sourceMappingURL\s*=\s*([^\s*]+)(?:\s*\*\/)?\s*$/;
+const DATA_URL_RE = /^data:[^;]+(?:;charset=[^;]+)?;base64,(.*)/;
+const SOURCEMAP_EXTENSIONS = exports.SOURCEMAP_EXTENSIONS = new Set(['css', 'es', 'es6', 'js', 'jsx', 'mjs', 'ts', 'tsx']);
+function matchSourceMappingURL(contents) {
+  return contents.match(SOURCEMAP_RE);
+}
+async function loadSourceMapUrl(fs, filename, contents) {
+  let match = matchSourceMappingURL(contents);
+  if (match) {
+    let url = match[1].trim();
+    let dataURLMatch = url.match(DATA_URL_RE);
+    let mapFilePath;
+    if (dataURLMatch) {
+      mapFilePath = filename;
+    } else {
+      mapFilePath = url.replace(/^file:\/\//, '');
+      mapFilePath = (0, _path2.isAbsolute)(mapFilePath) ? mapFilePath : _path().default.join(_path().default.dirname(filename), mapFilePath);
+    }
+    return {
+      url,
+      filename: mapFilePath,
+      map: JSON.parse(dataURLMatch ? Buffer.from(dataURLMatch[1], 'base64').toString() : await fs.readFile(mapFilePath, 'utf8'))
+    };
+  }
+}
+async function loadSourceMap(filename, contents, options) {
+  let foundMap = await loadSourceMapUrl(options.fs, filename, contents);
+  if (foundMap) {
+    let mapSourceRoot = _path().default.dirname(filename);
+    if (foundMap.map.sourceRoot && !(0, _path2.normalizeSeparators)(foundMap.map.sourceRoot).startsWith('/')) {
+      mapSourceRoot = _path().default.join(mapSourceRoot, foundMap.map.sourceRoot);
+    }
+    let sourcemapInstance = new (_sourceMap().default)(options.projectRoot);
+    sourcemapInstance.addVLQMap({
+      ...foundMap.map,
+      sources: foundMap.map.sources.map(s => {
+        return _path().default.join(mapSourceRoot, s);
+      })
+    });
+    return sourcemapInstance;
+  }
+}
+function remapSourceLocation(loc, originalMap) {
+  let {
+    filePath,
+    start: {
+      line: startLine,
+      column: startCol
+    },
+    end: {
+      line: endLine,
+      column: endCol
+    }
+  } = loc;
+  let lineDiff = endLine - startLine;
+  let colDiff = endCol - startCol;
+  let start = originalMap.findClosestMapping(startLine, startCol - 1);
+  let end = originalMap.findClosestMapping(endLine, endCol - 1);
+  if (start !== null && start !== void 0 && start.original) {
+    if (start.source) {
+      filePath = start.source;
+    }
+    ({
+      line: startLine,
+      column: startCol
+    } = start.original);
+    startCol++; // source map columns are 0-based
+  }
+
+  if (end !== null && end !== void 0 && end.original) {
+    ({
+      line: endLine,
+      column: endCol
+    } = end.original);
+    endCol++; // source map columns are 0-based
+
+    if (endLine < startLine) {
+      endLine = startLine;
+      endCol = startCol;
+    } else if (endLine === startLine && endCol < startCol && lineDiff === 0) {
+      endCol = startCol + colDiff;
+    } else if (endLine === startLine && startCol === endCol && lineDiff === 0) {
+      // Prevent 0-length ranges
+      endCol = startCol + 1;
+    }
+  } else {
+    endLine = startLine;
+    endCol = startCol;
+  }
+  return {
+    filePath,
+    start: {
+      line: startLine,
+      column: startCol
+    },
+    end: {
+      line: endLine,
+      column: endCol
+    }
+  };
+}

package/lib/stream.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.blobToStream = blobToStream;
+exports.bufferStream = bufferStream;
+exports.fallbackStream = fallbackStream;
+exports.measureStreamLength = measureStreamLength;
+exports.readableFromStringOrBuffer = readableFromStringOrBuffer;
+exports.streamFromPromise = streamFromPromise;
+function _stream() {
+  const data = require("stream");
+  _stream = function () {
+    return data;
+  };
+  return data;
+}
+function measureStreamLength(stream) {
+  return new Promise((resolve, reject) => {
+    let length = 0;
+    stream.on('data', chunk => {
+      length += chunk;
+    });
+    stream.on('end', () => resolve(length));
+    stream.on('error', reject);
+  });
+}
+function readableFromStringOrBuffer(str) {
+  // https://stackoverflow.com/questions/12755997/how-to-create-streams-from-string-in-node-js
+  const stream = new (_stream().Readable)();
+  stream.push(str);
+  stream.push(null);
+  return stream;
+}
+function bufferStream(stream) {
+  return new Promise((resolve, reject) => {
+    let buf = Buffer.from([]);
+    stream.on('data', data => {
+      buf = Buffer.concat([buf, data]);
+    });
+    stream.on('end', () => {
+      resolve(buf);
+    });
+    stream.on('error', reject);
+  });
+}
+function blobToStream(blob) {
+  if (blob instanceof _stream().Readable) {
+    return blob;
+  }
+  return readableFromStringOrBuffer(blob);
+}
+function streamFromPromise(promise) {
+  const stream = new (_stream().PassThrough)();
+  promise.then(blob => {
+    if (blob instanceof _stream().Readable) {
+      blob.pipe(stream);
+    } else {
+      stream.end(blob);
+    }
+  });
+  return stream;
+}
+function fallbackStream(stream, fallback) {
+  const res = new (_stream().PassThrough)();
+  stream.on('error', err => {
+    if (err.code === 'ENOENT') {
+      fallback().pipe(res);
+    } else {
+      res.emit('error', err);
+    }
+  });
+  stream.pipe(res);
+  return res;
+}

package/lib/throttle.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = throttle;
+function throttle(fn, delay) {
+  let lastCalled;
+  return function throttled(...args) {
+    if (lastCalled == null || lastCalled + delay <= Date.now()) {
+      fn.call(this, ...args);
+      lastCalled = Date.now();
+    }
+  };
+}

package/lib/urlJoin.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = urlJoin;
+function _url() {
+  const data = _interopRequireDefault(require("url"));
+  _url = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Joins a path onto a URL, and normalizes Windows paths
+ * e.g. from \path\to\res.js to /path/to/res.js.
+ */
+function urlJoin(publicURL, assetPath) {
+  const url = _url().default.parse(publicURL, false, true);
+  // Leading / ensures that paths with colons are not parsed as a protocol.
+  let p = assetPath.startsWith('/') ? assetPath : '/' + assetPath;
+  const assetUrl = _url().default.parse(p);
+  url.pathname = _path().default.posix.join(url.pathname, assetUrl.pathname);
+  url.search = assetUrl.search;
+  url.hash = assetUrl.hash;
+  return _url().default.format(url);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/utils",
-  "version": "2.16.2-noselfbuild-3f2849b52.0",
+  "version": "2.16.2-noselfbuild-8c516162e.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -30,21 +30,16 @@
     }
   },
   "dependencies": {
-    "@atlaspack/codeframe": "2.13.4-noselfbuild-3f2849b52.0",
-    "@atlaspack/diagnostic": "2.14.2-noselfbuild-3f2849b52.0",
-    "@atlaspack/feature-flags": "2.18.5-noselfbuild-3f2849b52.0",
-    "@atlaspack/logger": "2.14.13-noselfbuild-3f2849b52.0",
-    "@atlaspack/markdown-ansi": "2.14.2-noselfbuild-3f2849b52.0",
-    "@atlaspack/rust": "3.4.1-noselfbuild-3f2849b52.0",
-    "@parcel/source-map": "^2.1.1",
-    "chalk": "^4.1.0",
-    "nullthrows": "^1.1.1"
-  },
-  "devDependencies": {
-    "@atlaspack/babel-register": "2.14.2-noselfbuild-3f2849b52.0",
+    "@atlaspack/codeframe": "2.13.4-noselfbuild-8c516162e.0",
+    "@atlaspack/diagnostic": "2.14.2-noselfbuild-8c516162e.0",
+    "@atlaspack/feature-flags": "2.18.5-noselfbuild-8c516162e.0",
+    "@atlaspack/logger": "2.14.13-noselfbuild-8c516162e.0",
+    "@atlaspack/markdown-ansi": "2.14.2-noselfbuild-8c516162e.0",
+    "@atlaspack/rust": "3.4.1-noselfbuild-8c516162e.0",
     "@iarna/toml": "^2.2.0",
+    "@parcel/source-map": "^2.1.1",
     "ansi-html-community": "0.0.8",
-    "benny": "^3.7.1",
+    "chalk": "^4.1.0",
     "clone": "^2.1.1",
     "fast-glob": "^3.2.12",
     "fastest-levenshtein": "^1.0.16",
@@ -56,11 +51,15 @@
     "node-forge": "^1.2.1",
     "nullthrows": "^1.1.1",
     "open": "^7.0.3",
-    "random-int": "^1.0.0",
     "snarkdown": "^2.0.0",
     "strip-ansi": "^6.0.0",
     "terminal-link": "^2.1.1"
   },
+  "devDependencies": {
+    "@atlaspack/babel-register": "2.14.2-noselfbuild-8c516162e.0",
+    "benny": "^3.7.1",
+    "random-int": "^1.0.0"
+  },
   "browser": {
     "./src/generateCertificate.js": false,
     "./src/http-server.js": false,
@@ -68,5 +67,5 @@
     "@atlaspack/markdown-ansi": false
   },
   "type": "commonjs",
-  "gitHead": "3f2849b52d0a62d716f1c6cb3a92656e1e4fa18a"
+  "gitHead": "8c516162e3109bbebe535130a7de57e9e59a4eb8"
 }