@alma-cdk/project 0.0.14

package/node_modules/nunjucks/src/tests.js

@@ -0,0 +1,286 @@
+'use strict';
+
+var SafeString = require('./runtime').SafeString;
+/**
+ * Returns `true` if the object is a function, otherwise `false`.
+ * @param { any } value
+ * @returns { boolean }
+ */
+
+
+function callable(value) {
+  return typeof value === 'function';
+}
+
+exports.callable = callable;
+/**
+ * Returns `true` if the object is strictly not `undefined`.
+ * @param { any } value
+ * @returns { boolean }
+ */
+
+function defined(value) {
+  return value !== undefined;
+}
+
+exports.defined = defined;
+/**
+ * Returns `true` if the operand (one) is divisble by the test's argument
+ * (two).
+ * @param { number } one
+ * @param { number } two
+ * @returns { boolean }
+ */
+
+function divisibleby(one, two) {
+  return one % two === 0;
+}
+
+exports.divisibleby = divisibleby;
+/**
+ * Returns true if the string has been escaped (i.e., is a SafeString).
+ * @param { any } value
+ * @returns { boolean }
+ */
+
+function escaped(value) {
+  return value instanceof SafeString;
+}
+
+exports.escaped = escaped;
+/**
+ * Returns `true` if the arguments are strictly equal.
+ * @param { any } one
+ * @param { any } two
+ */
+
+function equalto(one, two) {
+  return one === two;
+}
+
+exports.equalto = equalto; // Aliases
+
+exports.eq = exports.equalto;
+exports.sameas = exports.equalto;
+/**
+ * Returns `true` if the value is evenly divisible by 2.
+ * @param { number } value
+ * @returns { boolean }
+ */
+
+function even(value) {
+  return value % 2 === 0;
+}
+
+exports.even = even;
+/**
+ * Returns `true` if the value is falsy - if I recall correctly, '', 0, false,
+ * undefined, NaN or null. I don't know if we should stick to the default JS
+ * behavior or attempt to replicate what Python believes should be falsy (i.e.,
+ * empty arrays, empty dicts, not 0...).
+ * @param { any } value
+ * @returns { boolean }
+ */
+
+function falsy(value) {
+  return !value;
+}
+
+exports.falsy = falsy;
+/**
+ * Returns `true` if the operand (one) is greater or equal to the test's
+ * argument (two).
+ * @param { number } one
+ * @param { number } two
+ * @returns { boolean }
+ */
+
+function ge(one, two) {
+  return one >= two;
+}
+
+exports.ge = ge;
+/**
+ * Returns `true` if the operand (one) is greater than the test's argument
+ * (two).
+ * @param { number } one
+ * @param { number } two
+ * @returns { boolean }
+ */
+
+function greaterthan(one, two) {
+  return one > two;
+}
+
+exports.greaterthan = greaterthan; // alias
+
+exports.gt = exports.greaterthan;
+/**
+ * Returns `true` if the operand (one) is less than or equal to the test's
+ * argument (two).
+ * @param { number } one
+ * @param { number } two
+ * @returns { boolean }
+ */
+
+function le(one, two) {
+  return one <= two;
+}
+
+exports.le = le;
+/**
+ * Returns `true` if the operand (one) is less than the test's passed argument
+ * (two).
+ * @param { number } one
+ * @param { number } two
+ * @returns { boolean }
+ */
+
+function lessthan(one, two) {
+  return one < two;
+}
+
+exports.lessthan = lessthan; // alias
+
+exports.lt = exports.lessthan;
+/**
+ * Returns `true` if the string is lowercased.
+ * @param { string } value
+ * @returns { boolean }
+ */
+
+function lower(value) {
+  return value.toLowerCase() === value;
+}
+
+exports.lower = lower;
+/**
+ * Returns `true` if the operand (one) is less than or equal to the test's
+ * argument (two).
+ * @param { number } one
+ * @param { number } two
+ * @returns { boolean }
+ */
+
+function ne(one, two) {
+  return one !== two;
+}
+
+exports.ne = ne;
+/**
+ * Returns true if the value is strictly equal to `null`.
+ * @param { any }
+ * @returns { boolean }
+ */
+
+function nullTest(value) {
+  return value === null;
+}
+
+exports.null = nullTest;
+/**
+ * Returns true if value is a number.
+ * @param { any }
+ * @returns { boolean }
+ */
+
+function number(value) {
+  return typeof value === 'number';
+}
+
+exports.number = number;
+/**
+ * Returns `true` if the value is *not* evenly divisible by 2.
+ * @param { number } value
+ * @returns { boolean }
+ */
+
+function odd(value) {
+  return value % 2 === 1;
+}
+
+exports.odd = odd;
+/**
+ * Returns `true` if the value is a string, `false` if not.
+ * @param { any } value
+ * @returns { boolean }
+ */
+
+function string(value) {
+  return typeof value === 'string';
+}
+
+exports.string = string;
+/**
+ * Returns `true` if the value is not in the list of things considered falsy:
+ * '', null, undefined, 0, NaN and false.
+ * @param { any } value
+ * @returns { boolean }
+ */
+
+function truthy(value) {
+  return !!value;
+}
+
+exports.truthy = truthy;
+/**
+ * Returns `true` if the value is undefined.
+ * @param { any } value
+ * @returns { boolean }
+ */
+
+function undefinedTest(value) {
+  return value === undefined;
+}
+
+exports.undefined = undefinedTest;
+/**
+ * Returns `true` if the string is uppercased.
+ * @param { string } value
+ * @returns { boolean }
+ */
+
+function upper(value) {
+  return value.toUpperCase() === value;
+}
+
+exports.upper = upper;
+/**
+ * If ES6 features are available, returns `true` if the value implements the
+ * `Symbol.iterator` method. If not, it's a string or Array.
+ *
+ * Could potentially cause issues if a browser exists that has Set and Map but
+ * not Symbol.
+ *
+ * @param { any } value
+ * @returns { boolean }
+ */
+
+function iterable(value) {
+  if (typeof Symbol !== 'undefined') {
+    return !!value[Symbol.iterator];
+  } else {
+    return Array.isArray(value) || typeof value === 'string';
+  }
+}
+
+exports.iterable = iterable;
+/**
+ * If ES6 features are available, returns `true` if the value is an object hash
+ * or an ES6 Map. Otherwise just return if it's an object hash.
+ * @param { any } value
+ * @returns { boolean }
+ */
+
+function mapping(value) {
+  // only maps and object hashes
+  var bool = value !== null && value !== undefined && typeof value === 'object' && !Array.isArray(value);
+
+  if (Set) {
+    return bool && !(value instanceof Set);
+  } else {
+    return bool;
+  }
+}
+
+exports.mapping = mapping;

