@cdklabs/cdk-ssm-documents 0.0.70 → 0.0.72

package/node_modules/jsonpath-plus/package.json

@@ -0,0 +1,141 @@
+{
+  "author": "Stefan Goessner",
+  "name": "jsonpath-plus",
+  "version": "10.4.0",
+  "type": "module",
+  "bin": {
+    "jsonpath": "./bin/jsonpath-cli.js",
+    "jsonpath-plus": "./bin/jsonpath-cli.js"
+  },
+  "main": "dist/index-node-cjs.cjs",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./src/jsonpath.d.ts",
+      "browser": "./dist/index-browser-esm.js",
+      "umd": "./dist/index-browser-umd.cjs",
+      "import": "./dist/index-node-esm.js",
+      "require": "./dist/index-node-cjs.cjs",
+      "default": "./dist/index-browser-esm.js"
+    }
+  },
+  "module": "dist/index-node-esm.js",
+  "browser": "dist/index-browser-esm.js",
+  "types": "./src/jsonpath.d.ts",
+  "description": "A JS implementation of JSONPath with some additional operators",
+  "contributors": [
+    {
+      "name": "Prof. Gössner",
+      "email": "stefan.goessner@fh-dortmund.de"
+    },
+    {
+      "name": "Subbu Allamaraju",
+      "email": "subbu@subbu.org"
+    },
+    {
+      "name": "Mike Brevoort",
+      "email": "mike@brevoort.com"
+    },
+    {
+      "name": "Robert Krahn",
+      "email": "robert.krahn@gmail.com"
+    },
+    {
+      "name": "Brett Zamir",
+      "email": "brettz9@yahoo.com"
+    },
+    {
+      "name": "Richard Schneider",
+      "email": "makaretu@gmail.com"
+    }
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/s3u/JSONPath.git"
+  },
+  "bugs": "https://github.com/s3u/JSONPath/issues/",
+  "homepage": "https://github.com/s3u/JSONPath",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "react-native": {
+    "vm": false
+  },
+  "dependencies": {
+    "@jsep-plugin/assignment": "^1.3.0",
+    "@jsep-plugin/regex": "^1.0.4",
+    "jsep": "^1.4.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.28.5",
+    "@babel/preset-env": "^7.28.5",
+    "@rollup/plugin-babel": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "c8": "^10.1.3",
+    "chai": "^6.2.1",
+    "coveradge": "^0.8.2",
+    "eslint": "^9.39.1",
+    "eslint-config-ash-nazg": "^39.8.0",
+    "http-server": "^14.1.1",
+    "license-badger": "^0.22.1",
+    "mocha": "^11.7.5",
+    "mocha-badge-generator": "^0.11.0",
+    "mocha-multi-reporters": "^1.5.1",
+    "open-cli": "^8.0.0",
+    "rollup": "4.53.2",
+    "typedoc": "^0.28.14",
+    "typescript": "^5.9.3"
+  },
+  "keywords": [
+    "json",
+    "jsonpath"
+  ],
+  "browserslist": [
+    "defaults, not op_mini all"
+  ],
+  "c8": {
+    "reporter": [
+      "text",
+      "html",
+      "json-summary"
+    ],
+    "exclude": [
+      ".mocharc.cjs",
+      "eslint.config.js",
+      "src/jsonpath.d.ts",
+      "rollup.config.js",
+      ".idea",
+      "coverage",
+      "dist",
+      "demo",
+      "docs",
+      "ignore",
+      "test",
+      "test-helpers"
+    ]
+  },
+  "scripts": {
+    "prepublishOnly": "pnpm i",
+    "license-badge": "license-badger --corrections --uncategorizedLicenseTemplate \"\\${license} (\\${name} (\\${version}))\" --filteredTypes=nonempty --textTemplate \"License types\n(project, deps, and bundled devDeps)\" --packageJson --production badges/licenses-badge.svg",
+    "license-badge-dev": "license-badger --corrections --filteredTypes=nonempty --textTemplate \"License types\n(all devDeps)\" --allDevelopment badges/licenses-badge-dev.svg",
+    "license-badges": "npm run license-badge && npm run license-badge-dev",
+    "build-docs": "typedoc --out docs/ts src --excludeExternals --entryPointStrategy Expand",
+    "open-docs": "open-cli http://localhost:8084/docs/ts/ && npm start",
+    "coverage": "open-cli http://localhost:8084/coverage/ && npm start",
+    "coverage-badge": "coveradge badges/coverage-badge.svg",
+    "node-import-test": "node --experimental-modules demo/node-import-test.mjs",
+    "open": "open-cli http://localhost:8084/demo/ && npm start",
+    "start": "http-server -p 8084",
+    "cli": "./bin/jsonpath-cli.js package.json name",
+    "typescript": "tsc",
+    "mocha": "mocha --require test-helpers/node-env.js --reporter-options configFile=mocha-multi-reporters.json test",
+    "c8": "rm -Rf ./coverage && rm -Rf ./node_modules/.cache && c8 --all npm run mocha && npm run coverage-badge",
+    "rollup": "rollup -c",
+    "eslint": "eslint .",
+    "lint": "npm run eslint",
+    "test": "npm run eslint && npm run rollup && npm run c8 && npm run typescript",
+    "browser-test": "npm run eslint && npm run rollup && open-cli http://localhost:8084/test/ && npm start"
+  }
+}

