snyk
Version:
snyk library and cli utility
1,473 lines (1,358 loc) • 560 kB
JavaScript
exports.id = 231;
exports.ids = [231];
exports.modules = {
/***/ 42869:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
const json = __webpack_require__(29387);
const strings = __webpack_require__(13043);
const regex = __webpack_require__(13732);
const yaml = __webpack_require__(76050);
module.exports = {
...json,
...strings,
...regex,
...yaml,
};
/***/ }),
/***/ 29387:
/***/ ((module) => {
function isValidJSON(str) {
if (typeof str !== "string") {
return;
}
try {
JSON.parse(str);
return true;
} catch (err) {
if (err instanceof SyntaxError) {
return false;
}
throw err;
}
}
module.exports = {
"json.is_valid": isValidJSON,
};
/***/ }),
/***/ 13732:
/***/ ((module) => {
const regexSplit = (pattern, s) => s.split(RegExp(pattern));
module.exports = { "regex.split": regexSplit };
/***/ }),
/***/ 13043:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
const vsprintf = __webpack_require__(8975).vsprintf;
const sprintf = (s, values) => vsprintf(s, values);
module.exports = { sprintf };
/***/ }),
/***/ 76050:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
const yaml = __webpack_require__(6792);
// see: https://eemeli.org/yaml/v1/#errors
const errors = new Set([
"YAMLReferenceError",
"YAMLSemanticError",
"YAMLSyntaxError",
"YAMLWarning",
]);
function parse(str) {
if (typeof str !== "string") {
return { ok: false, result: undefined };
}
const YAML_SILENCE_WARNINGS_CACHED = global.YAML_SILENCE_WARNINGS;
try {
// see: https://eemeli.org/yaml/v1/#silencing-warnings
global.YAML_SILENCE_WARNINGS = true;
return { ok: true, result: yaml.parse(str) };
} catch (err) {
// Ignore parser errors.
if (err && errors.has(err.name)) {
return { ok: false, result: undefined };
}
throw err;
} finally {
global.YAML_SILENCE_WARNINGS = YAML_SILENCE_WARNINGS_CACHED;
}
}
module.exports = {
// is_valid is expected to return nothing if input is invalid otherwise
// true/false for it being valid YAML.
"yaml.is_valid": (str) => typeof str === "string" ? parse(str).ok : undefined,
"yaml.marshal": (data) => yaml.stringify(data),
"yaml.unmarshal": (str) => parse(str).result,
};
/***/ }),
/***/ 39026:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
// Copyright 2018 The OPA Authors. All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
const builtIns = __webpack_require__(42869);
const util = __webpack_require__(73837);
// NOTE: The util shim here exists for Node 10.x and can be removed
// when dropping support. Browsers and Node >= 11.x use the global.
const TextEncoder = typeof global.TextEncoder !== "undefined"
? global.TextEncoder
: util.TextEncoder;
const TextDecoder = typeof global.TextDecoder !== "undefined"
? global.TextDecoder
: util.TextDecoder;
/**
* @param {WebAssembly.Memory} mem
*/
function stringDecoder(mem) {
return function (addr) {
const i8 = new Int8Array(mem.buffer);
let s = "";
while (i8[addr] !== 0) {
s += String.fromCharCode(i8[addr++]);
}
return s;
};
}
/**
* Stringifies and loads an object into OPA's Memory
* @param {WebAssembly.Instance} wasmInstance
* @param {WebAssembly.Memory} memory
* @param {any | ArrayBuffer} value data as `object`, literal primitive or ArrayBuffer (last is assumed to be a well-formed stringified JSON)
* @returns {number}
*/
function _loadJSON(wasmInstance, memory, value) {
if (value === undefined) {
return 0;
}
let valueBuf;
if (value instanceof ArrayBuffer) {
valueBuf = new Uint8Array(value);
} else {
const valueAsText = JSON.stringify(value);
valueBuf = new TextEncoder().encode(valueAsText);
}
const valueBufLen = valueBuf.byteLength;
const rawAddr = wasmInstance.exports.opa_malloc(valueBufLen);
const memoryBuffer = new Uint8Array(memory.buffer);
memoryBuffer.set(valueBuf, rawAddr);
const parsedAddr = wasmInstance.exports.opa_json_parse(rawAddr, valueBufLen);
if (parsedAddr === 0) {
throw "failed to parse json value";
}
return parsedAddr;
}
/**
* Dumps and parses a JSON object from OPA's Memory
* @param {WebAssembly.Instance} wasmInstance
* @param {WebAssembly.Memory} memory
* @param {number} addr
* @returns {object}
*/
function _dumpJSON(wasmInstance, memory, addr) {
const rawAddr = wasmInstance.exports.opa_json_dump(addr);
return _dumpJSONRaw(memory, rawAddr);
}
/**
* Parses a JSON object from wasm instance's memory
* @param {WebAssembly.Memory} memory
* @param {number} addr
* @returns {object}
*/
function _dumpJSONRaw(memory, addr) {
const buf = new Uint8Array(memory.buffer);
let idx = addr;
while (buf[idx] !== 0) {
idx++;
}
const utf8View = new Uint8Array(memory.buffer, addr, idx - addr);
const jsonAsText = new TextDecoder().decode(utf8View);
return JSON.parse(jsonAsText);
}
const builtinFuncs = builtIns;
/**
* _builtinCall dispatches the built-in function. The built-in function
* arguments are loaded from Wasm and back in using JSON serialization.
* @param {WebAssembly.Instance} wasmInstance
* @param {WebAssembly.Memory} memory
* @param {{ [builtinId: number]: string }} builtins
* @param {string} builtin_id
*/
function _builtinCall(wasmInstance, memory, builtins, builtinId) {
const builtInName = builtins[builtinId];
const impl = builtinFuncs[builtInName];
if (impl === undefined) {
throw {
message: "not implemented: built-in function " +
builtinId +
": " +
builtins[builtinId],
};
}
const argArray = Array.prototype.slice.apply(arguments);
const args = [];
for (let i = 4; i < argArray.length; i++) {
const jsArg = _dumpJSON(wasmInstance, memory, argArray[i]);
args.push(jsArg);
}
const result = impl(...args);
return _loadJSON(wasmInstance, memory, result);
}
/**
* _loadPolicy can take in either an ArrayBuffer or WebAssembly.Module
* as its first argument, and a WebAssembly.Memory for the second parameter.
* It will return a Promise, depending on the input type the promise
* resolves to both a compiled WebAssembly.Module and its first WebAssembly.Instance
* or to the WebAssemblyInstance.
* @param {BufferSource | WebAssembly.Module} policyWasm
* @param {WebAssembly.Memory} memory
* @returns {Promise<{ policy: WebAssembly.WebAssemblyInstantiatedSource | WebAssembly.Instance, minorVersion: number }>}
*/
async function _loadPolicy(policyWasm, memory) {
const addr2string = stringDecoder(memory);
const env = {};
const wasm = await WebAssembly.instantiate(policyWasm, {
env: {
memory,
opa_abort: function (addr) {
throw addr2string(addr);
},
opa_println: function (addr) {
console.log(addr2string(addr));
},
opa_builtin0: function (builtinId, _ctx) {
return _builtinCall(env.instance, memory, env.builtins, builtinId);
},
opa_builtin1: function (builtinId, _ctx, arg1) {
return _builtinCall(
env.instance,
memory,
env.builtins,
builtinId,
arg1,
);
},
opa_builtin2: function (builtinId, _ctx, arg1, arg2) {
return _builtinCall(
env.instance,
memory,
env.builtins,
builtinId,
arg1,
arg2,
);
},
opa_builtin3: function (builtinId, _ctx, arg1, arg2, arg3) {
return _builtinCall(
env.instance,
memory,
env.builtins,
builtinId,
arg1,
arg2,
arg3,
);
},
opa_builtin4: function (builtinId, _ctx, arg1, arg2, arg3, arg4) {
return _builtinCall(
env.instance,
memory,
env.builtins,
builtinId,
arg1,
arg2,
arg3,
arg4,
);
},
},
});
// Note: On Node 10.x this value is a number on Node 12.x and up it is
// an object with numberic `value` property.
const abiVersionGlobal = wasm.instance.exports.opa_wasm_abi_version;
if (abiVersionGlobal !== undefined) {
const abiVersion = typeof abiVersionGlobal === "number"
? abiVersionGlobal
: abiVersionGlobal.value;
if (abiVersion !== 1) {
throw `unsupported ABI version ${abiVersion}`;
}
} else {
console.error("opa_wasm_abi_version undefined"); // logs to stderr
}
const abiMinorVersionGlobal =
wasm.instance.exports.opa_wasm_abi_minor_version;
let abiMinorVersion;
if (abiMinorVersionGlobal !== undefined) {
abiMinorVersion = typeof abiMinorVersionGlobal === "number"
? abiMinorVersionGlobal
: abiMinorVersionGlobal.value;
} else {
console.error("opa_wasm_abi_minor_version undefined");
}
env.instance = wasm.instance ? wasm.instance : wasm;
const builtins = _dumpJSON(
env.instance,
memory,
env.instance.exports.builtins(),
);
/** @type {typeof builtIns} */
env.builtins = {};
for (const key of Object.keys(builtins)) {
env.builtins[builtins[key]] = key;
}
return { policy: wasm, minorVersion: abiMinorVersion };
}
/**
* LoadedPolicy is a wrapper around a WebAssembly.Instance and WebAssembly.Memory
* for a compiled Rego policy. There are helpers to run the wasm instance and
* handle the output from the policy wasm.
*/
class LoadedPolicy {
/**
* Loads and initializes a compiled Rego policy.
* @param {WebAssembly.WebAssemblyInstantiatedSource} policy
* @param {WebAssembly.Memory} memory
*/
constructor(policy, memory, minorVersion) {
this.minorVersion = minorVersion;
this.mem = memory;
// Depending on how the wasm was instantiated "policy" might be a
// WebAssembly Instance or be a wrapper around the Module and
// Instance. We only care about the Instance.
this.wasmInstance = policy.instance ? policy.instance : policy;
this.dataAddr = _loadJSON(this.wasmInstance, this.mem, {});
this.baseHeapPtr = this.wasmInstance.exports.opa_heap_ptr_get();
this.dataHeapPtr = this.baseHeapPtr;
this.entrypoints = _dumpJSON(
this.wasmInstance,
this.mem,
this.wasmInstance.exports.entrypoints(),
);
}
/**
* Evaluates the loaded policy with the given input and
* return the result set. This should be re-used for multiple evaluations
* of the same policy with different inputs.
*
* To call a non-default entrypoint in your WASM specify it as the second
* param. A list of entrypoints can be accessed with the `this.entrypoints`
* property.
* @param {any | ArrayBuffer} input input to be evaluated in form of `object`, literal primitive or ArrayBuffer (last is assumed to be a well-formed stringified JSON)
* @param {number | string} entrypoint ID or name of the entrypoint to call (optional)
*/
evaluate(input, entrypoint = 0) {
// determine entrypoint ID
if (typeof entrypoint === "number") {
// used as-is
} else if (typeof entrypoint === "string") {
if (Object.prototype.hasOwnProperty.call(this.entrypoints, entrypoint)) {
entrypoint = this.entrypoints[entrypoint];
} else {
throw `entrypoint ${entrypoint} is not valid in this instance`;
}
} else {
throw `entrypoint value is an invalid type, must be either string or number`;
}
// ABI 1.2 fastpath
if (this.minorVersion >= 2) {
// write input into memory, adjust heap pointer
let inputBuf = null;
let inputLen = 0;
let inputAddr = 0;
if (input) {
if (input instanceof ArrayBuffer) {
inputBuf = new Uint8Array(input);
} else {
const inputAsText = JSON.stringify(input);
inputBuf = new TextEncoder().encode(inputAsText);
}
inputAddr = this.dataHeapPtr;
inputLen = inputBuf.byteLength;
const delta = inputAddr + inputLen - this.mem.buffer.byteLength;
if (delta > 0) {
const pages = roundup(delta);
this.mem.grow(pages);
}
const buf = new Uint8Array(this.mem.buffer);
buf.set(inputBuf, this.dataHeapPtr);
this.dataHeapPtr = inputAddr + inputLen;
}
const ret = this.wasmInstance.exports.opa_eval(
0,
entrypoint,
this.dataAddr,
inputAddr,
inputLen,
this.dataHeapPtr,
0,
);
return _dumpJSONRaw(this.mem, ret);
}
// Reset the heap pointer before each evaluation
this.wasmInstance.exports.opa_heap_ptr_set(this.dataHeapPtr);
// Load the input data
const inputAddr = _loadJSON(this.wasmInstance, this.mem, input);
// Setup the evaluation context
const ctxAddr = this.wasmInstance.exports.opa_eval_ctx_new();
this.wasmInstance.exports.opa_eval_ctx_set_input(ctxAddr, inputAddr);
this.wasmInstance.exports.opa_eval_ctx_set_data(ctxAddr, this.dataAddr);
this.wasmInstance.exports.opa_eval_ctx_set_entrypoint(ctxAddr, entrypoint);
// Actually evaluate the policy
this.wasmInstance.exports.eval(ctxAddr);
// Retrieve the result
const resultAddr = this.wasmInstance.exports.opa_eval_ctx_get_result(
ctxAddr,
);
return _dumpJSON(this.wasmInstance, this.mem, resultAddr);
}
/**
* evalBool will evaluate the policy and return a boolean answer
* depending on the return code from the policy evaluation.
* @deprecated Use `evaluate` instead.
* @param {object} input
*/
evalBool(input) {
const rs = this.evaluate(input);
return rs && rs.length === 1 && rs[0] === true;
}
/**
* Loads data for use in subsequent evaluations.
* @param {object | ArrayBuffer} data data in form of `object` or ArrayBuffer (last is assumed to be a well-formed stringified JSON)
*/
setData(data) {
this.wasmInstance.exports.opa_heap_ptr_set(this.baseHeapPtr);
this.dataAddr = _loadJSON(this.wasmInstance, this.mem, data);
this.dataHeapPtr = this.wasmInstance.exports.opa_heap_ptr_get();
}
}
function roundup(bytes) {
const pageSize = 64 * 1024;
return Math.ceil(bytes / pageSize);
}
module.exports = {
/**
* Takes in either an ArrayBuffer or WebAssembly.Module
* and will return a LoadedPolicy object which can be used to evaluate
* the policy.
*
* To set custom memory size specify number of memory pages
* as second param.
* Defaults to 5 pages (320KB).
* @param {BufferSource | WebAssembly.Module} regoWasm
* @param {number | WebAssembly.MemoryDescriptor} memoryDescriptor For backwards-compatibility, a 'number' argument is taken to be the initial memory size.
*/
async loadPolicy(regoWasm, memoryDescriptor = {}) {
// back-compat, second arg used to be a number: 'memorySize', with default of 5
if (typeof memoryDescriptor === "number") {
memoryDescriptor = { initial: memoryDescriptor };
}
memoryDescriptor.initial = memoryDescriptor.initial || 5;
const memory = new WebAssembly.Memory(memoryDescriptor);
const { policy, minorVersion } = await _loadPolicy(regoWasm, memory);
return new LoadedPolicy(policy, memory, minorVersion);
},
};
/***/ }),
/***/ 98611:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
var types_1 = __webpack_require__(60442);
Object.defineProperty(exports, "CloudConfigFileTypes", ({ enumerable: true, get: function () { return types_1.CloudConfigFileTypes; } }));
var issue_to_line_1 = __webpack_require__(76932);
Object.defineProperty(exports, "issuesToLineNumbers", ({ enumerable: true, get: function () { return issue_to_line_1.issuesToLineNumbers; } }));
Object.defineProperty(exports, "getTrees", ({ enumerable: true, get: function () { return issue_to_line_1.getTrees; } }));
Object.defineProperty(exports, "getLineNumber", ({ enumerable: true, get: function () { return issue_to_line_1.getLineNumber; } }));
var yaml_parser_1 = __webpack_require__(54232);
Object.defineProperty(exports, "parseFileContent", ({ enumerable: true, get: function () { return yaml_parser_1.parseFileContent; } }));
var path_1 = __webpack_require__(89639);
Object.defineProperty(exports, "parsePath", ({ enumerable: true, get: function () { return path_1.parsePath; } }));
//# sourceMappingURL=index.js.map
/***/ }),
/***/ 76932:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.getLineNumber = exports.getTrees = exports.issuesToLineNumbers = void 0;
var types = __webpack_require__(60442);
var utils_1 = __webpack_require__(95680);
function issuesToLineNumbers(fileContent, fileType, path) {
var trees = getTrees(fileType, fileContent);
return getLineNumber(path, fileType, trees);
}
exports.issuesToLineNumbers = issuesToLineNumbers;
function getTrees(fileType, fileContent) {
assertFileType(fileType);
var trees = utils_1.buildTreeForTypeMap[fileType](fileContent);
if (Object.keys(trees).length === 0) {
throw new Error('failed to create trees');
}
return trees;
}
exports.getTrees = getTrees;
function getLineNumber(path, fileType, trees) {
assertFileType(fileType);
var pathDetails = utils_1.getPathDetails(path.slice(), fileType);
var treeNodes = trees[pathDetails.docId].nodes;
return utils_1.findLineNumberOfGivenPath(treeNodes, pathDetails);
}
exports.getLineNumber = getLineNumber;
function assertFileType(fileType) {
if (!Object.values(types.CloudConfigFileTypes).includes(fileType)) {
throw new Error('Unknown format');
}
}
//# sourceMappingURL=index.js.map
/***/ }),
/***/ 83686:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
var esprima_1 = __webpack_require__(31072);
var JsonIterator = /** @class */ (function () {
function JsonIterator(fileContent) {
this.tokens = [];
this.i = -1;
this.currentToken = {
type: '',
value: '',
loc: undefined,
};
this.done = false;
this.previousProps = [];
this.lastProp = undefined;
this.tokens = esprima_1.tokenize(fileContent, {
comment: true,
loc: true,
});
if (!this.tokens.length) {
throw new SyntaxError('unexpected end of JSON input');
}
}
JsonIterator.prototype[Symbol.iterator] = function () {
return this;
};
JsonIterator.prototype.isCurrentType = function (type) {
if (!this.currentToken) {
throw new SyntaxError('unexpected end of JSON input');
}
return ((this.currentToken.type === 'Punctuator'
? this.currentToken.value
: this.currentToken.type) === type);
};
JsonIterator.prototype.isCurrentValue = function (value) {
if (!this.currentToken) {
throw new SyntaxError('unexpected end of JSON input');
}
return (this.currentToken.type === 'Punctuator' &&
this.currentToken.value === value);
};
JsonIterator.prototype.expectType = function (type) {
if (this.isCurrentType(type)) {
return;
}
var error = new SyntaxError("Unexpected type " + this.currentToken.type);
Object.assign(error, this.currentToken.loc.start);
throw error;
};
JsonIterator.prototype.expectValue = function (value) {
if (this.isCurrentValue(value)) {
return;
}
var error = new SyntaxError("Unexpected value " + this.currentToken.value);
Object.assign(error, this.currentToken.loc.start);
throw error;
};
JsonIterator.prototype.skipComments = function () {
while (this.currentToken &&
(this.isCurrentType('LineComment') || this.isCurrentType('BlockComment'))) {
this.next();
}
};
JsonIterator.prototype.next = function () {
if (this.done) {
throw new SyntaxError('Unexpected EOF');
}
var newToken = this.tokens[++this.i];
this.currentToken = newToken;
if (!this.currentToken) {
this.done = true;
}
};
JsonIterator.prototype.current = function () {
return this.currentToken;
};
JsonIterator.prototype.getCurrentLocation = function () {
return {
line: this.currentToken ? this.currentToken.loc.start.line : 0,
columnStart: this.currentToken ? this.currentToken.loc.start.column : 0,
columnEnd: this.currentToken ? this.currentToken.loc.end.column : 0,
};
};
//--------------- Prop Handling
JsonIterator.prototype.setLastProp = function (prop) {
this.lastProp = prop;
};
JsonIterator.prototype.pushLastProp = function () {
this.previousProps.push(this.lastProp);
this.lastProp = undefined;
};
JsonIterator.prototype.restoreProp = function () {
this.lastProp = this.previousProps.pop();
};
JsonIterator.prototype.getLastProp = function () {
return this.lastProp !== undefined ? this.lastProp.toString() : '';
};
return JsonIterator;
}());
exports["default"] = JsonIterator;
//# sourceMappingURL=iterator.js.map
/***/ }),
/***/ 25552:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.buildJsonTreeMap = void 0;
var tslib_1 = __webpack_require__(70655);
var iterator_1 = __webpack_require__(83686);
var COLON = ':';
var BRACKET_OPEN = '[';
var BRACKET_CLOSE = ']';
var CURLY_BRACKET_OPEN = '{';
var CURLY_BRACKET_CLOSE = '}';
var COMMA = ',';
var MINUS = '-';
var possibleValueTypes = ['String', 'Boolean', 'Null', 'Numeric'];
function buildJsonTreeMap(jsonContent) {
var iter = new iterator_1.default(jsonContent);
iter.next();
iter.skipComments();
var singleWalk = walk(iter);
var tree = {
nodes: singleWalk[0].values,
};
// JSON are always single doc
return {
0: tree,
};
}
exports.buildJsonTreeMap = buildJsonTreeMap;
function skipCommentsAndParseObjectOrArray(iter, shouldParseObject) {
iter.pushLastProp();
iter.skipComments();
var nodes = [];
if (shouldParseObject) {
nodes = parseObject(iter);
}
else {
nodes = parseArray(iter);
}
// bypass }
iter.next();
iter.restoreProp();
return nodes;
}
function parseObject(iter) {
var nodes = [];
var firstLoop = true;
var name;
while (!iter.isCurrentValue(CURLY_BRACKET_CLOSE)) {
if (!firstLoop) {
// key-value pair delimiter
iter.expectValue(COMMA);
iter.next();
iter.skipComments();
// If there is a trailing comma, we might reach the end
// ```
// {
// "a": 1,
// }
// ```
if (iter.isCurrentValue(CURLY_BRACKET_CLOSE)) {
break;
}
}
firstLoop = false;
iter.expectType('String');
name = JSON.parse(iter.current().value);
iter.setLastProp(name);
iter.next();
iter.expectValue(COLON);
iter.next();
nodes.push.apply(nodes, walk(iter));
}
return nodes;
}
function parseArray(iter) {
var nodes = [];
var firstLoop = true;
var i = 0;
while (!iter.isCurrentValue(BRACKET_CLOSE)) {
if (!firstLoop) {
iter.expectValue(COMMA);
iter.next();
iter.skipComments();
if (iter.isCurrentValue(BRACKET_CLOSE)) {
break;
}
}
firstLoop = false;
iter.setLastProp(i);
nodes.push.apply(nodes, walk(iter));
iter.skipComments();
i++;
}
return nodes;
}
function handleNativeCase(iter) {
if (!possibleValueTypes.includes(iter.current().type)) {
throw new Error('failed to find type ' + iter.current().type);
}
// turn "apiVersion" -> apiVersion
// turn 'apiVersion' -> apiVersion
var currentValue = iter.current().value;
if ((currentValue.startsWith('"') && currentValue.endsWith('"')) ||
(currentValue.startsWith("'") && currentValue.endsWith("'"))) {
currentValue = currentValue.substring(1, currentValue.length - 1);
}
var nativeNode = {
key: iter.getLastProp(),
lineLocation: iter.getCurrentLocation(),
values: currentValue,
};
iter.next();
return [nativeNode];
}
function walk(iter) {
var currentNode = {
key: iter.getLastProp(),
lineLocation: iter.getCurrentLocation(),
values: [],
};
switch (iter.current().value) {
case CURLY_BRACKET_OPEN:
iter.next();
return [
tslib_1.__assign(tslib_1.__assign({}, currentNode), { values: skipCommentsAndParseObjectOrArray(iter, true) }),
];
case BRACKET_OPEN:
iter.next();
return skipCommentsAndParseObjectOrArray(iter, false).map(function (value, i) {
return {
key: iter.getLastProp() + "[" + i + "]",
lineLocation: value.lineLocation,
values: value.values,
};
});
case MINUS:
iter.next();
break;
}
return handleNativeCase(iter);
}
//# sourceMappingURL=parser.js.map
/***/ }),
/***/ 89179:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.buildTfTreeMap = void 0;
var types_1 = __webpack_require__(978);
var utils_1 = __webpack_require__(41904);
function buildTfTreeMap(tfContent) {
var multiLineComment = false;
var multiLinePhrase = { phrase: null };
var nodes = [];
var currNode = null;
var stateQueue = [];
var duringTypeParsing = false;
var tfFileLines = tfContent.split('\n');
for (var i = 0; i < tfFileLines.length; i++) {
var line = { content: tfFileLines[i].trim(), number: i };
var lineState = utils_1.getLineState(line, multiLineComment, multiLinePhrase);
multiLineComment = lineState.multiCommentLine;
if (lineState.ignoredLine) {
continue;
}
if (multiLinePhrase.phrase) {
//Multi-line phrase ended - line is not ignored any more
multiLinePhrase.phrase = null;
continue;
}
var topType = void 0;
if (stateQueue.length > 0) {
topType = stateQueue[stateQueue.length - 1].type;
}
var lineType = utils_1.getLineType(line, topType);
// In case of array value where is multiline and not completed yet
// or
// Object inside array
// -> can skip this line
if (topType === types_1.TFLineTypes.ARRAY_START &&
![
types_1.TFLineTypes.ARRAY_END,
types_1.TFLineTypes.OBJECT_START,
types_1.TFLineTypes.OBJECT_START_AND_END,
].includes(lineType)) {
continue;
}
switch (lineType) {
case types_1.TFLineTypes.IGNORE:
continue;
case types_1.TFLineTypes.TYPE_START:
currNode = getTypeDetailsFromLine(line, nodes, stateQueue);
duringTypeParsing = true;
continue;
case types_1.TFLineTypes.TYPE_START_AND_END:
currNode = getTypeDetailsFromLine(line, nodes, stateQueue);
stateQueue = [];
duringTypeParsing = false;
continue;
case types_1.TFLineTypes.TYPE_END:
if (topType !== types_1.TFLineTypes.SUB_TYPE) {
throw new SyntaxError('Invalid TF Input - End of type object without sub type');
}
stateQueue = [];
duringTypeParsing = false;
continue;
case types_1.TFLineTypes.OBJECT_START:
currNode = getComplexObjectNode(line, stateQueue, utils_1.Charts.openBracketsObject, lineType);
continue;
case types_1.TFLineTypes.OBJECT_START_AND_END:
getComplexObjectNode(line, stateQueue, utils_1.Charts.openBracketsObject, lineType);
stateQueue.pop();
continue;
case types_1.TFLineTypes.OBJECT_END: {
currNode = handleComplexObjectEnd(currNode, stateQueue, types_1.TFLineTypes.OBJECT_START);
continue;
}
case types_1.TFLineTypes.FUNCTION_START:
currNode = getComplexObjectNode(line, stateQueue, utils_1.Charts.openFunction, lineType);
continue;
case types_1.TFLineTypes.FUNCTION_START_AND_END:
getComplexObjectNode(line, stateQueue, utils_1.Charts.openFunction, lineType);
stateQueue.pop();
continue;
case types_1.TFLineTypes.FUNCTION_END:
currNode = handleComplexObjectEnd(currNode, stateQueue, types_1.TFLineTypes.FUNCTION_START);
continue;
case types_1.TFLineTypes.STRING:
case types_1.TFLineTypes.MULTILINE_STRING:
case types_1.TFLineTypes.ARRAY_START_AND_END: {
if (!currNode) {
throw new SyntaxError('Unexpected TF input - Simple object without parent node');
}
var simpleNode = getSimpleNode(line);
currNode.values.push(simpleNode);
if (lineType === types_1.TFLineTypes.MULTILINE_STRING) {
multiLinePhrase = utils_1.getMultiLinePhrase(line);
}
continue;
}
case types_1.TFLineTypes.ARRAY_START: {
if (!currNode) {
throw new SyntaxError('Unexpected TF input - Simple object without parent node');
}
var simpleNode = getSimpleNode(line);
if (simpleNode.values === utils_1.Charts.openBracketsArray) {
simpleNode.values = [];
}
currNode.values.push(simpleNode);
stateQueue.push({
structure: simpleNode,
type: lineType,
});
continue;
}
case types_1.TFLineTypes.ARRAY_END: {
stateQueue.pop();
continue;
}
default:
throw new SyntaxError("Invalid TF input - Unhandled line type " + types_1.TFLineTypes[lineType]);
}
}
if (duringTypeParsing || stateQueue.length !== 0) {
throw new SyntaxError('Invalid TF input - Broken file');
}
if (nodes.length === 0) {
throw new SyntaxError('Invalid TF input - No nodes were parsed');
}
// TF are always single doc
return {
0: { nodes: nodes },
};
}
exports.buildTfTreeMap = buildTfTreeMap;
function getTypeDetailsFromLine(currentLine, nodes, stateQueue) {
var lineContent = currentLine.content.split(utils_1.Charts.space);
var resourceType = lineContent[1].replace(/"/g, '');
var objectType = lineContent[0];
if (resourceType === utils_1.Charts.openBracketsObject) {
if (types_1.TerraformValidConfigurationTypes.includes(objectType)) {
//Support Terraform configurations settings object
resourceType = '';
}
else {
throw new SyntaxError('Invalid TF input - Type object without sub type');
}
}
var headNode = getTypeNode(objectType, currentLine, nodes);
if (lineContent[2] &&
lineContent[2] !== null &&
lineContent[2] !== utils_1.Charts.openBracketsObject) {
var resourceName = lineContent[2].replace(/"/g, '');
resourceType = resourceType + "[" + resourceName + "]";
}
var subHeadNode = getSubTypeNode(headNode, resourceType, currentLine);
stateQueue.push({ structure: headNode, type: types_1.TFLineTypes.TYPE_START });
stateQueue.push({ structure: subHeadNode, type: types_1.TFLineTypes.SUB_TYPE });
return subHeadNode;
}
function getTypeNode(objectType, line, nodes) {
var headNode = nodes.find(function (node) { return node.key === objectType; });
if (!headNode) {
headNode = utils_1.getNode(objectType, line, []);
nodes.push(headNode);
}
return headNode;
}
function getSubTypeNode(headNode, resourceType, line) {
var headerSubTypes = headNode.values;
var subHeadNode = headerSubTypes.find(function (node) { return node.key === resourceType; });
if (!subHeadNode) {
subHeadNode = utils_1.getNode(resourceType, line);
headNode.values.push(subHeadNode);
}
return subHeadNode;
}
function getComplexObjectNode(line, stateQueue, splitByChart, lineType) {
var key = line.content
.split(splitByChart)[0]
.split(utils_1.Charts.equal)[0]
.trim();
var objectNode = utils_1.getNode(key, line);
stateQueue.push({ structure: objectNode, type: lineType });
return objectNode;
}
function getSimpleNode(line) {
var _a = line.content.split(utils_1.Charts.equal), key = _a[0], value = _a[1];
return utils_1.getNode(key.trim(), line, value.trim().replace(/"/g, ''));
}
function handleComplexObjectEnd(currNode, stateQueue, startLineType) {
var topState = stateQueue[stateQueue.length - 1];
if (topState.type !== startLineType || stateQueue.length === 0) {
throw new SyntaxError('Invalid TF Input - Object end without start');
}
if (!currNode) {
throw new SyntaxError('Invalid TF input - Object without parent');
}
stateQueue.pop();
topState = stateQueue[stateQueue.length - 1];
var topNode = topState.structure;
topNode.values.push(currNode);
return topNode;
}
//# sourceMappingURL=parser.js.map
/***/ }),
/***/ 978:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.TerraformValidConfigurationTypes = exports.TFLineTypes = void 0;
var TFLineTypes;
(function (TFLineTypes) {
TFLineTypes[TFLineTypes["TYPE_START"] = 1] = "TYPE_START";
TFLineTypes[TFLineTypes["TYPE_END"] = 2] = "TYPE_END";
TFLineTypes[TFLineTypes["TYPE_START_AND_END"] = 3] = "TYPE_START_AND_END";
TFLineTypes[TFLineTypes["SUB_TYPE"] = 4] = "SUB_TYPE";
TFLineTypes[TFLineTypes["STRING"] = 5] = "STRING";
TFLineTypes[TFLineTypes["MULTILINE_STRING"] = 6] = "MULTILINE_STRING";
TFLineTypes[TFLineTypes["ARRAY_START_AND_END"] = 7] = "ARRAY_START_AND_END";
TFLineTypes[TFLineTypes["ARRAY_START"] = 8] = "ARRAY_START";
TFLineTypes[TFLineTypes["ARRAY_END"] = 9] = "ARRAY_END";
TFLineTypes[TFLineTypes["OBJECT_START_AND_END"] = 10] = "OBJECT_START_AND_END";
TFLineTypes[TFLineTypes["OBJECT_START"] = 11] = "OBJECT_START";
TFLineTypes[TFLineTypes["OBJECT_END"] = 12] = "OBJECT_END";
TFLineTypes[TFLineTypes["FUNCTION_START_AND_END"] = 13] = "FUNCTION_START_AND_END";
TFLineTypes[TFLineTypes["FUNCTION_START"] = 14] = "FUNCTION_START";
TFLineTypes[TFLineTypes["FUNCTION_END"] = 15] = "FUNCTION_END";
TFLineTypes[TFLineTypes["IGNORE"] = 99] = "IGNORE";
})(TFLineTypes = exports.TFLineTypes || (exports.TFLineTypes = {}));
exports.TerraformValidConfigurationTypes = ['terraform', 'locals'];
//# sourceMappingURL=types.js.map
/***/ }),
/***/ 41904:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.getNode = exports.getLineType = exports.getMultiLinePhrase = exports.getLineState = exports.Charts = void 0;
var types_1 = __webpack_require__(978);
exports.Charts = {
space: ' ',
equal: '=',
commentHash: '#',
commentDash: '//',
multilineCommentStart: '/*',
multilineCommentEnd: '*/',
multilinePhrase: '<<',
openBracketsObject: '{',
closeBracketsObject: '}',
openBracketsArray: '[',
closeBracketsArray: ']',
openFunction: '(',
closeFunction: ')',
};
function getLineState(line, isMultiLineComment, multiLinePhrase) {
var multiCommentLine = isMultiLineComment;
var ignoredLine = false;
if (line.content.startsWith(exports.Charts.multilineCommentStart)) {
ignoredLine = true;
multiCommentLine = true;
}
if (line.content.includes(exports.Charts.multilineCommentEnd)) {
// Multiline comment ended - this is still a commented line
ignoredLine = true;
multiCommentLine = false;
}
if (line.content.startsWith(exports.Charts.commentHash) ||
line.content.startsWith(exports.Charts.commentDash) ||
line.content.length === 0 //Empty Line
) {
ignoredLine = true;
}
// Inside a multiline comment
if (isMultiLineComment && !ignoredLine) {
ignoredLine = true;
}
// Inside a multiline phrase
if (multiLinePhrase.phrase &&
!line.content.includes(multiLinePhrase.phrase)) {
ignoredLine = true;
}
return {
ignoredLine: ignoredLine,
multiCommentLine: multiCommentLine,
};
}
exports.getLineState = getLineState;
function getMultiLinePhrase(line) {
var phrase = line.content
.split(exports.Charts.multilinePhrase)[1]
.trim()
.split(exports.Charts.space)[0];
return { phrase: phrase };
}
exports.getMultiLinePhrase = getMultiLinePhrase;
function getLineType(line, currentObjectType) {
if (!currentObjectType) {
if (line.content.includes(exports.Charts.openBracketsObject)) {
if (line.content.includes(exports.Charts.closeBracketsObject)) {
return types_1.TFLineTypes.TYPE_START_AND_END;
}
return types_1.TFLineTypes.TYPE_START;
}
throw new SyntaxError('Invalid TF input - TF Object without parent Type');
}
if (line.content.includes(exports.Charts.openBracketsArray)) {
if (line.content.includes(exports.Charts.closeBracketsArray)) {
return types_1.TFLineTypes.ARRAY_START_AND_END;
}
return types_1.TFLineTypes.ARRAY_START;
}
if (line.content.includes(exports.Charts.closeBracketsArray)) {
return types_1.TFLineTypes.ARRAY_END;
}
if (line.content.includes(exports.Charts.multilinePhrase)) {
return types_1.TFLineTypes.MULTILINE_STRING;
}
if (line.content.includes(exports.Charts.openFunction)) {
if (line.content.includes(exports.Charts.closeFunction)) {
return types_1.TFLineTypes.FUNCTION_START_AND_END;
}
return types_1.TFLineTypes.FUNCTION_START;
}
if (line.content.includes(exports.Charts.openBracketsObject)) {
if (line.content.includes(exports.Charts.closeBracketsObject)) {
if (line.content.includes(exports.Charts.equal)) {
return types_1.TFLineTypes.STRING;
}
return types_1.TFLineTypes.OBJECT_START_AND_END;
}
return types_1.TFLineTypes.OBJECT_START;
}
if (line.content.includes(exports.Charts.closeFunction)) {
if (currentObjectType != types_1.TFLineTypes.FUNCTION_START) {
throw new SyntaxError('Invalid TF input - Close function sign without open function');
}
return types_1.TFLineTypes.FUNCTION_END;
}
if (currentObjectType === types_1.TFLineTypes.FUNCTION_START) {
if (line.content.split(exports.Charts.space).length === 1) {
return types_1.TFLineTypes.IGNORE;
}
return types_1.TFLineTypes.STRING;
}
if (line.content.includes(exports.Charts.equal)) {
return types_1.TFLineTypes.STRING;
}
if (line.content.includes(exports.Charts.closeBracketsObject)) {
if (currentObjectType === types_1.TFLineTypes.SUB_TYPE) {
return types_1.TFLineTypes.TYPE_END;
}
return types_1.TFLineTypes.OBJECT_END;
}
if (line.content.startsWith(exports.Charts.multilinePhrase)) {
return types_1.TFLineTypes.MULTILINE_STRING;
}
if (currentObjectType === types_1.TFLineTypes.ARRAY_START) {
// Handling case of multi-line array object where the content is not yet finished.
// Those lines will be skipped as part of
// https://github.com/snyk/cloud-config-parser/blob/b5f5bdd8dd60cb3ad9c110bb6c640f08db0e108b/lib/issue-to-line/tf/parser.ts#L44
return types_1.TFLineTypes.STRING;
}
throw new SyntaxError("Invalid TF input - Unknown line type - " + line.content);
}
exports.getLineType = getLineType;
function getNode(key, line, values) {
var node = {
key: key,
lineLocation: {
line: line.number + 1,
columnStart: 0,
columnEnd: line.content.length,
},
values: values ? values : [],
};
return node;
}
exports.getNode = getNode;
//# sourceMappingURL=utils.js.map
/***/ }),
/***/ 95680:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
var _a;
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.getLineLocationForYamlElement = exports.findLineNumberOfGivenPath = exports.removeInputPathPrefix = exports.getPathDetails = exports.buildTreeForTypeMap = void 0;
var types_1 = __webpack_require__(60442);
var parser_1 = __webpack_require__(59559);
var parser_2 = __webpack_require__(25552);
var parser_3 = __webpack_require__(89179);
exports.buildTreeForTypeMap = (_a = {},
_a[types_1.CloudConfigFileTypes.YAML] = parser_1.buildYamlTreeMap,
_a[types_1.CloudConfigFileTypes.JSON] = parser_2.buildJsonTreeMap,
_a[types_1.CloudConfigFileTypes.TF] = parser_3.buildTfTreeMap,
_a);
function getPathDetails(path, fileType) {
if (fileType === types_1.CloudConfigFileTypes.YAML) {
return parser_1.getPathDetailsForYamlFile(path);
}
return {
docId: 0,
path: removeInputPathPrefix(path),
};
}
exports.getPathDetails = getPathDetails;
function removeInputPathPrefix(path) {
if (path[0] === 'input') {
return path.splice(1);
}
return path;
}
exports.removeInputPathPrefix = removeInputPathPrefix;
function findLineNumberOfGivenPath(nodes, pathDetails) {
var filteredNodes = nodes.filter(function (node) { return node.key === pathDetails.path[0]; });
if (filteredNodes.length === 0) {
// If the path does not exist, we will return '-1'
return -1;
}
if (pathDetails.path.length === 1) {
return filteredNodes[0].lineLocation.line;
}
return getLineNumberForSingleNode(filteredNodes[0], pathDetails.path.splice(1));
}
exports.findLineNumberOfGivenPath = findLineNumberOfGivenPath;
function getLineNumberForSingleNode(baseNode, remainingPath) {
var node = baseNode;
while (remainingPath.length) {
if (typeof node.values === 'string') {
return node.lineLocation.line;
}
var nodeForPath = getNodeForPath(node.values, remainingPath[0]);
if (!nodeForPath) {
//Not exists
return node.lineLocation.line;
}
node = nodeForPath;
remainingPath = remainingPath.splice(1);
}
return node.lineLocation.line;
}
function getNodeForPath(nodeValues, path) {
if (!path.includes('[')) {
return nodeValues.find(function (currNode) {
return currNode.key.startsWith(path + "[") || currNode.key === path;
});
}
var _a = path.replace(']', '').split('['), nodeName = _a[0], subNodeName = _a[1];
var subNodeId = parseInt(subNodeName);
if (!isNaN(subNodeId) && Number.isInteger(subNodeId)) {
return nodeValues.find(function (currNode) { return currNode.key === path; });
}
return nodeValues.find(function (currNode) {
var values = currNode.values;
if (typeof values !== 'string') {
return (currNode.key === path ||
(currNode.key.startsWith(nodeName) &&
values.filter(function (value) {
return value.key === 'name' && value.values === subNodeName;
}).length > 0));
}
return false;
});
}
function getLineLocationForYamlElement(nodeElement) {
return {
line: nodeElement.startMark.line + 1,
columnStart: nodeElement.startMark.pointer,
columnEnd: nodeElement.endMark.pointer,
};
}
exports.getLineLocationForYamlElement = getLineLocationForYamlElement;
//# sourceMappingURL=utils.js.map
/***/ }),
/***/ 59559:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.getPathDetailsForYamlFile = exports.buildYamlTreeMap = void 0;
var yamlJs = __webpack_require__(87736);
var utils_1 = __webpack_require__(95680);
var NULL_TAG = 'tag:yaml.org,2002:null';
var STR_TAG = 'tag:yaml.org,2002:str';
var INT_TAG = 'tag:yaml.org,2002:int';
var FLOAT_TAG = 'tag:yaml.org,2002:float';
var BOOL_TAG = 'tag:yaml.org,2002:bool';
var MAP_TAG = 'tag:yaml.org,2002:map';
var SEQ_TAG = 'tag:yaml.org,2002:seq';
var TIMESTAMP_TAG = 'tag:yaml.org,2002:timestamp';
var KEY_NODE_INDEX = 0;
var VAL_NODE_INDEX = 1;
var COMMENT_CHAR = '#';
var MULTI_DOC_SEPARATOR = '---';
function buildYamlTreeMap(yamlContent) {
var yamlTrees = {};
var docsArray = [];
try {
docsArray = yamlJs.compose_all(yamlContent);
}
catch (error) {
throw new Error('failed to compose_all for given yaml');
}
// Edge case that yamlJs does not handle -
// The first lines, before the first doc separator (---) are comments
// The yamlJs will ignore this lines and will have 1 less document than expected.
// This will only happen for the first document which document object will not be added for
if (yamlContent.startsWith(COMMENT_CHAR) &&
yamlContent.split(MULTI_DOC_SEPARATOR).length === docsArray.length + 1) {
/* eslint-disable @typescript-eslint/camelcase */
// Disable camelcase - object structure from yamlJs
var commentObject = {
start_mark: { line: 0, column: 0, pointer: 0, buffer: yamlContent },
end_mark: { line: 0, column: 0, pointer: 0, buffer: yamlContent },
style: undefined,
tag: NULL_TAG,
unique_id: 'node_0',
value: '',
};
/* eslint-enable @typescript-eslint/camelcase */
docsArray.unshift(commentObject);
}
for (var i = 0; i < docsArray.length; i++) {
var yamlDoc = convertComposeElementToType(docsArray[i]);
// Handle case of empty document - the tag will be null
// No need to build tree for this document
if (yamlDoc.tag !== NULL_TAG) {
yamlTrees[i] = buildTree(yamlDoc);
}
}
return yamlTrees;
}
exports.buildYamlTreeMap = buildYamlTreeMap;
function buildTree(yamlDoc) {
var _a;
var tree = { nodes: [] };
if (yamlDoc.tag !== MAP_TAG) {
throw new Error('Invalid tree - cannot build from map');
}
for (var _i = 0, _b = yamlDoc.value; _i < _b.length; _i++) {
var yamlElementValues = _b[_i];
var values = [
convertComposeElementToType(yamlElementValues[KEY_NODE_INDEX]),
convertComposeElementToType(yamlElementValues[VAL_NODE_INDEX]),
];
(_a = tree.nodes).push.apply(_a, buildTreeBranch(values, []));
}
return tree;
}
function buildTreeBranch(yamlElements, path) {
//We are checking on the valNode - which is the second element in the yamlElements array ([1])
switch (yamlElements[VAL_NODE_INDEX].tag) {
case NULL_TAG:
case STR_TAG:
case INT_TAG:
case FLOAT_TAG:
case BOOL_TAG:
case TIMESTAMP_TAG:
return buildPrimitiveLeaf(yamlElements);
case MAP_TAG:
return buildMapBranch(yamlElements, path);
case SEQ_TAG:
return buildSeqBranch(yamlElements, path);
default:
return [];
}
}
function buildPrimitiveLeaf(yamlElements) {
var keyNode = yamlElements[0], valNode = yamlElements[1];
var key = keyNode.value;
var values = valNode.value;
var lineLocation = utils_1.getLineLocationForYamlElement(keyNode);
return [
{
key: key,
lineLocation: lineLocation,
values: values,
},
];
}
function buildMapBranch(yamlElements, path) {
var keyNode = yamlElements[KEY_NODE_INDEX];
var fullPath = path.concat([keyNode.value]);
return [
getFileStructureNodesForYamlElement(yamlElements, keyNode.value, fullPath),
];
}
function buildSeqBranch(yamlElements, path) {
var keyNode = yamlElements[0], valNode = yamlElements[1];
var seqNodes = [];
for (var i = 0; i < valNode.value.length; i++) {
var nodeElement = convertComposeElementToType(valNode.value[i]);
var key = keyNode.value + "[" + i + "]";
var fullPath = path.concat(key);
if (typeof nodeElement.value === 'string') {
var lineLocation = utils_1.getLineLocationForYamlElement(nodeElement);
var node = {
key: key,
lineLocation: lineLocation,
values: nodeElement.value,
};
seqNodes.push(node);
}
else {
seqNodes.push(getFileStructureNodesForYamlElement([nodeElement, nodeElement], key, fullPath));
}
}
return seqNodes;
}
function convertComposeElementToType(yamlElement) {
return {
id: yamlElement.id