package/node_modules/nunjucks/src/transformer.js

@@ -0,0 +1,197 @@
+'use strict';
+
+var nodes = require('./nodes');
+
+var lib = require('./lib');
+
+var sym = 0;
+
+function gensym() {
+  return 'hole_' + sym++;
+} // copy-on-write version of map
+
+
+function mapCOW(arr, func) {
+  var res = null;
+
+  for (var i = 0; i < arr.length; i++) {
+    var item = func(arr[i]);
+
+    if (item !== arr[i]) {
+      if (!res) {
+        res = arr.slice();
+      }
+
+      res[i] = item;
+    }
+  }
+
+  return res || arr;
+}
+
+function walk(ast, func, depthFirst) {
+  if (!(ast instanceof nodes.Node)) {
+    return ast;
+  }
+
+  if (!depthFirst) {
+    var astT = func(ast);
+
+    if (astT && astT !== ast) {
+      return astT;
+    }
+  }
+
+  if (ast instanceof nodes.NodeList) {
+    var children = mapCOW(ast.children, function (node) {
+      return walk(node, func, depthFirst);
+    });
+
+    if (children !== ast.children) {
+      ast = new nodes[ast.typename](ast.lineno, ast.colno, children);
+    }
+  } else if (ast instanceof nodes.CallExtension) {
+    var args = walk(ast.args, func, depthFirst);
+    var contentArgs = mapCOW(ast.contentArgs, function (node) {
+      return walk(node, func, depthFirst);
+    });
+
+    if (args !== ast.args || contentArgs !== ast.contentArgs) {
+      ast = new nodes[ast.typename](ast.extName, ast.prop, args, contentArgs);
+    }
+  } else {
+    var props = ast.fields.map(function (field) {
+      return ast[field];
+    });
+    var propsT = mapCOW(props, function (prop) {
+      return walk(prop, func, depthFirst);
+    });
+
+    if (propsT !== props) {
+      ast = new nodes[ast.typename](ast.lineno, ast.colno);
+      propsT.forEach(function (prop, i) {
+        ast[ast.fields[i]] = prop;
+      });
+    }
+  }
+
+  return depthFirst ? func(ast) || ast : ast;
+}
+
+function depthWalk(ast, func) {
+  return walk(ast, func, true);
+}
+
+function _liftFilters(node, asyncFilters, prop) {
+  var children = [];
+  var walked = depthWalk(prop ? node[prop] : node, function (descNode) {
+    var symbol;
+
+    if (descNode instanceof nodes.Block) {
+      return descNode;
+    } else if (descNode instanceof nodes.Filter && lib.indexOf(asyncFilters, descNode.name.value) !== -1 || descNode instanceof nodes.CallExtensionAsync) {
+      symbol = new nodes.Symbol(descNode.lineno, descNode.colno, gensym());
+      children.push(new nodes.FilterAsync(descNode.lineno, descNode.colno, descNode.name, descNode.args, symbol));
+    }
+
+    return symbol;
+  });
+
+  if (prop) {
+    node[prop] = walked;
+  } else {
+    node = walked;
+  }
+
+  if (children.length) {
+    children.push(node);
+    return new nodes.NodeList(node.lineno, node.colno, children);
+  } else {
+    return node;
+  }
+}
+
+function liftFilters(ast, asyncFilters) {
+  return depthWalk(ast, function (node) {
+    if (node instanceof nodes.Output) {
+      return _liftFilters(node, asyncFilters);
+    } else if (node instanceof nodes.Set) {
+      return _liftFilters(node, asyncFilters, 'value');
+    } else if (node instanceof nodes.For) {
+      return _liftFilters(node, asyncFilters, 'arr');
+    } else if (node instanceof nodes.If) {
+      return _liftFilters(node, asyncFilters, 'cond');
+    } else if (node instanceof nodes.CallExtension) {
+      return _liftFilters(node, asyncFilters, 'args');
+    } else {
+      return undefined;
+    }
+  });
+}
+
+function liftSuper(ast) {
+  return walk(ast, function (blockNode) {
+    if (!(blockNode instanceof nodes.Block)) {
+      return;
+    }
+
+    var hasSuper = false;
+    var symbol = gensym();
+    blockNode.body = walk(blockNode.body, function (node) {
+      // eslint-disable-line consistent-return
+      if (node instanceof nodes.FunCall && node.name.value === 'super') {
+        hasSuper = true;
+        return new nodes.Symbol(node.lineno, node.colno, symbol);
+      }
+    });
+
+    if (hasSuper) {
+      blockNode.body.children.unshift(new nodes.Super(0, 0, blockNode.name, new nodes.Symbol(0, 0, symbol)));
+    }
+  });
+}
+
+function convertStatements(ast) {
+  return depthWalk(ast, function (node) {
+    if (!(node instanceof nodes.If) && !(node instanceof nodes.For)) {
+      return undefined;
+    }
+
+    var async = false;
+    walk(node, function (child) {
+      if (child instanceof nodes.FilterAsync || child instanceof nodes.IfAsync || child instanceof nodes.AsyncEach || child instanceof nodes.AsyncAll || child instanceof nodes.CallExtensionAsync) {
+        async = true; // Stop iterating by returning the node
+
+        return child;
+      }
+
+      return undefined;
+    });
+
+    if (async) {
+      if (node instanceof nodes.If) {
+        return new nodes.IfAsync(node.lineno, node.colno, node.cond, node.body, node.else_);
+      } else if (node instanceof nodes.For && !(node instanceof nodes.AsyncAll)) {
+        return new nodes.AsyncEach(node.lineno, node.colno, node.arr, node.name, node.body, node.else_);
+      }
+    }
+
+    return undefined;
+  });
+}
+
+function cps(ast, asyncFilters) {
+  return convertStatements(liftSuper(liftFilters(ast, asyncFilters)));
+}
+
+function transform(ast, asyncFilters) {
+  return cps(ast, asyncFilters || []);
+} // var parser = require('./parser');
+// var src = 'hello {% foo %}{% endfoo %} end';
+// var ast = transform(parser.parse(src, [new FooExtension()]), ['bar']);
+// nodes.printNodes(ast);
+
+
+module.exports = {
+  transform: transform
+};