package/node_modules/jsonpath-plus/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+ignoredBuiltDependencies:
+  - unrs-resolver

package/node_modules/jsonpath-plus/src/Safe-Script.js

@@ -0,0 +1,208 @@
+/* eslint-disable no-bitwise -- Convenient */
+import jsep from 'jsep';
+import jsepRegex from '@jsep-plugin/regex';
+import jsepAssignment from '@jsep-plugin/assignment';
+
+// register plugins
+jsep.plugins.register(jsepRegex, jsepAssignment);
+jsep.addUnaryOp('typeof');
+jsep.addUnaryOp('void');
+jsep.addLiteral('null', null);
+jsep.addLiteral('undefined', undefined);
+
+const BLOCKED_PROTO_PROPERTIES = new Set([
+    'constructor',
+    '__proto__',
+    '__defineGetter__',
+    '__defineSetter__',
+    '__lookupGetter__',
+    '__lookupSetter__'
+]);
+
+const SafeEval = {
+    /**
+     * @param {jsep.Expression} ast
+     * @param {Record<string, any>} subs
+     */
+    evalAst (ast, subs) {
+        switch (ast.type) {
+        case 'BinaryExpression':
+        case 'LogicalExpression':
+            return SafeEval.evalBinaryExpression(ast, subs);
+        case 'Compound':
+            return SafeEval.evalCompound(ast, subs);
+        case 'ConditionalExpression':
+            return SafeEval.evalConditionalExpression(ast, subs);
+        case 'Identifier':
+            return SafeEval.evalIdentifier(ast, subs);
+        case 'Literal':
+            return SafeEval.evalLiteral(ast, subs);
+        case 'MemberExpression':
+            return SafeEval.evalMemberExpression(ast, subs);
+        case 'UnaryExpression':
+            return SafeEval.evalUnaryExpression(ast, subs);
+        case 'ArrayExpression':
+            return SafeEval.evalArrayExpression(ast, subs);
+        case 'CallExpression':
+            return SafeEval.evalCallExpression(ast, subs);
+        case 'AssignmentExpression':
+            return SafeEval.evalAssignmentExpression(ast, subs);
+        default:
+            throw SyntaxError('Unexpected expression', ast);
+        }
+    },
+    evalBinaryExpression (ast, subs) {
+        const result = {
+            '||': (a, b) => a || b(),
+            '&&': (a, b) => a && b(),
+            '|': (a, b) => a | b(),
+            '^': (a, b) => a ^ b(),
+            '&': (a, b) => a & b(),
+            // eslint-disable-next-line eqeqeq -- API
+            '==': (a, b) => a == b(),
+            // eslint-disable-next-line eqeqeq -- API
+            '!=': (a, b) => a != b(),
+            '===': (a, b) => a === b(),
+            '!==': (a, b) => a !== b(),
+            '<': (a, b) => a < b(),
+            '>': (a, b) => a > b(),
+            '<=': (a, b) => a <= b(),
+            '>=': (a, b) => a >= b(),
+            '<<': (a, b) => a << b(),
+            '>>': (a, b) => a >> b(),
+            '>>>': (a, b) => a >>> b(),
+            '+': (a, b) => a + b(),
+            '-': (a, b) => a - b(),
+            '*': (a, b) => a * b(),
+            '/': (a, b) => a / b(),
+            '%': (a, b) => a % b()
+        }[ast.operator](
+            SafeEval.evalAst(ast.left, subs),
+            () => SafeEval.evalAst(ast.right, subs)
+        );
+        return result;
+    },
+    evalCompound (ast, subs) {
+        let last;
+        for (let i = 0; i < ast.body.length; i++) {
+            if (
+                ast.body[i].type === 'Identifier' &&
+                ['var', 'let', 'const'].includes(ast.body[i].name) &&
+                ast.body[i + 1] &&
+                ast.body[i + 1].type === 'AssignmentExpression'
+            ) {
+                // var x=2; is detected as
+                // [{Identifier var}, {AssignmentExpression x=2}]
+                // eslint-disable-next-line @stylistic/max-len -- Long
+                // eslint-disable-next-line sonarjs/updated-loop-counter -- Convenient
+                i += 1;
+            }
+            const expr = ast.body[i];
+            last = SafeEval.evalAst(expr, subs);
+        }
+        return last;
+    },
+    evalConditionalExpression (ast, subs) {
+        if (SafeEval.evalAst(ast.test, subs)) {
+            return SafeEval.evalAst(ast.consequent, subs);
+        }
+        return SafeEval.evalAst(ast.alternate, subs);
+    },
+    evalIdentifier (ast, subs) {
+        if (Object.hasOwn(subs, ast.name)) {
+            return subs[ast.name];
+        }
+        throw ReferenceError(`${ast.name} is not defined`);
+    },
+    evalLiteral (ast) {
+        return ast.value;
+    },
+    evalMemberExpression (ast, subs) {
+        const prop = String(
+            // NOTE: `String(value)` throws error when
+            // value has overwritten the toString method to return non-string
+            // i.e. `value = {toString: () => []}`
+            ast.computed
+                ? SafeEval.evalAst(ast.property) // `object[property]`
+                : ast.property.name // `object.property` property is Identifier
+        );
+        const obj = SafeEval.evalAst(ast.object, subs);
+        if (obj === undefined || obj === null) {
+            throw TypeError(
+                `Cannot read properties of ${obj} (reading '${prop}')`
+            );
+        }
+        if (!Object.hasOwn(obj, prop) && BLOCKED_PROTO_PROPERTIES.has(prop)) {
+            throw TypeError(
+                `Cannot read properties of ${obj} (reading '${prop}')`
+            );
+        }
+        const result = obj[prop];
+        if (typeof result === 'function') {
+            return result.bind(obj); // arrow functions aren't affected by bind.
+        }
+        return result;
+    },
+    evalUnaryExpression (ast, subs) {
+        const result = {
+            '-': (a) => -SafeEval.evalAst(a, subs),
+            '!': (a) => !SafeEval.evalAst(a, subs),
+            '~': (a) => ~SafeEval.evalAst(a, subs),
+            // eslint-disable-next-line no-implicit-coercion -- API
+            '+': (a) => +SafeEval.evalAst(a, subs),
+            typeof: (a) => typeof SafeEval.evalAst(a, subs),
+            // eslint-disable-next-line no-void, sonarjs/void-use -- feature
+            void: (a) => void SafeEval.evalAst(a, subs)
+        }[ast.operator](ast.argument);
+        return result;
+    },
+    evalArrayExpression (ast, subs) {
+        return ast.elements.map((el) => SafeEval.evalAst(el, subs));
+    },
+    evalCallExpression (ast, subs) {
+        const args = ast.arguments.map((arg) => SafeEval.evalAst(arg, subs));
+        const func = SafeEval.evalAst(ast.callee, subs);
+        /* c8 ignore start  */
+        if (func === Function) {
+            // unreachable since BLOCKED_PROTO_PROPERTIES includes 'constructor'
+            throw new Error('Function constructor is disabled');
+        }
+        /* c8 ignore end  */
+        return func(...args);
+    },
+    evalAssignmentExpression (ast, subs) {
+        if (ast.left.type !== 'Identifier') {
+            throw SyntaxError('Invalid left-hand side in assignment');
+        }
+        const id = ast.left.name;
+        const value = SafeEval.evalAst(ast.right, subs);
+        subs[id] = value;
+        return subs[id];
+    }
+};
+
+/**
+ * A replacement for NodeJS' VM.Script which is also {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP | Content Security Policy} friendly.
+ */
+class SafeScript {
+    /**
+     * @param {string} expr Expression to evaluate
+     */
+    constructor (expr) {
+        this.code = expr;
+        this.ast = jsep(this.code);
+    }
+
+    /**
+     * @param {object} context Object whose items will be added
+     *   to evaluation
+     * @returns {EvaluatedResult} Result of evaluated code
+     */
+    runInNewContext (context) {
+        // `Object.create(null)` creates a prototypeless object
+        const keyMap = Object.assign(Object.create(null), context);
+        return SafeEval.evalAst(this.ast, keyMap);
+    }
+}
+
+export {SafeScript};

