text: define([],function(){
      var __extends = (this && this.__extends) || function (d, b) {
          for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
      /*!
       * https://github.com/Starcounter-Jack/JSON-Patch
       * (c) 2017 Joachim Wester
       * MIT license
       */
      var _hasOwnProperty = Object.prototype.hasOwnProperty;
      function hasOwnProperty(obj, key) {
          return _hasOwnProperty.call(obj, key);
      }
      function _objectKeys(obj) {
          if (Array.isArray(obj)) {
              var keys = new Array(obj.length);
              for (var k = 0; k < keys.length; k++) {
                  keys[k] = "" + k;
              }
              return keys;
          }
          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
      */
      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)
      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
      */
      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
       */
      function unescapePathComponent(path) {
          return path.replace(/~1/g, '/').replace(/~0/g, '~');
      }
      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 '';
      }
      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.
      */
      function hasUndefined(obj) {
          if (obj === undefined) {
              return true;
          }
          if (obj) {
              if (Array.isArray(obj)) {
                  for (var i = 0, len = obj.length; i < len; i++) {
                      if (hasUndefined(obj[i])) {
                          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;
      }
      var PatchError = (function (_super) {
          __extends(PatchError, _super);
          function PatchError(message, name, index, operation, tree) {
              _super.call(this, message);
              this.message = message;
              this.name = name;
              this.index = index;
              this.operation = operation;
              this.tree = tree;
          }
          return PatchError;
      }(Error));
  
      return {
          hasOwnProperty,
          PatchError,
          hasUndefined,
          getPath,
          unescapePathComponent,
          escapePathComponent,
          isInteger,
          _objectKeys,
          _deepClone,
          _getPathRecursive
      };
  
  });