package/node_modules/nunjucks/src/web-loaders.js

@@ -0,0 +1,110 @@
+'use strict';
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+var Loader = require('./loader');
+
+var _require = require('./precompiled-loader.js'),
+    PrecompiledLoader = _require.PrecompiledLoader;
+
+var WebLoader = /*#__PURE__*/function (_Loader) {
+  _inheritsLoose(WebLoader, _Loader);
+
+  function WebLoader(baseURL, opts) {
+    var _this;
+
+    _this = _Loader.call(this) || this;
+    _this.baseURL = baseURL || '.';
+    opts = opts || {}; // By default, the cache is turned off because there's no way
+    // to "watch" templates over HTTP, so they are re-downloaded
+    // and compiled each time. (Remember, PRECOMPILE YOUR
+    // TEMPLATES in production!)
+
+    _this.useCache = !!opts.useCache; // We default `async` to false so that the simple synchronous
+    // API can be used when you aren't doing anything async in
+    // your templates (which is most of the time). This performs a
+    // sync ajax request, but that's ok because it should *only*
+    // happen in development. PRECOMPILE YOUR TEMPLATES.
+
+    _this.async = !!opts.async;
+    return _this;
+  }
+
+  var _proto = WebLoader.prototype;
+
+  _proto.resolve = function resolve(from, to) {
+    throw new Error('relative templates not support in the browser yet');
+  };
+
+  _proto.getSource = function getSource(name, cb) {
+    var _this2 = this;
+
+    var useCache = this.useCache;
+    var result;
+    this.fetch(this.baseURL + '/' + name, function (err, src) {
+      if (err) {
+        if (cb) {
+          cb(err.content);
+        } else if (err.status === 404) {
+          result = null;
+        } else {
+          throw err.content;
+        }
+      } else {
+        result = {
+          src: src,
+          path: name,
+          noCache: !useCache
+        };
+
+        _this2.emit('load', name, result);
+
+        if (cb) {
+          cb(null, result);
+        }
+      }
+    }); // if this WebLoader isn't running asynchronously, the
+    // fetch above would actually run sync and we'll have a
+    // result here
+
+    return result;
+  };
+
+  _proto.fetch = function fetch(url, cb) {
+    // Only in the browser please
+    if (typeof window === 'undefined') {
+      throw new Error('WebLoader can only by used in a browser');
+    }
+
+    var ajax = new XMLHttpRequest();
+    var loading = true;
+
+    ajax.onreadystatechange = function () {
+      if (ajax.readyState === 4 && loading) {
+        loading = false;
+
+        if (ajax.status === 0 || ajax.status === 200) {
+          cb(null, ajax.responseText);
+        } else {
+          cb({
+            status: ajax.status,
+            content: ajax.responseText
+          });
+        }
+      }
+    };
+
+    url += (url.indexOf('?') === -1 ? '?' : '&') + 's=' + new Date().getTime();
+    ajax.open('GET', url, this.async);
+    ajax.send();
+  };
+
+  return WebLoader;
+}(Loader);
+
+module.exports = {
+  WebLoader: WebLoader,
+  PrecompiledLoader: PrecompiledLoader
+};

