cdk8s 2.3.9 → 2.3.12

package/node_modules/fast-json-patch/module/duplex.mjs

@@ -0,0 +1,176 @@
+/*!
+ * https://github.com/Starcounter-Jack/JSON-Patch
+ * (c) 2017-2021 Joachim Wester
+ * MIT license
+ */
+import { _deepClone, _objectKeys, escapePathComponent, hasOwnProperty } from './helpers.mjs';
+import { applyPatch } from './core.mjs';
+var beforeDict = new WeakMap();
+var Mirror = /** @class */ (function () {
+    function Mirror(obj) {
+        this.observers = new Map();
+        this.obj = obj;
+    }
+    return Mirror;
+}());
+var ObserverInfo = /** @class */ (function () {
+    function ObserverInfo(callback, observer) {
+        this.callback = callback;
+        this.observer = observer;
+    }
+    return ObserverInfo;
+}());
+function getMirror(obj) {
+    return beforeDict.get(obj);
+}
+function getObserverFromMirror(mirror, callback) {
+    return mirror.observers.get(callback);
+}
+function removeObserverFromMirror(mirror, observer) {
+    mirror.observers.delete(observer.callback);
+}
+/**
+ * Detach an observer from an object
+ */
+export function unobserve(root, observer) {
+    observer.unobserve();
+}
+/**
+ * Observes changes made to an object, which can then be retrieved using generate
+ */
+export function observe(obj, callback) {
+    var patches = [];
+    var observer;
+    var mirror = getMirror(obj);
+    if (!mirror) {
+        mirror = new Mirror(obj);
+        beforeDict.set(obj, mirror);
+    }
+    else {
+        var observerInfo = getObserverFromMirror(mirror, callback);
+        observer = observerInfo && observerInfo.observer;
+    }
+    if (observer) {
+        return observer;
+    }
+    observer = {};
+    mirror.value = _deepClone(obj);
+    if (callback) {
+        observer.callback = callback;
+        observer.next = null;
+        var dirtyCheck = function () {
+            generate(observer);
+        };
+        var fastCheck = function () {
+            clearTimeout(observer.next);
+            observer.next = setTimeout(dirtyCheck);
+        };
+        if (typeof window !== 'undefined') { //not Node
+            window.addEventListener('mouseup', fastCheck);
+            window.addEventListener('keyup', fastCheck);
+            window.addEventListener('mousedown', fastCheck);
+            window.addEventListener('keydown', fastCheck);
+            window.addEventListener('change', fastCheck);
+        }
+    }
+    observer.patches = patches;
+    observer.object = obj;
+    observer.unobserve = function () {
+        generate(observer);
+        clearTimeout(observer.next);
+        removeObserverFromMirror(mirror, observer);
+        if (typeof window !== 'undefined') {
+            window.removeEventListener('mouseup', fastCheck);
+            window.removeEventListener('keyup', fastCheck);
+            window.removeEventListener('mousedown', fastCheck);
+            window.removeEventListener('keydown', fastCheck);
+            window.removeEventListener('change', fastCheck);
+        }
+    };
+    mirror.observers.set(callback, new ObserverInfo(callback, observer));
+    return observer;
+}
+/**
+ * Generate an array of patches from an observer
+ */
+export function generate(observer, invertible) {
+    if (invertible === void 0) { invertible = false; }
+    var mirror = beforeDict.get(observer.object);
+    _generate(mirror.value, observer.object, observer.patches, "", invertible);
+    if (observer.patches.length) {
+        applyPatch(mirror.value, observer.patches);
+    }
+    var temp = observer.patches;
+    if (temp.length > 0) {
+        observer.patches = [];
+        if (observer.callback) {
+            observer.callback(temp);
+        }
+    }
+    return temp;
+}
+// Dirty check if obj is different from mirror, generate patches and update mirror
+function _generate(mirror, obj, patches, path, invertible) {
+    if (obj === mirror) {
+        return;
+    }
+    if (typeof obj.toJSON === "function") {
+        obj = obj.toJSON();
+    }
+    var newKeys = _objectKeys(obj);
+    var oldKeys = _objectKeys(mirror);
+    var changed = false;
+    var deleted = false;
+    //if ever "move" operation is implemented here, make sure this test runs OK: "should not generate the same patch twice (move)"
+    for (var t = oldKeys.length - 1; t >= 0; t--) {
+        var key = oldKeys[t];
+        var oldVal = mirror[key];
+        if (hasOwnProperty(obj, key) && !(obj[key] === undefined && oldVal !== undefined && Array.isArray(obj) === false)) {
+            var newVal = obj[key];
+            if (typeof oldVal == "object" && oldVal != null && typeof newVal == "object" && newVal != null && Array.isArray(oldVal) === Array.isArray(newVal)) {
+                _generate(oldVal, newVal, patches, path + "/" + escapePathComponent(key), invertible);
+            }
+            else {
+                if (oldVal !== newVal) {
+                    changed = true;
+                    if (invertible) {
+                        patches.push({ op: "test", path: path + "/" + escapePathComponent(key), value: _deepClone(oldVal) });
+                    }
+                    patches.push({ op: "replace", path: path + "/" + escapePathComponent(key), value: _deepClone(newVal) });
+                }
+            }
+        }
+        else if (Array.isArray(mirror) === Array.isArray(obj)) {
+            if (invertible) {
+                patches.push({ op: "test", path: path + "/" + escapePathComponent(key), value: _deepClone(oldVal) });
+            }
+            patches.push({ op: "remove", path: path + "/" + escapePathComponent(key) });
+            deleted = true; // property has been deleted
+        }
+        else {
+            if (invertible) {
+                patches.push({ op: "test", path: path, value: mirror });
+            }
+            patches.push({ op: "replace", path: path, value: obj });
+            changed = true;
+        }
+    }
+    if (!deleted && newKeys.length == oldKeys.length) {
+        return;
+    }
+    for (var t = 0; t < newKeys.length; t++) {
+        var key = newKeys[t];
+        if (!hasOwnProperty(mirror, key) && obj[key] !== undefined) {
+            patches.push({ op: "add", path: path + "/" + escapePathComponent(key), value: _deepClone(obj[key]) });
+        }
+    }
+}
+/**
+ * Create an array of patches from the differences in two objects
+ */
+export function compare(tree1, tree2, invertible) {
+    if (invertible === void 0) { invertible = false; }
+    var patches = [];
+    _generate(tree1, tree2, patches, '', invertible);
+    return patches;
+}

