@ui5/webcomponents-localization 1.22.0-rc.1 → 1.22.0-rc.2

package/dist/sap/base/strings/formatMessage.js

@@ -1,20 +1,93 @@
-import assert from '../assert.js';
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2024 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+import assert from "../assert.js";
+/**
+ * Pattern to analyze MessageFormat strings.
+ *
+ * Group 1: captures doubled single quotes within the string
+ * Group 2: captures quoted fragments within the string.
+ *            Note that java.util.MessageFormat silently forgives a missing single quote at
+ *            the end of a pattern. This special case is handled by the RegEx as well.
+ * Group 3: captures placeholders
+ *            Checks only for numerical argument index, any remainder is ignored up to the next
+ *            closing curly brace. Nested placeholders are not accepted!
+ * Group 4: captures any remaining curly braces and indicates syntax errors
+ *
+ *                    [-1] [----- quoted string -----] [------ placeholder ------] [--]
+ * @private
+ */
 var rMessageFormat = /('')|'([^']+(?:''[^']*)*)(?:'|$)|\{([0-9]+(?:\s*,[^{}]*)?)\}|[{}]/g;
+
+/**
+ * Creates a string from a pattern by replacing placeholders with concrete values.
+ *
+ * The syntax of the pattern is inspired by (but not fully equivalent to) the
+ * java.util.MessageFormat.
+ *
+ * Placeholders have the form <code>{ integer }</code>, where any occurrence of
+ * <code>{0}</code> is replaced by the value with index 0 in <code>aValues</code>,
+ * <code>{1}</code> by the value with index 1 in <code>aValues</code> etc.
+ *
+ * To avoid interpretation of curly braces as placeholders, any non-placeholder fragment
+ * of the pattern can be enclosed in single quotes. The surrounding single quotes will be
+ * omitted from the result. Single quotes that are not meant to escape a fragment and
+ * that should appear in the result, need to be doubled. In the result, only a single
+ * single quote will occur.
+ *
+ * Example: Pattern Strings
+ * <pre>
+ *  formatMessage("Say {0}",     ["Hello"]) -> "Say Hello"    // normal use case
+ *  formatMessage("Say '{0}'",   ["Hello"]) -> "Say {0}"      // escaped placeholder
+ *  formatMessage("Say ''{0}''", ["Hello"]) -> "Say 'Hello'"  // doubled single quote
+ *  formatMessage("Say '{0}'''", ["Hello"]) -> "Say {0}'"     // doubled single quote in quoted fragment
+ * </pre>
+ * In contrast to java.util.MessageFormat, format types or format styles are not supported.
+ * Everything after the argument index and up to the first closing curly brace is ignored.
+ * Nested placeholders (as supported by java.lang.MessageFormat for the format type choice)
+ * are not ignored but reported as a parse error.
+ *
+ * This method throws an Error when the pattern syntax is not fulfilled (e.g. unbalanced curly
+ * braces, nested placeholders or a non-numerical argument index).
+ *
+ * This method can also be used as a formatter within a binding. The first part of a composite binding
+ * will be used as pattern, the following parts as aValues. If there is only one value and this
+ * value is an array it will be handled like the default described above.
+ *
+ * @function
+ * @since 1.58
+ * @alias module:sap/base/strings/formatMessage
+ * @param {string} sPattern A pattern string in the described syntax
+ * @param {any[]} [aValues=[]] The values to be used instead of the placeholders.
+ * @returns {string} The formatted result string
+ * @SecPassthrough {*|return}
+ * @public
+ */
 var fnFormatMessage = function (sPattern, aValues) {
-    assert(typeof sPattern === 'string' || sPattern instanceof String, 'pattern must be string');
-    if (arguments.length > 2 || aValues != null && !Array.isArray(aValues)) {
-        aValues = Array.prototype.slice.call(arguments, 1);
+  assert(typeof sPattern === "string" || sPattern instanceof String, "pattern must be string");
+  if (arguments.length > 2 || aValues != null && !Array.isArray(aValues)) {
+    aValues = Array.prototype.slice.call(arguments, 1);
+  }
+  aValues = aValues || [];
+  return sPattern.replace(rMessageFormat, function ($0, $1, $2, $3, offset) {
+    if ($1) {
+      // a doubled single quote in a normal string fragment
+      //   --> emit a single quote
+      return "'";
+    } else if ($2) {
+      // a quoted sequence of chars, potentially containing doubled single quotes again
+      //   --> emit with doubled single quotes replaced by a single quote
+      return $2.replace(/''/g, "'");
+    } else if ($3) {
+      // a welformed curly brace
+      //   --> emit the argument but ignore other parameters
+      return String(aValues[parseInt($3)]);
     }
-    aValues = aValues || [];
-    return sPattern.replace(rMessageFormat, function ($0, $1, $2, $3, offset) {
-        if ($1) {
-            return '\'';
-        } else if ($2) {
-            return $2.replace(/''/g, '\'');
-        } else if ($3) {
-            return String(aValues[parseInt($3)]);
-        }
-        throw new Error('formatMessage: pattern syntax error at pos. ' + offset);
-    });
+    // e.g. malformed curly braces
+    //   --> throw Error
+    throw new Error("formatMessage: pattern syntax error at pos. " + offset);
+  });
 };
 export default fnFormatMessage;

package/dist/sap/base/util/ObjectPath.js

@@ -1,21 +1,92 @@
+/**
+ * Manages an object path.
+ *
+ * The object path can be just created with {@link #.create}, then an empty nested object path will be created from
+ * the provided string. If a value is set for an object path {@link #.set} it is also created if it not already
+ * exists. Values can be retrieved from the objectpath with {@link #get}.
+ *
+ * @namespace
+ * @since 1.58
+ * @alias module:sap/base/util/ObjectPath
+ * @public
+ */ /*!
+     * OpenUI5
+     * (c) Copyright 2009-2024 SAP SE or an SAP affiliate company.
+     * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+     */
+
 var ObjectPath = {};
+
+/**
+ * The default root context for the object path.
+ *
+ * @type {object}
+ * @private
+ */
 var defaultRootContext = window;
+
+/**
+ * If the provided object path is a string, it will be split and returned as an array.
+ *
+ * @private
+ * @param {string|string[]} vObjectPath Path as string where each name is separated by '.'. Can also be an array of names.
+ * @returns {string[]} The path as an array
+ */
 function getObjectPathArray(vObjectPath) {
   return Array.isArray(vObjectPath) ? vObjectPath.slice() : vObjectPath.split(".");
 }
+
+/**
+ * Creates a object path from the provided path in the provided root context.
+ *
+ * The provided path is used to navigate through the nested objects, starting with the root context.
+ *
+ * @example
+ * var root = {};
+ * ObjectPath.create("my.test.module", root) === root.my.test.module;
+ * ObjectPath.set(["my", "test", "otherModule"], root) === root.my.test.otherModule;
+ *
+ * @public
+ * @static
+ * @param {string|string[]} vObjectPath Path as string where each name is separated by '.'. Can also be an array of names.
+ * @param {Object} [oRootContext=window] Root context where the path starts
+ * @returns {Object} The newly created context object, e.g. base.my.test.module
+ * @throws {Error} Will throw an error if a value already exists within the path and the object path cannot be set.
+ */
 ObjectPath.create = function (vObjectPath, oRootContext) {
   var oObject = oRootContext || defaultRootContext;
   var aNames = getObjectPathArray(vObjectPath);
   for (var i = 0; i < aNames.length; i++) {
     var sName = aNames[i];
-    if (oObject[sName] === null || oObject[sName] !== undefined && (typeof oObject[sName] !== "object" && typeof oObject[sName] !== "function")) {
+
+    // we only accept nested objects and functions in the ObjectPath
+    // Functions in the ObjectPath are typically constructor functions
+    if (oObject[sName] === null || oObject[sName] !== undefined && typeof oObject[sName] !== "object" && typeof oObject[sName] !== "function") {
       throw new Error("Could not set object-path for '" + aNames.join(".") + "', path segment '" + sName + "' already exists.");
     }
-    oObject[sName] = oObject[sName] || ({});
+    oObject[sName] = oObject[sName] || {};
     oObject = oObject[sName];
   }
   return oObject;
 };
+
+/**
+ * Returns a value located in the provided path.
+ * If the provided path cannot be resolved completely, <code>undefined</code> is returned.
+ *
+ * The provided object path is used to navigate through the nested objects, starting with the root context.
+ * If no root context is provided, the object path begins with <code>window</code>.
+ *
+ * @public
+ * @static
+ * @param {string|string[]} vObjectPath Path as string where each name is separated by '.'. Can also be an array of names.
+ * @param {Object} [oRootContext=window] Root context where the path starts
+ * @returns {any|undefined} Returns the value located in the provided path, or <code>undefined</code> if the path does not exist completely.
+ * @example
+ * ObjectPath.get("my.test.module", root) === root.my.test.module
+ * ObjectPath.get(["my", "test", "otherModule"], root) === root.my.test.otherModule
+ * ObjectPath.get("globalVar") === window["globalVar"];
+ */
 ObjectPath.get = function (vObjectPath, oRootContext) {
   var oObject = oRootContext || defaultRootContext;
   var aNames = getObjectPathArray(vObjectPath);
@@ -25,11 +96,32 @@ ObjectPath.get = function (vObjectPath, oRootContext) {
   }
   return oObject ? oObject[sPropertyName] : undefined;
 };
+
+/**
+ * Sets a value located in the provided path.
+ *
+ * The provided path is used to navigate through the nested objects, starting with the root context.
+ *
+ * <b>Note:</b> Ensures that the object path exists.
+ *
+ * @public
+ * @static
+ * @param {string|string[]} vObjectPath vObjectPath Path as string where each name is separated by '.'. Can also be an array of names.
+ * @param {any} vValue The value to be set in the root context's object path
+ * @param {Object} [oRootContext=window] Root context where the path starts
+ * @throws {Error} Will throw an error if a value already exists within the object path and the path cannot be set.
+ * @example
+ * var root = {};
+ * ObjectPath.set("my.test.module", "propertyValue", root);
+ * ObjectPath.set(["my", "test", "otherModule"], "otherPropertyValue", root);
+ */
 ObjectPath.set = function (vObjectPath, vValue, oRootContext) {
   oRootContext = oRootContext || defaultRootContext;
   var aNames = getObjectPathArray(vObjectPath);
   var sPropertyName = aNames.pop();
+
+  // ensure object exists
   var oObject = ObjectPath.create(aNames, oRootContext);
   oObject[sPropertyName] = vValue;
 };
-export default ObjectPath;
+export default ObjectPath;

package/dist/sap/base/util/Version.js

@@ -0,0 +1,157 @@
+// @evo-todo make it a simple object with immutable properties (Object.defineProperties)
+
+// -------------------------- VERSION -------------------------------------
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2024 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+
+var rVersion = /^[0-9]+(?:\.([0-9]+)(?:\.([0-9]+))?)?(.*)$/;
+
+/**
+ * Returns a Version instance created from the given parameters.
+ *
+ * This function can either be called as a constructor (using <code>new</code>) or as a normal function.
+ * It always returns an immutable Version instance.
+ *
+ * The parts of the version number (major, minor, patch, suffix) can be provided in several ways:
+ * <ul>
+ * <li>Version("1.2.3-SNAPSHOT")    - as a dot-separated string. Any non-numerical char or a dot followed
+ *                                    by a non-numerical char starts the suffix portion. Any missing major,
+ *                                    minor or patch versions will be set to 0.</li>
+ * <li>Version(1,2,3,"-SNAPSHOT")   - as individual parameters. Major, minor and patch must be integer numbers
+ *                                    or empty, suffix must be a string not starting with digits.</li>
+ * <li>Version([1,2,3,"-SNAPSHOT"]) - as an array with the individual parts. The same type restrictions apply
+ *                                    as before.</li>
+ * <li>Version(otherVersion)        - as a Version instance (cast operation). Returns the given instance instead
+ *                                    of creating a new one.</li>
+ * </ul>
+ *
+ * To keep the code size small, this implementation mainly validates the single string variant.
+ * All other variants are only validated to some degree. It is the responsibility of the caller to
+ * provide proper parts.
+ *
+ * @param {int|string|any[]|module:sap/base/util/Version} vMajor the major part of the version (int) or any of the single
+ *        parameter variants explained above.
+ * @param {int} iMinor the minor part of the version number
+ * @param {int} iPatch the patch part of the version number
+ * @param {string} sSuffix the suffix part of the version number
+ * @class Represents a version consisting of major, minor, patch version, and suffix, for example '1.2.7-SNAPSHOT'.
+ * @since 1.58
+ * @alias module:sap/base/util/Version
+ * @public
+ */
+function Version(vMajor, iMinor, iPatch, sSuffix) {
+  if (vMajor instanceof Version) {
+    // note: even a constructor may return a value different from 'this'
+    return vMajor;
+  }
+  if (!(this instanceof Version)) {
+    // act as a cast operator when called as function (not as a constructor)
+    return new Version(vMajor, iMinor, iPatch, sSuffix);
+  }
+  var m;
+  if (typeof vMajor === "string") {
+    m = rVersion.exec(vMajor);
+  } else if (Array.isArray(vMajor)) {
+    m = vMajor;
+  } else {
+    m = arguments;
+  }
+  m = m || [];
+  function norm(v) {
+    v = parseInt(v);
+    return isNaN(v) ? 0 : v;
+  }
+  vMajor = norm(m[0]);
+  iMinor = norm(m[1]);
+  iPatch = norm(m[2]);
+  sSuffix = String(m[3] || "");
+
+  /**
+   * Returns a string representation of this version.
+   *
+   * @return {string} a string representation of this version.
+   * @public
+   */
+  this.toString = function () {
+    return vMajor + "." + iMinor + "." + iPatch + sSuffix;
+  };
+
+  /**
+   * Returns the major version part of this version.
+   *
+   * @return {int} the major version part of this version
+   * @public
+   */
+  this.getMajor = function () {
+    return vMajor;
+  };
+
+  /**
+   * Returns the minor version part of this version.
+   *
+   * @return {int} the minor version part of this version
+   * @public
+   */
+  this.getMinor = function () {
+    return iMinor;
+  };
+
+  /**
+   * Returns the patch (or micro) version part of this version.
+   *
+   * @return {int} the patch version part of this version
+   * @public
+   */
+  this.getPatch = function () {
+    return iPatch;
+  };
+
+  /**
+   * Returns the version suffix of this version.
+   *
+   * @return {string} the version suffix of this version
+   * @public
+   */
+  this.getSuffix = function () {
+    return sSuffix;
+  };
+
+  /**
+   * Compares this version with a given one.
+   *
+   * The version with which this version should be compared can be given as a <code>sap/base/util/Version</code> instance,
+   * as a string (e.g. <code>v.compareto("1.4.5")</code>). Or major, minor, patch and suffix values can be given as
+   * separate parameters (e.g. <code>v.compareTo(1, 4, 5)</code>) or in an array (e.g. <code>v.compareTo([1, 4, 5])</code>).
+   *
+   * @return {int} 0, if the given version is equal to this version, a negative value if the given other version is greater
+   *               and a positive value otherwise
+   * @public
+   */
+  this.compareTo = function () {
+    var vOther = Version.apply(window, arguments);
+    /*eslint-disable no-nested-ternary */
+    return vMajor - vOther.getMajor() || iMinor - vOther.getMinor() || iPatch - vOther.getPatch() || (sSuffix < vOther.getSuffix() ? -1 : sSuffix === vOther.getSuffix() ? 0 : 1);
+    /*eslint-enable no-nested-ternary */
+  };
+}
+
+/**
+ * Checks whether this version is in the range of the given interval (start inclusive, end exclusive).
+ *
+ * The boundaries against which this version should be checked can be given as  <code>sap/base/util/Version</code>
+ * instances (e.g. <code>v.inRange(v1, v2)</code>), as strings (e.g. <code>v.inRange("1.4", "2.7")</code>)
+ * or as arrays (e.g. <code>v.inRange([1,4], [2,7])</code>).
+ *
+ * @param {string|any[]|module:sap/base/util/Version} vMin the start of the range (inclusive)
+ * @param {string|any[]|module:sap/base/util/Version} vMax the end of the range (exclusive)
+ * @return {boolean} <code>true</code> if this version is greater or equal to <code>vMin</code> and smaller
+ *                   than <code>vMax</code>, <code>false</code> otherwise.
+ * @public
+ */
+Version.prototype.inRange = function (vMin, vMax) {
+  return this.compareTo(vMin) >= 0 && this.compareTo(vMax) < 0;
+};
+export default Version;

package/dist/sap/base/util/_merge.js

@@ -1,32 +1,89 @@
-import isPlainObject from './isPlainObject.js';
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2024 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+import isPlainObject from "./isPlainObject.js";
 var oToken = Object.create(null);
+
+/**
+ * Performs object extension by merging source objects into a target object.
+ *
+ * @example
+ * var oMerged = _merge(true, false, {}, {prop1:1}, {prop2:2});
+ *
+ * @function
+ * @since 1.71
+ * @private
+ * @alias module:sap/base/util/_merge
+ * @param {boolean} deep Shallow copy or deep merge
+ * @param {boolean} skipUndefined Whether <code>undefined</code> values will be skipped, otherwise <code>undefined</code> values will overwrite existing values
+ * @param {object} target The object that will receive new properties
+ * @param {...object} [source] One or more objects which get merged into the target object
+ * @return {object} the target object which is the result of the merge
+ */
 var fnMerge = function () {
-    var src, copyIsArray, copy, name, options, clone, target = arguments[2] || {}, i = 3, length = arguments.length, deep = arguments[0] || false, skipToken = arguments[1] ? undefined : oToken;
-    if (typeof target !== 'object' && typeof target !== 'function') {
-        target = {};
-    }
-    for (; i < length; i++) {
-        if ((options = arguments[i]) != null) {
-            for (name in options) {
-                src = target[name];
-                copy = options[name];
-                if (name === '__proto__' || target === copy) {
-                    continue;
-                }
-                if (deep && copy && (isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {
-                    if (copyIsArray) {
-                        copyIsArray = false;
-                        clone = src && Array.isArray(src) ? src : [];
-                    } else {
-                        clone = src && isPlainObject(src) ? src : {};
-                    }
-                    target[name] = fnMerge(deep, arguments[1], clone, copy);
-                } else if (copy !== skipToken) {
-                    target[name] = copy;
-                }
-            }
+  /*
+   * The code in this function is taken from jQuery 3.6.0 "jQuery.extend" and got modified.
+   *
+   * jQuery JavaScript Library v3.6.0
+   * https://jquery.com/
+   *
+   * Copyright OpenJS Foundation and other contributors
+   * Released under the MIT license
+   * https://jquery.org/license
+   */
+  var src,
+    copyIsArray,
+    copy,
+    name,
+    options,
+    clone,
+    target = arguments[2] || {},
+    i = 3,
+    length = arguments.length,
+    deep = arguments[0] || false,
+    skipToken = arguments[1] ? undefined : oToken;
+
+  // Handle case when target is a string or something (possible in deep copy)
+  if (typeof target !== "object" && typeof target !== "function") {
+    target = {};
+  }
+  for (; i < length; i++) {
+    if ((options = arguments[i]) != null) {
+      // Extend the base object
+      for (name in options) {
+        src = target[name];
+        copy = options[name];
+
+        // Prevent never-ending loop
+        // Prevent Object.prototype pollution for $.extend( true, ... )
+        // For further information, please visit https://github.com/jquery/jquery/pull/4333
+        if (name === "__proto__" || target === copy) {
+          continue;
+        }
+
+        // Recurse if we're merging plain objects or arrays
+        if (deep && copy && (isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {
+          if (copyIsArray) {
+            copyIsArray = false;
+            clone = src && Array.isArray(src) ? src : [];
+          } else {
+            clone = src && isPlainObject(src) ? src : {};
+          }
+
+          // Never move original objects, clone them
+          target[name] = fnMerge(deep, arguments[1], clone, copy);
+
+          // Don't bring in undefined values
+        } else if (copy !== skipToken) {
+          target[name] = copy;
         }
+      }
     }
-    return target;
+  }
+
+  // Return the modified object
+  return target;
 };
 export default fnMerge;

package/dist/sap/base/util/array/uniqueSort.js

@@ -1,19 +1,41 @@
-import assert from '../../assert.js';
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2024 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+import assert from "../../assert.js";
+/**
+ * Sorts the given array in-place and removes any duplicates (identified by "===").
+ *
+ * Uses Array#sort()
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort
+ *
+ * Use <code>jQuery.uniqueSort()</code> for arrays of DOMElements.
+ *
+ * @function
+ * @since 1.58
+ * @param {any[]} aArray An Array of any type
+ * @alias module:sap/base/util/array/uniqueSort
+ * @return {any[]} Same array as given (for chaining)
+ * @public
+ */
 var fnUniqueSort = function (aArray) {
-    assert(Array.isArray(aArray), 'uniqueSort: input parameter must be an Array');
-    var iLength = aArray.length;
-    if (iLength > 1) {
-        aArray.sort();
-        var j = 0;
-        for (var i = 1; i < iLength; i++) {
-            if (aArray.indexOf(aArray[i]) === i) {
-                aArray[++j] = aArray[i];
-            }
-        }
-        if (++j < iLength) {
-            aArray.splice(j, iLength - j);
-        }
+  assert(Array.isArray(aArray), "uniqueSort: input parameter must be an Array");
+  var iLength = aArray.length;
+  if (iLength > 1) {
+    aArray.sort();
+    var j = 0;
+    for (var i = 1; i < iLength; i++) {
+      // invariant: i is the entry to check, j is the last unique entry known so far
+      if (aArray.indexOf(aArray[i]) === i) {
+        aArray[++j] = aArray[i];
+      }
     }
-    return aArray;
+    // cut off the rest - if any
+    if (++j < iLength) {
+      aArray.splice(j, iLength - j);
+    }
+  }
+  return aArray;
 };
 export default fnUniqueSort;

package/dist/sap/base/util/deepClone.js

@@ -0,0 +1,102 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2024 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+import isPlainObject from "./isPlainObject.js";
+/**
+ * Creates a deep clone of the source value.
+ *
+ * Only arrays, JavaScript Date objects and objects that pass the {@link module:sap/base/util/isPlainObject isPlainObject}
+ * check will be cloned. For other object types, a <code>TypeError</code> will be thrown as there's no standard way
+ * to clone them. Primitive values (boolean, number, string) as well as <code>null</code> and <code>undefined</code>
+ * will be copied, they have value semantics anyhow.
+ *
+ * <code>deepClone</code> is designed to match the semantics of {@link module:sap/base/util/deepEqual deepEqual}.
+ * Any deeply cloned object should be deep-equal to the source. However, not every object that can be handled
+ * by <code>deepEqual</code> can also be deeply cloned (e.g. <code>deepClone</code> fails on non-plain objects).
+ *
+ * To limit the time needed for a deep clone and to avoid endless recursion in case of cyclic structures, the
+ * recursion depth is limited by the parameter <code>maxDepth</code>, which defaults to 10. When the recursion
+ * depth exceeds the given limit, a <code>TypeError</code> is thrown.
+ *
+ * Note that object identities are not honored by the clone operation. If the original source contained multiple
+ * references to the same plain object instance, the clone will contain a different clone for each reference.
+ *
+ * @example <caption>Simple operation</caption>
+ * var oSource = { a: 1, b: { x: "test", y : 5.0 }, c: new Date(), d: null };
+ * var oClone = deepClone(oValue);
+ *
+ * deepEqual(oClone, oSource); // true
+ * oClone !== oSource; // true
+ * oClone.b !== oSource.b; // true
+ * oClone.c !== oSource.c; // true
+ *
+ * @example <caption>Object Identities</caption>
+ * var oCommon = { me: "unique" };
+ * var oValue = { a: oCommon, b: oCommon };
+ * var oClone = deepClone(oValue);
+ *
+ * deepEqual(oClone, oSource); // true
+ * oSource.a === oSource.b; // true
+ * oClone.a === oClone.b; // false
+ * deepEqual(oClone.a, oClone.b); // true
+ *
+ * @since 1.63
+ * @public
+ * @alias module:sap/base/util/deepClone
+ * @param {any} src Source value that shall be cloned
+ * @param {int} [maxDepth=10] Maximum recursion depth for the clone operation, deeper structures will throw an error
+ * @returns {any} A clone of the source value
+ * @throws {TypeError} When a non-plain object is encountered or when the max structure depth is exceeded
+ */
+var fnDeepClone = function (src, maxDepth) {
+  if (!maxDepth) {
+    maxDepth = 10;
+  }
+  return clone(src, 0, maxDepth);
+};
+function clone(src, depth, maxDepth) {
+  // avoid endless recursion due to cyclic structures
+  if (depth > maxDepth) {
+    throw new TypeError("The structure depth of the source exceeds the maximum depth (" + maxDepth + ")");
+  }
+  if (src == null) {
+    return src;
+  } else if (src instanceof Date) {
+    if (src.clone) {
+      // sap.ui.core.date.UI5Date
+      return src.clone();
+    }
+
+    // clone date object using #getTime(). Officially the date constructor does not support parameter Date.
+    return new Date(src.getTime());
+  } else if (Array.isArray(src)) {
+    return cloneArray(src, depth, maxDepth);
+  } else if (typeof src === "object") {
+    return cloneObject(src, depth, maxDepth);
+  } else {
+    return src;
+  }
+}
+function cloneArray(src, depth, maxDepth) {
+  var aClone = [];
+  for (var i = 0; i < src.length; i++) {
+    aClone.push(clone(src[i], depth + 1, maxDepth));
+  }
+  return aClone;
+}
+function cloneObject(src, depth, maxDepth) {
+  if (!isPlainObject(src)) {
+    throw new TypeError("Cloning is only supported for plain objects");
+  }
+  var oClone = {};
+  for (var key in src) {
+    if (key === "__proto__") {
+      continue;
+    }
+    oClone[key] = clone(src[key], depth + 1, maxDepth);
+  }
+  return oClone;
+}
+export default fnDeepClone;