package/node_modules/param-case/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/node_modules/param-case/README.md

@@ -0,0 +1,37 @@
+# Param Case
+
+[![NPM version][npm-image]][npm-url]
+[![NPM downloads][downloads-image]][downloads-url]
+[![Bundle size][bundlephobia-image]][bundlephobia-url]
+
+> Transform into a lower cased string with dashes between words.
+
+## Installation
+
+```
+npm install param-case --save
+```
+
+## Usage
+
+```js
+import { paramCase } from "param-case";
+
+paramCase("string"); //=> "string"
+paramCase("dot.case"); //=> "dot-case"
+paramCase("PascalCase"); //=> "pascal-case"
+paramCase("version 1.2.10"); //=> "version-1-2-10"
+```
+
+The function also accepts [`options`](https://github.com/blakeembrey/change-case#options).
+
+## License
+
+MIT
+
+[npm-image]: https://img.shields.io/npm/v/param-case.svg?style=flat
+[npm-url]: https://npmjs.org/package/param-case
+[downloads-image]: https://img.shields.io/npm/dm/param-case.svg?style=flat
+[downloads-url]: https://npmjs.org/package/param-case
+[bundlephobia-image]: https://img.shields.io/bundlephobia/minzip/param-case.svg
+[bundlephobia-url]: https://bundlephobia.com/result?p=param-case

package/node_modules/param-case/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { Options } from "dot-case";
+export { Options };
+export declare function paramCase(input: string, options?: Options): string;

package/node_modules/param-case/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paramCase = void 0;
+var tslib_1 = require("tslib");
+var dot_case_1 = require("dot-case");
+function paramCase(input, options) {
+    if (options === void 0) { options = {}; }
+    return dot_case_1.dotCase(input, tslib_1.__assign({ delimiter: "-" }, options));
+}
+exports.paramCase = paramCase;
+//# sourceMappingURL=index.js.map

package/node_modules/param-case/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;AAAA,qCAA4C;AAI5C,SAAgB,SAAS,CAAC,KAAa,EAAE,OAAqB;IAArB,wBAAA,EAAA,YAAqB;IAC5D,OAAO,kBAAO,CAAC,KAAK,qBAClB,SAAS,EAAE,GAAG,IACX,OAAO,EACV,CAAC;AACL,CAAC;AALD,8BAKC","sourcesContent":["import { dotCase, Options } from \"dot-case\";\n\nexport { Options };\n\nexport function paramCase(input: string, options: Options = {}) {\n  return dotCase(input, {\n    delimiter: \"-\",\n    ...options,\n  });\n}\n"]}