package/node_modules/fast-json-patch/module/helpers.d.ts

@@ -0,0 +1,41 @@
+/*!
+ * https://github.com/Starcounter-Jack/JSON-Patch
+ * (c) 2017-2022 Joachim Wester
+ * MIT licensed
+ */
+export declare function hasOwnProperty(obj: any, key: any): any;
+export declare function _objectKeys(obj: any): any[];
+/**
+* Deeply clone the object.
+* https://jsperf.com/deep-copy-vs-json-stringify-json-parse/25 (recursiveDeepCopy)
+* @param  {any} obj value to clone
+* @return {any} cloned obj
+*/
+export declare function _deepClone(obj: any): any;
+export declare function isInteger(str: string): boolean;
+/**
+* Escapes a json pointer path
+* @param path The raw pointer
+* @return the Escaped path
+*/
+export declare function escapePathComponent(path: string): string;
+/**
+ * Unescapes a json pointer path
+ * @param path The escaped pointer
+ * @return The unescaped path
+ */
+export declare function unescapePathComponent(path: string): string;
+export declare function _getPathRecursive(root: Object, obj: Object): string;
+export declare function getPath(root: Object, obj: Object): string;
+/**
+* Recursively checks whether an object has any undefined values inside.
+*/
+export declare function hasUndefined(obj: any): boolean;
+export declare type JsonPatchErrorName = 'SEQUENCE_NOT_AN_ARRAY' | 'OPERATION_NOT_AN_OBJECT' | 'OPERATION_OP_INVALID' | 'OPERATION_PATH_INVALID' | 'OPERATION_FROM_REQUIRED' | 'OPERATION_VALUE_REQUIRED' | 'OPERATION_VALUE_CANNOT_CONTAIN_UNDEFINED' | 'OPERATION_PATH_CANNOT_ADD' | 'OPERATION_PATH_UNRESOLVABLE' | 'OPERATION_FROM_UNRESOLVABLE' | 'OPERATION_PATH_ILLEGAL_ARRAY_INDEX' | 'OPERATION_VALUE_OUT_OF_BOUNDS' | 'TEST_OPERATION_FAILED';
+export declare class PatchError extends Error {
+    name: JsonPatchErrorName;
+    index?: number;
+    operation?: any;
+    tree?: any;
+    constructor(message: string, name: JsonPatchErrorName, index?: number, operation?: any, tree?: any);
+}