package/node_modules/jsonpath-plus/src/jsonpath-browser.js

@@ -0,0 +1,102 @@
+import {JSONPath} from './jsonpath.js';
+
+/**
+ * @typedef {any} ContextItem
+ */
+
+/**
+ * @typedef {any} EvaluatedResult
+ */
+
+/**
+ * @callback ConditionCallback
+ * @param {ContextItem} item
+ * @returns {boolean}
+ */
+
+/**
+ * Copy items out of one array into another.
+ * @param {GenericArray} source Array with items to copy
+ * @param {GenericArray} target Array to which to copy
+ * @param {ConditionCallback} conditionCb Callback passed the current item;
+ *     will move item if evaluates to `true`
+ * @returns {void}
+ */
+const moveToAnotherArray = function (source, target, conditionCb) {
+    const il = source.length;
+    for (let i = 0; i < il; i++) {
+        const item = source[i];
+        if (conditionCb(item)) {
+            // eslint-disable-next-line @stylistic/max-len -- Long
+            // eslint-disable-next-line sonarjs/updated-loop-counter -- Convenient
+            target.push(source.splice(i--, 1)[0]);
+        }
+    }
+};
+
+/**
+ * In-browser replacement for NodeJS' VM.Script.
+ */
+class Script {
+    /**
+     * @param {string} expr Expression to evaluate
+     */
+    constructor (expr) {
+        this.code = expr;
+    }
+
+    /**
+     * @param {object} context Object whose items will be added
+     *   to evaluation
+     * @returns {EvaluatedResult} Result of evaluated code
+     */
+    runInNewContext (context) {
+        let expr = this.code;
+        const keys = Object.keys(context);
+        const funcs = [];
+        moveToAnotherArray(keys, funcs, (key) => {
+            return typeof context[key] === 'function';
+        });
+        const values = keys.map((vr) => {
+            return context[vr];
+        });
+
+        const funcString = funcs.reduce((s, func) => {
+            let fString = context[func].toString();
+            if (!(/function/u).test(fString)) {
+                fString = 'function ' + fString;
+            }
+            return 'var ' + func + '=' + fString + ';' + s;
+        }, '');
+
+        expr = funcString + expr;
+
+        // Mitigate http://perfectionkills.com/global-eval-what-are-the-options/#new_function
+        if (!(/(['"])use strict\1/u).test(expr) && !keys.includes('arguments')) {
+            expr = 'var arguments = undefined;' + expr;
+        }
+
+        // Remove last semi so `return` will be inserted before
+        //  the previous one instead, allowing for the return
+        //  of a bare ending expression
+        expr = expr.replace(/;\s*$/u, '');
+
+        // Insert `return`
+        const lastStatementEnd = expr.lastIndexOf(';');
+        const code =
+            lastStatementEnd !== -1
+                ? expr.slice(0, lastStatementEnd + 1) +
+                  ' return ' +
+                  expr.slice(lastStatementEnd + 1)
+                : ' return ' + expr;
+
+        // eslint-disable-next-line no-new-func -- User's choice
+        return new Function(...keys, code)(...values);
+    }
+}
+
+JSONPath.prototype.vm = {
+    Script
+};
+
+export {JSONPath};

package/node_modules/jsonpath-plus/src/jsonpath-node.js

@@ -0,0 +1,8 @@
+import vm from 'vm';
+import {JSONPath} from './jsonpath.js';
+
+JSONPath.prototype.vm = vm;
+
+export {
+    JSONPath
+};

package/node_modules/jsonpath-plus/src/jsonpath.d.ts

@@ -0,0 +1,226 @@
+/**
+ * Declaration for https://github.com/s3u/JSONPath
+ */
+declare module 'jsonpath-plus' {
+  type JSONPathCallback = (
+      payload: any, payloadType: any, fullPayload: any
+  ) => any
+
+  type JSONPathOtherTypeCallback = (...args: any[]) => void
+
+  class EvalClass {
+    constructor(code: string);
+    runInNewContext(context: object): any;
+  }
+
+  interface JSONPathOptions {
+    /**
+     * The JSONPath expression as a (normalized or unnormalized) string or
+     *   array.
+     */
+    path: string | any[]
+    /**
+     * The JSON object to evaluate (whether of null, boolean, number,
+     *   string, object, or array type).
+     */
+    json: null | boolean | number | string | object | any[]
+    /**
+     * If this is supplied as false, one may call the evaluate method
+     *  manually.
+     *
+     * @default true
+     */
+    autostart?: true | boolean
+    /**
+     * Whether the returned array of results will be flattened to a
+     *   single dimension array.
+     *
+     * @default false
+     */
+    flatten?: false | boolean
+    /**
+     * Can be case-insensitive form of "value", "path", "pointer", "parent",
+     *   or "parentProperty" to determine respectively whether to return
+     *   results as the values of the found items, as their absolute paths,
+     *   as JSON Pointers to the absolute paths, as their parent objects,
+     *   or as their parent's property name.
+     *
+     * If set to "all", all of these types will be returned on an object with
+     *   the type as key name.
+     *
+     * @default 'value'
+     */
+    resultType?:
+        'value' | 'path' | 'pointer' | 'parent' | 'parentProperty' | 'all'
+
+    /**
+     * Key-value map of variables to be available to code evaluations such
+     *   as filtering expressions.
+     * (Note that the current path and value will also be available to those
+     *   expressions; see the Syntax section for details.)
+     */
+    sandbox?: Map<string, any>
+    /**
+     * Whether or not to wrap the results in an array.
+     *
+     * If wrap is set to false, and no results are found, undefined will be
+     *   returned (as opposed to an empty array when wrap is set to true).
+     *
+     * If wrap is set to false and a single non-array result is found, that
+     *   result will be the only item returned (not within an array).
+     *
+     * An array will still be returned if multiple results are found, however.
+     * To avoid ambiguities (in the case where it is necessary to distinguish
+     * between a result which is a failure and one which is an empty array),
+     * it is recommended to switch the default to false.
+     *
+     * @default true
+     */
+    wrap?: true | boolean
+    /**
+     * Script evaluation method.
+     *
+     * `safe`: In browser, it will use a minimal scripting engine which doesn't
+     * use `eval` or `Function` and satisfies Content Security Policy. In NodeJS,
+     * it has no effect and is equivalent to native as scripting is safe there.
+     *
+     * `native`: uses the native scripting capabilities. i.e. unsafe `eval` or
+     * `Function` in browser and `vm.Script` in nodejs.
+     *
+     * `true`: Same as 'safe'
+     *
+     * `false`: Disable Javascript executions in path string. Same as `preventEval: true` in previous versions.
+     *
+     * `callback [ (code, context) => value]`: A custom implementation which is called
+     * with `code` and `context` as arguments to return the evaluated value.
+     *
+     * `class`: A class similar to nodejs vm.Script. It will be created with `code` as constructor argument and the code
+     * is evaluated by calling `runInNewContext` with `context`.
+     *
+     * @default 'safe'
+     */
+    eval?: 'safe' | 'native' | boolean | ((code: string, context: object) => any) | typeof EvalClass
+    /**
+     * Ignore errors while evaluating JSONPath expression.
+     *
+     * `true`: Don't break entire search if an error occurs while evaluating JSONPath expression on one key/value pair.
+     *
+     * `false`: Break entire search if an error occurs while evaluating JSONPath expression on one key/value pair.
+     *
+     * @default false
+     *
+     */
+    ignoreEvalErrors?: boolean
+    /**
+     * In the event that a query could be made to return the root node,
+     * this allows the parent of that root node to be returned within results.
+     *
+     * @default null
+     */
+    parent?: null | any
+    /**
+     * In the event that a query could be made to return the root node,
+     * this allows the parentProperty of that root node to be returned within
+     * results.
+     *
+     * @default null
+     */
+    parentProperty?: null | any
+    /**
+     * If supplied, a callback will be called immediately upon retrieval of
+     * an end point value.
+     *
+     * The three arguments supplied will be the value of the payload
+     * (according to `resultType`), the type of the payload (whether it is
+     * a normal "value" or a "property" name), and a full payload object
+     * (with all `resultType`s).
+     *
+     * @default undefined
+     */
+    callback?: undefined | JSONPathCallback
+    /**
+     * In the current absence of JSON Schema support,
+     * one can determine types beyond the built-in types by adding the
+     * perator `@other()` at the end of one's query.
+     *
+     * If such a path is encountered, the `otherTypeCallback` will be invoked
+     * with the value of the item, its path, its parent, and its parent's
+     * property name, and it should return a boolean indicating whether the
+     * supplied value belongs to the "other" type or not (or it may handle
+     * transformations and return false).
+     *
+     * @default undefined
+     *   <A function that throws an error when `@other()` is encountered>
+     */
+    otherTypeCallback?: undefined | JSONPathOtherTypeCallback
+  }
+
+  interface JSONPathOptionsAutoStart extends JSONPathOptions {
+    autostart: false
+  }
+
+  interface JSONPathCallable {
+    <T = any>(options: JSONPathOptionsAutoStart): JSONPathClass
+    <T = any>(options: JSONPathOptions): T
+
+    <T = any>(
+        path: JSONPathOptions['path'],
+        json: JSONPathOptions['json'],
+        callback: JSONPathOptions['callback'],
+        otherTypeCallback: JSONPathOptions['otherTypeCallback']
+    ): T
+  }
+
+  class JSONPathClass {
+    /**
+     * Exposes the cache object for those who wish to preserve and reuse
+     *   it for optimization purposes.
+     */
+    cache: any
+
+    /**
+     * Accepts a normalized or unnormalized path as string and
+     * converts to an array: for example,
+     * `['$', 'aProperty', 'anotherProperty']`.
+     */
+    toPathArray(path: string): string[]
+
+    /**
+     * Accepts a path array and converts to a normalized path string.
+     * The string will be in a form like:
+     *   `$['aProperty']['anotherProperty][0]`.
+     * The JSONPath terminal constructions `~` and `^` and type operators
+     *   like `@string()` are silently stripped.
+     */
+    toPathString(path: string[]): string
+
+    /**
+     * Accepts a path array and converts to a JSON Pointer.
+     *
+     * The string will be in a form like: `/aProperty/anotherProperty/0`
+     * (with any `~` and `/` internal characters escaped as per the JSON
+     * Pointer spec).
+     *
+     * The JSONPath terminal constructions `~` and `^` and type operators
+     *   like `@string()` are silently stripped.
+     */
+    toPointer(path: string[]): any
+
+    evaluate(
+        path: JSONPathOptions['path'],
+        json: JSONPathOptions['json'],
+        callback: JSONPathOptions['callback'],
+        otherTypeCallback: JSONPathOptions['otherTypeCallback']
+    ): any
+    evaluate(options: {
+        path: JSONPathOptions['path'],
+        json: JSONPathOptions['json'],
+        callback: JSONPathOptions['callback'],
+        otherTypeCallback: JSONPathOptions['otherTypeCallback']
+    }): any
+  }
+
+  type JSONPathType = JSONPathCallable & JSONPathClass
+
+  export const JSONPath: JSONPathType
+}