package/node_modules/param-case/dist/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/param-case/dist/index.spec.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var _1 = require(".");
+var TEST_CASES = [
+    ["", ""],
+    ["test", "test"],
+    ["test string", "test-string"],
+    ["Test String", "test-string"],
+    ["TestV2", "test-v2"],
+    ["version 1.2.10", "version-1-2-10"],
+    ["version 1.21.0", "version-1-21-0"],
+];
+describe("param case", function () {
+    var _loop_1 = function (input, result) {
+        it(input + " -> " + result, function () {
+            expect(_1.paramCase(input)).toEqual(result);
+        });
+    };
+    for (var _i = 0, TEST_CASES_1 = TEST_CASES; _i < TEST_CASES_1.length; _i++) {
+        var _a = TEST_CASES_1[_i], input = _a[0], result = _a[1];
+        _loop_1(input, result);
+    }
+});
+//# sourceMappingURL=index.spec.js.map

package/node_modules/param-case/dist/index.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.spec.js","sourceRoot":"","sources":["../src/index.spec.ts"],"names":[],"mappings":";;AAAA,sBAA8B;AAE9B,IAAM,UAAU,GAAuB;IACrC,CAAC,EAAE,EAAE,EAAE,CAAC;IACR,CAAC,MAAM,EAAE,MAAM,CAAC;IAChB,CAAC,aAAa,EAAE,aAAa,CAAC;IAC9B,CAAC,aAAa,EAAE,aAAa,CAAC;IAC9B,CAAC,QAAQ,EAAE,SAAS,CAAC;IACrB,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IACpC,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;CACrC,CAAC;AAEF,QAAQ,CAAC,YAAY,EAAE;4BACT,KAAK,EAAE,MAAM;QACvB,EAAE,CAAI,KAAK,YAAO,MAAQ,EAAE;YAC1B,MAAM,CAAC,YAAS,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;;IAHL,KAA8B,UAAU,EAAV,yBAAU,EAAV,wBAAU,EAAV,IAAU;QAA7B,IAAA,qBAAe,EAAd,KAAK,QAAA,EAAE,MAAM,QAAA;gBAAb,KAAK,EAAE,MAAM;KAIxB;AACH,CAAC,CAAC,CAAC","sourcesContent":["import { paramCase } from \".\";\n\nconst TEST_CASES: [string, string][] = [\n  [\"\", \"\"],\n  [\"test\", \"test\"],\n  [\"test string\", \"test-string\"],\n  [\"Test String\", \"test-string\"],\n  [\"TestV2\", \"test-v2\"],\n  [\"version 1.2.10\", \"version-1-2-10\"],\n  [\"version 1.21.0\", \"version-1-21-0\"],\n];\n\ndescribe(\"param case\", () => {\n  for (const [input, result] of TEST_CASES) {\n    it(`${input} -> ${result}`, () => {\n      expect(paramCase(input)).toEqual(result);\n    });\n  }\n});\n"]}