package/node_modules/fast-json-patch/module/helpers.mjs

@@ -0,0 +1,171 @@
+/*!
+ * https://github.com/Starcounter-Jack/JSON-Patch
+ * (c) 2017-2022 Joachim Wester
+ * MIT licensed
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+export function hasOwnProperty(obj, key) {
+    return _hasOwnProperty.call(obj, key);
+}
+export function _objectKeys(obj) {
+    if (Array.isArray(obj)) {
+        var keys_1 = new Array(obj.length);
+        for (var k = 0; k < keys_1.length; k++) {
+            keys_1[k] = "" + k;
+        }
+        return keys_1;
+    }
+    if (Object.keys) {
+        return Object.keys(obj);
+    }
+    var keys = [];
+    for (var i in obj) {
+        if (hasOwnProperty(obj, i)) {
+            keys.push(i);
+        }
+    }
+    return keys;
+}
+;
+/**
+* Deeply clone the object.
+* https://jsperf.com/deep-copy-vs-json-stringify-json-parse/25 (recursiveDeepCopy)
+* @param  {any} obj value to clone
+* @return {any} cloned obj
+*/
+export function _deepClone(obj) {
+    switch (typeof obj) {
+        case "object":
+            return JSON.parse(JSON.stringify(obj)); //Faster than ES5 clone - http://jsperf.com/deep-cloning-of-objects/5
+        case "undefined":
+            return null; //this is how JSON.stringify behaves for array items
+        default:
+            return obj; //no need to clone primitives
+    }
+}
+//3x faster than cached /^\d+$/.test(str)
+export function isInteger(str) {
+    var i = 0;
+    var len = str.length;
+    var charCode;
+    while (i < len) {
+        charCode = str.charCodeAt(i);
+        if (charCode >= 48 && charCode <= 57) {
+            i++;
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+/**
+* Escapes a json pointer path
+* @param path The raw pointer
+* @return the Escaped path
+*/
+export function escapePathComponent(path) {
+    if (path.indexOf('/') === -1 && path.indexOf('~') === -1)
+        return path;
+    return path.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+/**
+ * Unescapes a json pointer path
+ * @param path The escaped pointer
+ * @return The unescaped path
+ */
+export function unescapePathComponent(path) {
+    return path.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+export function _getPathRecursive(root, obj) {
+    var found;
+    for (var key in root) {
+        if (hasOwnProperty(root, key)) {
+            if (root[key] === obj) {
+                return escapePathComponent(key) + '/';
+            }
+            else if (typeof root[key] === 'object') {
+                found = _getPathRecursive(root[key], obj);
+                if (found != '') {
+                    return escapePathComponent(key) + '/' + found;
+                }
+            }
+        }
+    }
+    return '';
+}
+export function getPath(root, obj) {
+    if (root === obj) {
+        return '/';
+    }
+    var path = _getPathRecursive(root, obj);
+    if (path === '') {
+        throw new Error("Object not found in root");
+    }
+    return "/" + path;
+}
+/**
+* Recursively checks whether an object has any undefined values inside.
+*/
+export function hasUndefined(obj) {
+    if (obj === undefined) {
+        return true;
+    }
+    if (obj) {
+        if (Array.isArray(obj)) {
+            for (var i_1 = 0, len = obj.length; i_1 < len; i_1++) {
+                if (hasUndefined(obj[i_1])) {
+                    return true;
+                }
+            }
+        }
+        else if (typeof obj === "object") {
+            var objKeys = _objectKeys(obj);
+            var objKeysLength = objKeys.length;
+            for (var i = 0; i < objKeysLength; i++) {
+                if (hasUndefined(obj[objKeys[i]])) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+function patchErrorMessageFormatter(message, args) {
+    var messageParts = [message];
+    for (var key in args) {
+        var value = typeof args[key] === 'object' ? JSON.stringify(args[key], null, 2) : args[key]; // pretty print
+        if (typeof value !== 'undefined') {
+            messageParts.push(key + ": " + value);
+        }
+    }
+    return messageParts.join('\n');
+}
+var PatchError = /** @class */ (function (_super) {
+    __extends(PatchError, _super);
+    function PatchError(message, name, index, operation, tree) {
+        var _newTarget = this.constructor;
+        var _this = _super.call(this, patchErrorMessageFormatter(message, { name: name, index: index, operation: operation, tree: tree })) || this;
+        _this.name = name;
+        _this.index = index;
+        _this.operation = operation;
+        _this.tree = tree;
+        Object.setPrototypeOf(_this, _newTarget.prototype); // restore prototype chain, see https://stackoverflow.com/a/48342359
+        _this.message = patchErrorMessageFormatter(message, { name: name, index: index, operation: operation, tree: tree });
+        return _this;
+    }
+    return PatchError;
+}(Error));
+export { PatchError };

package/node_modules/fast-json-patch/package.json

@@ -1,69 +1,65 @@
 {
-  "name": "fast-json-patch",
-  "version": "2.2.1",
-  "description": "Fast implementation of JSON-Patch (RFC-6902) with duplex (observe changes) capabilities",
-  "homepage": "https://github.com/Starcounter-Jack/JSON-Patch",
-  "keywords": [
-    "json",
-    "patch",
-    "http",
-    "rest"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/Starcounter-Jack/JSON-Patch.git"
-  },
-  "bugs": {
-    "url": "https://github.com/Starcounter-Jack/JSON-Patch/issues"
-  },
-  "author": {
-    "name": "Joachim Wester",
-    "email": "joachimwester@me.com",
-    "url": "http://www.starcounter.com/"
-  },
-  "license": "MIT",
-  "main": "lib/duplex.js",
-  "typings": "lib/duplex.d.ts",
-  "engines": {
-    "node": ">= 0.4.0"
-  },
-  "devDependencies": {
-    "benchmark": "^2.1.4",
-    "bluebird": "^3.5.5",
-    "bluebird-retry": "^0.11.0",
-    "chalk": "^2.4.2",
-    "fast-deep-equal": "^2.0.1",
-    "http-server": "^0.11.1",
-    "jasmine": "^3.4.0",
-    "jsdom": "^15.1.1",
-    "jsonfile": "^5.0.0",
-    "request": "^2.88.0",
-    "sauce-connect-launcher": "^1.2.7",
-    "saucelabs": "^2.1.9",
-    "selenium-webdriver": "^4.0.0-alpha.4",
-    "typescript": "~3.5.2",
-    "underscore": "^1.9.1",
-    "webpack": "^4.35.0",
-    "webpack-cli": "^3.3.5"
-  },
-  "scripts": {
-    "tsc": "tsc",
-    "version": "tsc && webpack && git add -A",
-    "build": "tsc && webpack",
-    "serve": "http-server -p 5000 --silent",
-    "tsc-watch": "tsc -w",
-    "test": "npm run tsc && npm run test-core && npm run test-duplex && npm run test-commonjs && npm run test-webpack-import && npm run test-typings",
-    "test-sauce": "npm run build && node test/Sauce/Runner.js",
-    "test-commonjs": "jasmine test/spec/commonjs/requireSpec.js",
-    "test-webpack-import": "webpack --env.NODE_ENV=test && jasmine test/spec/webpack/importSpec.build.js",
-    "test-typings": "tsc test/spec/typings/typingsSpec.ts",
-    "test-duplex": "jasmine DUPLEX=yes JASMINE_CONFIG_PATH=test/jasmine.json",
-    "test-core": "jasmine  DUPLEX=no JASMINE_CONFIG_PATH=test/jasmine.json test/spec/jsonPatchTestsSpec.js test/spec/coreSpec.js test/spec/validateSpec.js",
-    "bench": "npm run bench-core && npm run bench-duplex",
-    "bench-core": "node test/spec/coreBenchmark.js",
-    "bench-duplex": "node test/spec/coreBenchmark.js DUPLEX=yes && node test/spec/duplexBenchmark.js"
-  },
-  "dependencies": {
-    "fast-deep-equal": "^2.0.1"
-  }
+    "name": "fast-json-patch",
+    "version": "3.1.1",
+    "description": "Fast implementation of JSON-Patch (RFC-6902) with duplex (observe changes) capabilities",
+    "homepage": "https://github.com/Starcounter-Jack/JSON-Patch",
+    "keywords": [
+        "json",
+        "patch",
+        "http",
+        "rest"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/Starcounter-Jack/JSON-Patch.git"
+    },
+    "bugs": {
+        "url": "https://github.com/Starcounter-Jack/JSON-Patch/issues"
+    },
+    "author": {
+        "name": "Joachim Wester",
+        "email": "joachimwester@me.com",
+        "url": "http://www.starcounter.com/"
+    },
+    "license": "MIT",
+    "main": "index.js",
+    "module": "index.mjs",
+    "typings": "index.d.ts",
+    "devDependencies": {
+        "benchmark": "^2.1.4",
+        "bluebird": "^3.5.5",
+        "bluebird-retry": "^0.11.0",
+        "chalk": "^2.4.2",
+        "event-target-shim": "^5.0.1",
+        "fast-deep-equal": "^2.0.1",
+        "http-server": "^0.12.3",
+        "jasmine": "^3.4.0",
+        "request": "^2.88.0",
+        "sauce-connect-launcher": "^1.2.7",
+        "saucelabs": "^2.1.9",
+        "selenium-webdriver": "^4.0.0-alpha.4",
+        "typescript": "~3.5.2",
+        "webpack": "^4.35.0",
+        "webpack-cli": "^3.3.5"
+    },
+    "scripts": {
+        "tsc": "npm run tsc-common && npm run tsc-module",
+        "tsc-common": "tsc",
+        "tsc-module": "tsc --module esnext --moduleResolution node --outDir \"module/\" && npm run tsc-to-mjs",
+        "tsc-to-mjs": "bash tsc-to-mjs.sh",
+        "version": "npm run tsc && webpack && git add -A",
+        "build": "npm run tsc && webpack",
+        "serve": "http-server -p 5000 --silent",
+        "tsc-watch": "tsc -w",
+        "test": "npm run tsc && npm run test-core && npm run test-duplex && npm run test-commonjs && npm run test-webpack-import && npm run test-typings",
+        "test-sauce": "npm run build && node test/Sauce/Runner.js",
+        "test-commonjs": "jasmine test/spec/commonjs/requireSpec.js",
+        "test-webpack-import": "webpack --env.NODE_ENV=test && jasmine test/spec/webpack/importSpec.build.js",
+        "test-typings": "tsc test/spec/typings/typingsSpec.ts",
+        "test-duplex": "node --experimental-modules jasmine-run.mjs test/**/*[sS]pec.mjs",
+        "test-core": "node --experimental-modules jasmine-run.mjs 'test/spec/{jsonPatchTestsSpec,coreSpec,validateSpec}.mjs'",
+        "bench": "npm run bench-core && npm run bench-duplex",
+        "bench-core": "node test/spec/coreBenchmark.js",
+        "bench-duplex": "node test/spec/coreBenchmark.js && node test/spec/duplexBenchmark.js"
+    }
 }

package/node_modules/fast-json-patch/tsc-to-mjs.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+cd module
+mv core.js core.mjs && mv duplex.js duplex.mjs && mv helpers.js helpers.mjs
+# Unlike Ubuntu, OS X requires the extension to be explicitly specified
+# https://myshittycode.com/2014/07/24/os-x-sed-extra-characters-at-the-end-of-l-command-error/
+if [[ "$OSTYPE" == "darwin"* ]]; then
+  sed -i '' 's/\.js/\.mjs/g' duplex.mjs core.mjs
+else
+  sed -i 's/\.js/\.mjs/g' duplex.mjs core.mjs
+fi

package/node_modules/fast-json-patch/webpack.config.js

@@ -22,7 +22,7 @@ module.exports = env => {
   else {
     return [
       {
-        entry: './lib/duplex.js',
+        entry: './index.js',
         mode: 'production',
         optimization: {
           minimize: false
@@ -40,7 +40,7 @@ module.exports = env => {
         ]
       },
       {
-        entry: './lib/duplex.js',
+        entry: './index.js',
         mode: 'production',
         output: {
           filename: 'fast-json-patch.min.js',
@@ -61,4 +61,3 @@ module.exports = env => {
 
 
 
-

package/package.json

@@ -64,7 +64,7 @@
     "json-schema": "^0.4.0",
     "json-schema-to-typescript": "^10.1.5",
     "npm-check-updates": "^12",
-    "projen": "^0.56.36",
+    "projen": "^0.56.38",
     "standard-version": "^9",
     "ts-jest": "^27",
     "typescript": "^4.7.2"
@@ -73,7 +73,7 @@
     "constructs": "^10"
   },
   "dependencies": {
-    "fast-json-patch": "^2.2.1",
+    "fast-json-patch": "^3.1.1",
     "follow-redirects": "^1.15.1",
     "yaml": "2.0.0-7"
   },
@@ -96,7 +96,7 @@
   },
   "main": "lib/index.js",
   "license": "Apache-2.0",
-  "version": "2.3.9",
+  "version": "2.3.12",
   "jest": {
     "testMatch": [
       "<rootDir>/src/**/__tests__/**/*.ts?(x)",

package/releasetag.txt

@@ -1 +1 @@
-v2.3.9
+v2.3.12

package/version.txt

@@ -1 +1 @@
-2.3.9
+2.3.12

package/node_modules/fast-json-patch/lib/duplex.d.ts

@@ -1,63 +0,0 @@
-/*!
- * https://github.com/Starcounter-Jack/JSON-Patch
- * (c) 2017 Joachim Wester
- * MIT license
- */
-import { _deepClone, escapePathComponent } from './helpers';
-import { applyPatch, Operation } from './core';
-export { applyOperation, applyPatch, applyReducer, getValueByPointer, Operation, AddOperation, RemoveOperation, ReplaceOperation, MoveOperation, CopyOperation, TestOperation, GetOperation, validate, validator, OperationResult } from './core';
-export { PatchError as JsonPatchError, _deepClone as deepClone, escapePathComponent, unescapePathComponent } from './helpers';
-export interface Observer<T> {
-    object: T;
-    patches: Operation[];
-    unobserve: () => void;
-    callback: (patches: Operation[]) => void;
-}
-/**
- * Detach an observer from an object
- */
-export declare function unobserve<T>(root: T, observer: Observer<T>): void;
-/**
- * Observes changes made to an object, which can then be retrieved using generate
- */
-export declare function observe<T>(obj: Object | Array<T>, callback?: (patches: Operation[]) => void): Observer<T>;
-/**
- * Generate an array of patches from an observer
- */
-export declare function generate<T>(observer: Observer<Object>, invertible?: boolean): Operation[];
-/**
- * Create an array of patches from the differences in two objects
- */
-export declare function compare(tree1: Object | Array<any>, tree2: Object | Array<any>, invertible?: boolean): Operation[];
-/**
- * Default export for backwards compat
- */
-import * as core from './core';
-import { PatchError as JsonPatchError, unescapePathComponent } from './helpers';
-declare const _default: {
-    unobserve: typeof unobserve;
-    observe: typeof observe;
-    generate: typeof generate;
-    compare: typeof compare;
-    JsonPatchError: typeof JsonPatchError;
-    deepClone: typeof _deepClone;
-    escapePathComponent: typeof escapePathComponent;
-    unescapePathComponent: typeof unescapePathComponent;
-    getValueByPointer(document: any, pointer: string): any;
-    applyOperation<T>(document: T, operation: Operation, validateOperation?: boolean | core.Validator<T>, mutateDocument?: boolean, banPrototypeModifications?: boolean, index?: number): core.OperationResult<T>;
-    applyPatch<T>(document: T, patch: Operation[], validateOperation?: boolean | core.Validator<T>, mutateDocument?: boolean, banPrototypeModifications?: boolean): core.PatchResult<T>;
-    applyReducer<T>(document: T, operation: Operation, index: number): T;
-    validator(operation: Operation, index: number, document?: any, existingPathFragment?: string): void;
-    validate<T>(sequence: Operation[], document?: T, externalValidator?: core.Validator<T>): JsonPatchError;
-    default: {
-        JsonPatchError: typeof JsonPatchError;
-        deepClone: typeof _deepClone;
-        getValueByPointer: typeof core.getValueByPointer;
-        applyOperation: typeof core.applyOperation;
-        applyPatch: typeof applyPatch;
-        applyReducer: typeof core.applyReducer;
-        validator: typeof core.validator;
-        validate: typeof core.validate;
-    };
-};
-export default _default;