@ng-formworks/core 17.2.7 → 17.4.0

package/esm2022/lib/shared/jsonpointer.functions.mjs

@@ -0,0 +1,1026 @@
+import { cleanValueOfQuotes, copy, getExpressionType, getKeyAndValueByExpressionType, hasOwn, isEqual, isNotEqual, isNotExpression } from './utility.functions';
+import { Injectable } from '@angular/core';
+import { isArray, isDefined, isEmpty, isMap, isNumber, isObject, isString } from './validator.functions';
+import * as i0 from "@angular/core";
+export class JsonPointer {
+    /**
+     * 'get' function
+     *
+     * Uses a JSON Pointer to retrieve a value from an object.
+     *
+     * //  { object } object - Object to get value from
+     * //  { Pointer } pointer - JSON Pointer (string or array)
+     * //  { number = 0 } startSlice - Zero-based index of first Pointer key to use
+     * //  { number } endSlice - Zero-based index of last Pointer key to use
+     * //  { boolean = false } getBoolean - Return only true or false?
+     * //  { boolean = false } errors - Show error if not found?
+     * // { object } - Located value (or true or false if getBoolean = true)
+     */
+    static get(object, pointer, startSlice = 0, endSlice = null, getBoolean = false, errors = false) {
+        if (object === null) {
+            return getBoolean ? false : undefined;
+        }
+        let keyArray = this.parse(pointer, errors);
+        if (typeof object === 'object' && keyArray !== null) {
+            let subObject = object;
+            if (startSlice >= keyArray.length || endSlice <= -keyArray.length) {
+                return object;
+            }
+            if (startSlice <= -keyArray.length) {
+                startSlice = 0;
+            }
+            if (!isDefined(endSlice) || endSlice >= keyArray.length) {
+                endSlice = keyArray.length;
+            }
+            keyArray = keyArray.slice(startSlice, endSlice);
+            for (let key of keyArray) {
+                if (key === '-' && isArray(subObject) && subObject.length) {
+                    key = subObject.length - 1;
+                }
+                if (isMap(subObject) && subObject.has(key)) {
+                    subObject = subObject.get(key);
+                }
+                else if (typeof subObject === 'object' && subObject !== null &&
+                    hasOwn(subObject, key)) {
+                    subObject = subObject[key];
+                }
+                else {
+                    const evaluatedExpression = JsonPointer.evaluateExpression(subObject, key);
+                    if (evaluatedExpression.passed) {
+                        subObject = evaluatedExpression.key ? subObject[evaluatedExpression.key] : subObject;
+                    }
+                    else {
+                        this.logErrors(errors, key, pointer, object);
+                        return getBoolean ? false : undefined;
+                    }
+                }
+            }
+            return getBoolean ? true : subObject;
+        }
+        if (errors && keyArray === null) {
+            console.error(`get error: Invalid JSON Pointer: ${pointer}`);
+        }
+        if (errors && typeof object !== 'object') {
+            console.error('get error: Invalid object:');
+            console.error(object);
+        }
+        return getBoolean ? false : undefined;
+    }
+    static logErrors(errors, key, pointer, object) {
+        if (errors) {
+            console.error(`get error: "${key}" key not found in object.`);
+            console.error(pointer);
+            console.error(object);
+        }
+    }
+    /**
+     * Evaluates conditional expression in form of `model.<property>==<value>` or
+     * `model.<property>!=<value>` where the first one means that the value must match to be
+     * shown in a form, while the former shows the property only when the property value is not
+     * set, or does not equal the given value.
+     *
+     * // { subObject } subObject -  an object containing the data values of properties
+     * // { key } key - the key from the for loop in a form of `<property>==<value>`
+     *
+     * Returns the object with two properties. The property passed informs whether
+     * the expression evaluated successfully and the property key returns either the same
+     * key if it is not contained inside the subObject or the key of the property if it is contained.
+     */
+    static evaluateExpression(subObject, key) {
+        const defaultResult = { passed: false, key: key };
+        const keysAndExpression = this.parseKeysAndExpression(key, subObject);
+        if (!keysAndExpression) {
+            return defaultResult;
+        }
+        const ownCheckResult = this.doOwnCheckResult(subObject, keysAndExpression);
+        if (ownCheckResult) {
+            return ownCheckResult;
+        }
+        const cleanedValue = cleanValueOfQuotes(keysAndExpression.keyAndValue[1]);
+        const evaluatedResult = this.performExpressionOnValue(keysAndExpression, cleanedValue, subObject);
+        if (evaluatedResult) {
+            return evaluatedResult;
+        }
+        return defaultResult;
+    }
+    /**
+     * Performs the actual evaluation on the given expression with given values and keys.
+     * // { cleanedValue } cleanedValue - the given valued cleaned of quotes if it had any
+     * // { subObject } subObject - the object with properties values
+     * // { keysAndExpression } keysAndExpression - an object holding the expressions with
+     */
+    static performExpressionOnValue(keysAndExpression, cleanedValue, subObject) {
+        const propertyByKey = subObject[keysAndExpression.keyAndValue[0]];
+        if (this.doComparisonByExpressionType(keysAndExpression.expressionType, propertyByKey, cleanedValue)) {
+            return { passed: true, key: keysAndExpression.keyAndValue[0] };
+        }
+        return null;
+    }
+    static doComparisonByExpressionType(expressionType, propertyByKey, cleanedValue) {
+        if (isEqual(expressionType)) {
+            return propertyByKey === cleanedValue;
+        }
+        if (isNotEqual(expressionType)) {
+            return propertyByKey !== cleanedValue;
+        }
+        return false;
+    }
+    /**
+     * Does the checks when the parsed key is actually no a property inside subObject.
+     * That would mean that the equal comparison makes no sense and thus the negative result
+     * is returned, and the not equal comparison is not necessary because it doesn't equal
+     * obviously. Returns null when the given key is a real property inside the subObject.
+     * // { subObject } subObject - the object with properties values
+     * // { keysAndExpression } keysAndExpression - an object holding the expressions with
+     * the associated keys.
+     */
+    static doOwnCheckResult(subObject, keysAndExpression) {
+        let ownCheckResult = null;
+        if (!hasOwn(subObject, keysAndExpression.keyAndValue[0])) {
+            if (isEqual(keysAndExpression.expressionType)) {
+                ownCheckResult = { passed: false, key: null };
+            }
+            if (isNotEqual(keysAndExpression.expressionType)) {
+                ownCheckResult = { passed: true, key: null };
+            }
+        }
+        return ownCheckResult;
+    }
+    /**
+     * Does the basic checks and tries to parse an expression and a pair
+     * of key and value.
+     * // { key } key - the original for loop created value containing key and value in one string
+     * // { subObject } subObject - the object with properties values
+     */
+    static parseKeysAndExpression(key, subObject) {
+        if (this.keyOrSubObjEmpty(key, subObject)) {
+            return null;
+        }
+        const expressionType = getExpressionType(key.toString());
+        if (isNotExpression(expressionType)) {
+            return null;
+        }
+        const keyAndValue = getKeyAndValueByExpressionType(expressionType, key);
+        if (!keyAndValue || !keyAndValue[0] || !keyAndValue[1]) {
+            return null;
+        }
+        return { expressionType: expressionType, keyAndValue: keyAndValue };
+    }
+    static keyOrSubObjEmpty(key, subObject) {
+        return !key || !subObject;
+    }
+    /**
+     * 'getCopy' function
+     *
+     * Uses a JSON Pointer to deeply clone a value from an object.
+     *
+     * //  { object } object - Object to get value from
+     * //  { Pointer } pointer - JSON Pointer (string or array)
+     * //  { number = 0 } startSlice - Zero-based index of first Pointer key to use
+     * //  { number } endSlice - Zero-based index of last Pointer key to use
+     * //  { boolean = false } getBoolean - Return only true or false?
+     * //  { boolean = false } errors - Show error if not found?
+     * // { object } - Located value (or true or false if getBoolean = true)
+     */
+    static getCopy(object, pointer, startSlice = 0, endSlice = null, getBoolean = false, errors = false) {
+        const objectToCopy = this.get(object, pointer, startSlice, endSlice, getBoolean, errors);
+        return this.forEachDeepCopy(objectToCopy);
+    }
+    /**
+     * 'getFirst' function
+     *
+     * Takes an array of JSON Pointers and objects,
+     * checks each object for a value specified by the pointer,
+     * and returns the first value found.
+     *
+     * //  { [object, pointer][] } items - Array of objects and pointers to check
+     * //  { any = null } defaultValue - Value to return if nothing found
+     * //  { boolean = false } getCopy - Return a copy instead?
+     * //  - First value found
+     */
+    static getFirst(items, defaultValue = null, getCopy = false) {
+        if (isEmpty(items)) {
+            return;
+        }
+        if (isArray(items)) {
+            for (const item of items) {
+                if (isEmpty(item)) {
+                    continue;
+                }
+                if (isArray(item) && item.length >= 2) {
+                    if (isEmpty(item[0]) || isEmpty(item[1])) {
+                        continue;
+                    }
+                    const value = getCopy ?
+                        this.getCopy(item[0], item[1]) :
+                        this.get(item[0], item[1]);
+                    if (value) {
+                        return value;
+                    }
+                    continue;
+                }
+                console.error('getFirst error: Input not in correct format.\n' +
+                    'Should be: [ [ object1, pointer1 ], [ object 2, pointer2 ], etc... ]');
+                return;
+            }
+            return defaultValue;
+        }
+        if (isMap(items)) {
+            for (const [object, pointer] of items) {
+                if (object === null || !this.isJsonPointer(pointer)) {
+                    continue;
+                }
+                const value = getCopy ?
+                    this.getCopy(object, pointer) :
+                    this.get(object, pointer);
+                if (value) {
+                    return value;
+                }
+            }
+            return defaultValue;
+        }
+        console.error('getFirst error: Input not in correct format.\n' +
+            'Should be: [ [ object1, pointer1 ], [ object 2, pointer2 ], etc... ]');
+        return defaultValue;
+    }
+    /**
+     * 'getFirstCopy' function
+     *
+     * Similar to getFirst, but always returns a copy.
+     *
+     * //  { [object, pointer][] } items - Array of objects and pointers to check
+     * //  { any = null } defaultValue - Value to return if nothing found
+     * //  - Copy of first value found
+     */
+    static getFirstCopy(items, defaultValue = null) {
+        const firstCopy = this.getFirst(items, defaultValue, true);
+        return firstCopy;
+    }
+    /**
+     * 'set' function
+     *
+     * Uses a JSON Pointer to set a value on an object.
+     * Also creates any missing sub objects or arrays to contain that value.
+     *
+     * If the optional fourth parameter is TRUE and the inner-most container
+     * is an array, the function will insert the value as a new item at the
+     * specified location in the array, rather than overwriting the existing
+     * value (if any) at that location.
+     *
+     * So set([1, 2, 3], '/1', 4) => [1, 4, 3]
+     * and
+     * So set([1, 2, 3], '/1', 4, true) => [1, 4, 2, 3]
+     *
+     * //  { object } object - The object to set value in
+     * //  { Pointer } pointer - The JSON Pointer (string or array)
+     * //   value - The new value to set
+     * //  { boolean } insert - insert value?
+     * // { object } - The original object, modified with the set value
+     */
+    static set(object, pointer, value, insert = false) {
+        const keyArray = this.parse(pointer);
+        if (keyArray !== null && keyArray.length) {
+            let subObject = object;
+            for (let i = 0; i < keyArray.length - 1; ++i) {
+                let key = keyArray[i];
+                if (key === '-' && isArray(subObject)) {
+                    key = subObject.length;
+                }
+                if (isMap(subObject) && subObject.has(key)) {
+                    subObject = subObject.get(key);
+                }
+                else {
+                    if (!hasOwn(subObject, key)) {
+                        subObject[key] = (keyArray[i + 1].match(/^(\d+|-)$/)) ? [] : {};
+                    }
+                    subObject = subObject[key];
+                }
+            }
+            const lastKey = keyArray[keyArray.length - 1];
+            if (isArray(subObject) && lastKey === '-') {
+                subObject.push(value);
+            }
+            else if (insert && isArray(subObject) && !isNaN(+lastKey)) {
+                subObject.splice(lastKey, 0, value);
+            }
+            else if (isMap(subObject)) {
+                subObject.set(lastKey, value);
+            }
+            else {
+                subObject[lastKey] = value;
+            }
+            return object;
+        }
+        console.error(`set error: Invalid JSON Pointer: ${pointer}`);
+        return object;
+    }
+    /**
+     * 'setCopy' function
+     *
+     * Copies an object and uses a JSON Pointer to set a value on the copy.
+     * Also creates any missing sub objects or arrays to contain that value.
+     *
+     * If the optional fourth parameter is TRUE and the inner-most container
+     * is an array, the function will insert the value as a new item at the
+     * specified location in the array, rather than overwriting the existing value.
+     *
+     * //  { object } object - The object to copy and set value in
+     * //  { Pointer } pointer - The JSON Pointer (string or array)
+     * //   value - The value to set
+     * //  { boolean } insert - insert value?
+     * // { object } - The new object with the set value
+     */
+    static setCopy(object, pointer, value, insert = false) {
+        const keyArray = this.parse(pointer);
+        if (keyArray !== null) {
+            const newObject = copy(object);
+            let subObject = newObject;
+            for (let i = 0; i < keyArray.length - 1; ++i) {
+                let key = keyArray[i];
+                if (key === '-' && isArray(subObject)) {
+                    key = subObject.length;
+                }
+                if (isMap(subObject) && subObject.has(key)) {
+                    subObject.set(key, copy(subObject.get(key)));
+                    subObject = subObject.get(key);
+                }
+                else {
+                    if (!hasOwn(subObject, key)) {
+                        subObject[key] = (keyArray[i + 1].match(/^(\d+|-)$/)) ? [] : {};
+                    }
+                    subObject[key] = copy(subObject[key]);
+                    subObject = subObject[key];
+                }
+            }
+            const lastKey = keyArray[keyArray.length - 1];
+            if (isArray(subObject) && lastKey === '-') {
+                subObject.push(value);
+            }
+            else if (insert && isArray(subObject) && !isNaN(+lastKey)) {
+                subObject.splice(lastKey, 0, value);
+            }
+            else if (isMap(subObject)) {
+                subObject.set(lastKey, value);
+            }
+            else {
+                subObject[lastKey] = value;
+            }
+            return newObject;
+        }
+        console.error(`setCopy error: Invalid JSON Pointer: ${pointer}`);
+        return object;
+    }
+    /**
+     * 'insert' function
+     *
+     * Calls 'set' with insert = TRUE
+     *
+     * //  { object } object - object to insert value in
+     * //  { Pointer } pointer - JSON Pointer (string or array)
+     * //   value - value to insert
+     * // { object }
+     */
+    static insert(object, pointer, value) {
+        const updatedObject = this.set(object, pointer, value, true);
+        return updatedObject;
+    }
+    /**
+     * 'insertCopy' function
+     *
+     * Calls 'setCopy' with insert = TRUE
+     *
+     * //  { object } object - object to insert value in
+     * //  { Pointer } pointer - JSON Pointer (string or array)
+     * //   value - value to insert
+     * // { object }
+     */
+    static insertCopy(object, pointer, value) {
+        const updatedObject = this.setCopy(object, pointer, value, true);
+        return updatedObject;
+    }
+    /**
+     * 'remove' function
+     *
+     * Uses a JSON Pointer to remove a key and its attribute from an object
+     *
+     * //  { object } object - object to delete attribute from
+     * //  { Pointer } pointer - JSON Pointer (string or array)
+     * // { object }
+     */
+    static remove(object, pointer) {
+        const keyArray = this.parse(pointer);
+        if (keyArray !== null && keyArray.length) {
+            let lastKey = keyArray.pop();
+            const parentObject = this.get(object, keyArray);
+            if (isArray(parentObject)) {
+                if (lastKey === '-') {
+                    lastKey = parentObject.length - 1;
+                }
+                parentObject.splice(lastKey, 1);
+            }
+            else if (isObject(parentObject)) {
+                delete parentObject[lastKey];
+            }
+            return object;
+        }
+        console.error(`remove error: Invalid JSON Pointer: ${pointer}`);
+        return object;
+    }
+    /**
+     * 'has' function
+     *
+     * Tests if an object has a value at the location specified by a JSON Pointer
+     *
+     * //  { object } object - object to chek for value
+     * //  { Pointer } pointer - JSON Pointer (string or array)
+     * // { boolean }
+     */
+    static has(object, pointer) {
+        const hasValue = this.get(object, pointer, 0, null, true);
+        return hasValue;
+    }
+    /**
+     * 'dict' function
+     *
+     * Returns a (pointer -> value) dictionary for an object
+     *
+     * //  { object } object - The object to create a dictionary from
+     * // { object } - The resulting dictionary object
+     */
+    static dict(object) {
+        const results = {};
+        this.forEachDeep(object, (value, pointer) => {
+            if (typeof value !== 'object') {
+                results[pointer] = value;
+            }
+        });
+        return results;
+    }
+    /**
+     * 'forEachDeep' function
+     *
+     * Iterates over own enumerable properties of an object or items in an array
+     * and invokes an iteratee function for each key/value or index/value pair.
+     * By default, iterates over items within objects and arrays after calling
+     * the iteratee function on the containing object or array itself.
+     *
+     * The iteratee is invoked with three arguments: (value, pointer, rootObject),
+     * where pointer is a JSON pointer indicating the location of the current
+     * value within the root object, and rootObject is the root object initially
+     * submitted to th function.
+     *
+     * If a third optional parameter 'bottomUp' is set to TRUE, the iterator
+     * function will be called on sub-objects and arrays after being
+     * called on their contents, rather than before, which is the default.
+     *
+     * This function can also optionally be called directly on a sub-object by
+     * including optional 4th and 5th parameterss to specify the initial
+     * root object and pointer.
+     *
+     * //  { object } object - the initial object or array
+     * //  { (v: any, p?: string, o?: any) => any } function - iteratee function
+     * //  { boolean = false } bottomUp - optional, set to TRUE to reverse direction
+     * //  { object = object } rootObject - optional, root object or array
+     * //  { string = '' } pointer - optional, JSON Pointer to object within rootObject
+     * // { object } - The modified object
+     */
+    static forEachDeep(object, fn = (v) => v, bottomUp = false, pointer = '', rootObject = object) {
+        if (typeof fn !== 'function') {
+            console.error(`forEachDeep error: Iterator is not a function:`, fn);
+            return;
+        }
+        if (!bottomUp) {
+            fn(object, pointer, rootObject);
+        }
+        if (isObject(object) || isArray(object)) {
+            for (const key of Object.keys(object)) {
+                const newPointer = pointer + '/' + this.escape(key);
+                this.forEachDeep(object[key], fn, bottomUp, newPointer, rootObject);
+            }
+        }
+        if (bottomUp) {
+            fn(object, pointer, rootObject);
+        }
+    }
+    /**
+     * 'forEachDeepCopy' function
+     *
+     * Similar to forEachDeep, but returns a copy of the original object, with
+     * the same keys and indexes, but with values replaced with the result of
+     * the iteratee function.
+     *
+     * //  { object } object - the initial object or array
+     * //  { (v: any, k?: string, o?: any, p?: any) => any } function - iteratee function
+     * //  { boolean = false } bottomUp - optional, set to TRUE to reverse direction
+     * //  { object = object } rootObject - optional, root object or array
+     * //  { string = '' } pointer - optional, JSON Pointer to object within rootObject
+     * // { object } - The copied object
+     */
+    static forEachDeepCopy(object, fn = (v) => v, bottomUp = false, pointer = '', rootObject = object) {
+        if (typeof fn !== 'function') {
+            console.error(`forEachDeepCopy error: Iterator is not a function:`, fn);
+            return null;
+        }
+        if (isObject(object) || isArray(object)) {
+            let newObject = isArray(object) ? [...object] : { ...object };
+            if (!bottomUp) {
+                newObject = fn(newObject, pointer, rootObject);
+            }
+            for (const key of Object.keys(newObject)) {
+                const newPointer = pointer + '/' + this.escape(key);
+                newObject[key] = this.forEachDeepCopy(newObject[key], fn, bottomUp, newPointer, rootObject);
+            }
+            if (bottomUp) {
+                newObject = fn(newObject, pointer, rootObject);
+            }
+            return newObject;
+        }
+        else {
+            return fn(object, pointer, rootObject);
+        }
+    }
+    /**
+     * 'escape' function
+     *
+     * Escapes a string reference key
+     *
+     * //  { string } key - string key to escape
+     * // { string } - escaped key
+     */
+    static escape(key) {
+        const escaped = key.toString().replace(/~/g, '~0').replace(/\//g, '~1');
+        return escaped;
+    }
+    /**
+     * 'unescape' function
+     *
+     * Unescapes a string reference key
+     *
+     * //  { string } key - string key to unescape
+     * // { string } - unescaped key
+     */
+    static unescape(key) {
+        const unescaped = key.toString().replace(/~1/g, '/').replace(/~0/g, '~');
+        return unescaped;
+    }
+    /**
+     * 'parse' function
+     *
+     * Converts a string JSON Pointer into a array of keys
+     * (if input is already an an array of keys, it is returned unchanged)
+     *
+     * //  { Pointer } pointer - JSON Pointer (string or array)
+     * //  { boolean = false } errors - Show error if invalid pointer?
+     * // { string[] } - JSON Pointer array of keys
+     */
+    static parse(pointer, errors = false) {
+        if (!this.isJsonPointer(pointer)) {
+            if (errors) {
+                console.error(`parse error: Invalid JSON Pointer: ${pointer}`);
+            }
+            return null;
+        }
+        if (isArray(pointer)) {
+            return pointer;
+        }
+        if (typeof pointer === 'string') {
+            if (pointer[0] === '#') {
+                pointer = pointer.slice(1);
+            }
+            if (pointer === '' || pointer === '/') {
+                return [];
+            }
+            return pointer.slice(1).split('/').map(this.unescape);
+        }
+    }
+    /**
+     * 'compile' function
+     *
+     * Converts an array of keys into a JSON Pointer string
+     * (if input is already a string, it is normalized and returned)
+     *
+     * The optional second parameter is a default which will replace any empty keys.
+     *
+     * //  { Pointer } pointer - JSON Pointer (string or array)
+     * //  { string | number = '' } defaultValue - Default value
+     * //  { boolean = false } errors - Show error if invalid pointer?
+     * // { string } - JSON Pointer string
+     */
+    static compile(pointer, defaultValue = '', errors = false) {
+        if (pointer === '#') {
+            return '';
+        }
+        if (!this.isJsonPointer(pointer)) {
+            if (errors) {
+                console.error(`compile error: Invalid JSON Pointer: ${pointer}`);
+            }
+            return null;
+        }
+        if (isArray(pointer)) {
+            if (pointer.length === 0) {
+                return '';
+            }
+            return '/' + pointer.map(key => key === '' ? defaultValue : this.escape(key)).join('/');
+        }
+        if (typeof pointer === 'string') {
+            if (pointer[0] === '#') {
+                pointer = pointer.slice(1);
+            }
+            return pointer;
+        }
+    }
+    /**
+     * 'toKey' function
+     *
+     * Extracts name of the final key from a JSON Pointer.
+     *
+     * //  { Pointer } pointer - JSON Pointer (string or array)
+     * //  { boolean = false } errors - Show error if invalid pointer?
+     * // { string } - the extracted key
+     */
+    static toKey(pointer, errors = false) {
+        const keyArray = this.parse(pointer, errors);
+        if (keyArray === null) {
+            return null;
+        }
+        if (!keyArray.length) {
+            return '';
+        }
+        return keyArray[keyArray.length - 1];
+    }
+    /**
+     * 'isJsonPointer' function
+     *
+     * Checks a string or array value to determine if it is a valid JSON Pointer.
+     * Returns true if a string is empty, or starts with '/' or '#/'.
+     * Returns true if an array contains only string values.
+     *
+     * //   value - value to check
+     * // { boolean } - true if value is a valid JSON Pointer, otherwise false
+     */
+    static isJsonPointer(value) {
+        if (isArray(value)) {
+            return value.every(key => typeof key === 'string');
+        }
+        else if (isString(value)) {
+            if (value === '' || value === '#') {
+                return true;
+            }
+            if (value[0] === '/' || value.slice(0, 2) === '#/') {
+                return !/(~[^01]|~$)/g.test(value);
+            }
+        }
+        return false;
+    }
+    /**
+     * 'isSubPointer' function
+     *
+     * Checks whether one JSON Pointer is a subset of another.
+     *
+     * //  { Pointer } shortPointer - potential subset JSON Pointer
+     * //  { Pointer } longPointer - potential superset JSON Pointer
+     * //  { boolean = false } trueIfMatching - return true if pointers match?
+     * //  { boolean = false } errors - Show error if invalid pointer?
+     * // { boolean } - true if shortPointer is a subset of longPointer, false if not
+     */
+    static isSubPointer(shortPointer, longPointer, trueIfMatching = false, errors = false) {
+        if (!this.isJsonPointer(shortPointer) || !this.isJsonPointer(longPointer)) {
+            if (errors) {
+                let invalid = '';
+                if (!this.isJsonPointer(shortPointer)) {
+                    invalid += ` 1: ${shortPointer}`;
+                }
+                if (!this.isJsonPointer(longPointer)) {
+                    invalid += ` 2: ${longPointer}`;
+                }
+                console.error(`isSubPointer error: Invalid JSON Pointer ${invalid}`);
+            }
+            return;
+        }
+        shortPointer = this.compile(shortPointer, '', errors);
+        longPointer = this.compile(longPointer, '', errors);
+        return shortPointer === longPointer ? trueIfMatching :
+            `${shortPointer}/` === longPointer.slice(0, shortPointer.length + 1);
+    }
+    /**
+     * 'toIndexedPointer' function
+     *
+     * Merges an array of numeric indexes and a generic pointer to create an
+     * indexed pointer for a specific item.
+     *
+     * For example, merging the generic pointer '/foo/-/bar/-/baz' and
+     * the array [4, 2] would result in the indexed pointer '/foo/4/bar/2/baz'
+     *
+     *
+     * //  { Pointer } genericPointer - The generic pointer
+     * //  { number[] } indexArray - The array of numeric indexes
+     * //  { Map<string, number> } arrayMap - An optional array map
+     * // { string } - The merged pointer with indexes
+     */
+    static toIndexedPointer(genericPointer, indexArray, arrayMap = null) {
+        if (this.isJsonPointer(genericPointer) && isArray(indexArray)) {
+            let indexedPointer = this.compile(genericPointer);
+            if (isMap(arrayMap)) {
+                let arrayIndex = 0;
+                return indexedPointer.replace(/\/\-(?=\/|$)/g, (key, stringIndex) => arrayMap.has(indexedPointer.slice(0, stringIndex)) ?
+                    '/' + indexArray[arrayIndex++] : key);
+            }
+            else {
+                for (const pointerIndex of indexArray) {
+                    indexedPointer = indexedPointer.replace('/-', '/' + pointerIndex);
+                }
+                return indexedPointer;
+            }
+        }
+        if (!this.isJsonPointer(genericPointer)) {
+            console.error(`toIndexedPointer error: Invalid JSON Pointer: ${genericPointer}`);
+        }
+        if (!isArray(indexArray)) {
+            console.error(`toIndexedPointer error: Invalid indexArray: ${indexArray}`);
+        }
+    }
+    /**
+     * 'toGenericPointer' function
+     *
+     * Compares an indexed pointer to an array map and removes list array
+     * indexes (but leaves tuple arrray indexes and all object keys, including
+     * numeric keys) to create a generic pointer.
+     *
+     * For example, using the indexed pointer '/foo/1/bar/2/baz/3' and
+     * the arrayMap [['/foo', 0], ['/foo/-/bar', 3], ['/foo/-/bar/-/baz', 0]]
+     * would result in the generic pointer '/foo/-/bar/2/baz/-'
+     * Using the indexed pointer '/foo/1/bar/4/baz/3' and the same arrayMap
+     * would result in the generic pointer '/foo/-/bar/-/baz/-'
+     * (the bar array has 3 tuple items, so index 2 is retained, but 4 is removed)
+     *
+     * The structure of the arrayMap is: [['path to array', number of tuple items]...]
+     *
+     *
+     * //  { Pointer } indexedPointer - The indexed pointer (array or string)
+     * //  { Map<string, number> } arrayMap - The optional array map (for preserving tuple indexes)
+     * // { string } - The generic pointer with indexes removed
+     */
+    static toGenericPointer(indexedPointer, arrayMap = new Map()) {
+        if (this.isJsonPointer(indexedPointer) && isMap(arrayMap)) {
+            const pointerArray = this.parse(indexedPointer);
+            for (let i = 1; i < pointerArray.length; i++) {
+                const subPointer = this.compile(pointerArray.slice(0, i));
+                if (arrayMap.has(subPointer) &&
+                    arrayMap.get(subPointer) <= +pointerArray[i]) {
+                    pointerArray[i] = '-';
+                }
+            }
+            return this.compile(pointerArray);
+        }
+        if (!this.isJsonPointer(indexedPointer)) {
+            console.error(`toGenericPointer error: invalid JSON Pointer: ${indexedPointer}`);
+        }
+        if (!isMap(arrayMap)) {
+            console.error(`toGenericPointer error: invalid arrayMap: ${arrayMap}`);
+        }
+    }
+    /**
+     * 'toControlPointer' function
+     *
+     * Accepts a JSON Pointer for a data object and returns a JSON Pointer for the
+     * matching control in an Angular FormGroup.
+     *
+     * //  { Pointer } dataPointer - JSON Pointer (string or array) to a data object
+     * //  { FormGroup } formGroup - Angular FormGroup to get value from
+     * //  { boolean = false } controlMustExist - Only return if control exists?
+     * // { Pointer } - JSON Pointer (string) to the formGroup object
+     */
+    static toControlPointer(dataPointer, formGroup, controlMustExist = false) {
+        const dataPointerArray = this.parse(dataPointer);
+        const controlPointerArray = [];
+        let subGroup = formGroup;
+        if (dataPointerArray !== null) {
+            for (const key of dataPointerArray) {
+                if (hasOwn(subGroup, 'controls')) {
+                    controlPointerArray.push('controls');
+                    subGroup = subGroup.controls;
+                }
+                if (isArray(subGroup) && (key === '-')) {
+                    controlPointerArray.push((subGroup.length - 1).toString());
+                    subGroup = subGroup[subGroup.length - 1];
+                }
+                else if (hasOwn(subGroup, key)) {
+                    controlPointerArray.push(key);
+                    subGroup = subGroup[key];
+                }
+                else if (controlMustExist) {
+                    console.error(`toControlPointer error: Unable to find "${key}" item in FormGroup.`);
+                    console.error(dataPointer);
+                    console.error(formGroup);
+                    return;
+                }
+                else {
+                    controlPointerArray.push(key);
+                    subGroup = { controls: {} };
+                }
+            }
+            return this.compile(controlPointerArray);
+        }
+        console.error(`toControlPointer error: Invalid JSON Pointer: ${dataPointer}`);
+    }
+    /**
+     * 'toSchemaPointer' function
+     *
+     * Accepts a JSON Pointer to a value inside a data object and a JSON schema
+     * for that object.
+     *
+     * Returns a Pointer to the sub-schema for the value inside the object's schema.
+     *
+     * //  { Pointer } dataPointer - JSON Pointer (string or array) to an object
+     * //   schema - JSON schema for the object
+     * // { Pointer } - JSON Pointer (string) to the object's schema
+     */
+    static toSchemaPointer(dataPointer, schema) {
+        if (this.isJsonPointer(dataPointer) && typeof schema === 'object') {
+            const pointerArray = this.parse(dataPointer);
+            if (!pointerArray.length) {
+                return '';
+            }
+            const firstKey = pointerArray.shift();
+            if (schema.type === 'object' || schema.properties || schema.additionalProperties) {
+                if ((schema.properties || {})[firstKey]) {
+                    return `/properties/${this.escape(firstKey)}` +
+                        this.toSchemaPointer(pointerArray, schema.properties[firstKey]);
+                }
+                else if (schema.additionalProperties) {
+                    return '/additionalProperties' +
+                        this.toSchemaPointer(pointerArray, schema.additionalProperties);
+                }
+            }
+            if ((schema.type === 'array' || schema.items) &&
+                (isNumber(firstKey) || firstKey === '-' || firstKey === '')) {
+                const arrayItem = firstKey === '-' || firstKey === '' ? 0 : +firstKey;
+                if (isArray(schema.items)) {
+                    if (arrayItem < schema.items.length) {
+                        return '/items/' + arrayItem +
+                            this.toSchemaPointer(pointerArray, schema.items[arrayItem]);
+                    }
+                    else if (schema.additionalItems) {
+                        return '/additionalItems' +
+                            this.toSchemaPointer(pointerArray, schema.additionalItems);
+                    }
+                }
+                else if (isObject(schema.items)) {
+                    return '/items' + this.toSchemaPointer(pointerArray, schema.items);
+                }
+                else if (isObject(schema.additionalItems)) {
+                    return '/additionalItems' +
+                        this.toSchemaPointer(pointerArray, schema.additionalItems);
+                }
+            }
+            console.error(`toSchemaPointer error: Data pointer ${dataPointer} ` +
+                `not compatible with schema ${schema}`);
+            return null;
+        }
+        if (!this.isJsonPointer(dataPointer)) {
+            console.error(`toSchemaPointer error: Invalid JSON Pointer: ${dataPointer}`);
+        }
+        if (typeof schema !== 'object') {
+            console.error(`toSchemaPointer error: Invalid JSON Schema: ${schema}`);
+        }
+        return null;
+    }
+    /**
+     * 'toDataPointer' function
+     *
+     * Accepts a JSON Pointer to a sub-schema inside a JSON schema and the schema.
+     *
+     * If possible, returns a generic Pointer to the corresponding value inside
+     * the data object described by the JSON schema.
+     *
+     * Returns null if the sub-schema is in an ambiguous location (such as
+     * definitions or additionalProperties) where the corresponding value
+     * location cannot be determined.
+     *
+     * //  { Pointer } schemaPointer - JSON Pointer (string or array) to a JSON schema
+     * //   schema - the JSON schema
+     * //  { boolean = false } errors - Show errors?
+     * // { Pointer } - JSON Pointer (string) to the value in the data object
+     */
+    static toDataPointer(schemaPointer, schema, errors = false) {
+        if (this.isJsonPointer(schemaPointer) && typeof schema === 'object' &&
+            this.has(schema, schemaPointer)) {
+            const pointerArray = this.parse(schemaPointer);
+            if (!pointerArray.length) {
+                return '';
+            }
+            const firstKey = pointerArray.shift();
+            if (firstKey === 'properties' ||
+                (firstKey === 'items' && isArray(schema.items))) {
+                const secondKey = pointerArray.shift();
+                const pointerSuffix = this.toDataPointer(pointerArray, schema[firstKey][secondKey]);
+                return pointerSuffix === null ? null : '/' + secondKey + pointerSuffix;
+            }
+            else if (firstKey === 'additionalItems' ||
+                (firstKey === 'items' && isObject(schema.items))) {
+                const pointerSuffix = this.toDataPointer(pointerArray, schema[firstKey]);
+                return pointerSuffix === null ? null : '/-' + pointerSuffix;
+            }
+            else if (['allOf', 'anyOf', 'oneOf'].includes(firstKey)) {
+                const secondKey = pointerArray.shift();
+                return this.toDataPointer(pointerArray, schema[firstKey][secondKey]);
+            }
+            else if (firstKey === 'not') {
+                return this.toDataPointer(pointerArray, schema[firstKey]);
+            }
+            else if (['contains', 'definitions', 'dependencies', 'additionalItems',
+                'additionalProperties', 'patternProperties', 'propertyNames'].includes(firstKey)) {
+                if (errors) {
+                    console.error(`toDataPointer error: Ambiguous location`);
+                }
+            }
+            return '';
+        }
+        if (errors) {
+            if (!this.isJsonPointer(schemaPointer)) {
+                console.error(`toDataPointer error: Invalid JSON Pointer: ${schemaPointer}`);
+            }
+            if (typeof schema !== 'object') {
+                console.error(`toDataPointer error: Invalid JSON Schema: ${schema}`);
+            }
+            if (typeof schema !== 'object') {
+                console.error(`toDataPointer error: Pointer ${schemaPointer} invalid for Schema: ${schema}`);
+            }
+        }
+        return null;
+    }
+    /**
+     * 'parseObjectPath' function
+     *
+     * Parses a JavaScript object path into an array of keys, which
+     * can then be passed to compile() to convert into a string JSON Pointer.
+     *
+     * Based on mike-marcacci's excellent objectpath parse function:
+     * https://github.com/mike-marcacci/objectpath
+     *
+     * //  { Pointer } path - The object path to parse
+     * // { string[] } - The resulting array of keys
+     */
+    static parseObjectPath(path) {
+        if (isArray(path)) {
+            return path;
+        }
+        if (this.isJsonPointer(path)) {
+            return this.parse(path);
+        }
+        if (typeof path === 'string') {
+            let index = 0;
+            const parts = [];
+            while (index < path.length) {
+                const nextDot = path.indexOf('.', index);
+                const nextOB = path.indexOf('[', index); // next open bracket
+                if (nextDot === -1 && nextOB === -1) { // last item
+                    parts.push(path.slice(index));
+                    index = path.length;
+                }
+                else if (nextDot !== -1 && (nextDot < nextOB || nextOB === -1)) { // dot notation
+                    parts.push(path.slice(index, nextDot));
+                    index = nextDot + 1;
+                }
+                else { // bracket notation
+                    if (nextOB > index) {
+                        parts.push(path.slice(index, nextOB));
+                        index = nextOB;
+                    }
+                    const quote = path.charAt(nextOB + 1);
+                    if (quote === '"' || quote === '\'') { // enclosing quotes
+                        let nextCB = path.indexOf(quote + ']', nextOB); // next close bracket
+                        while (nextCB !== -1 && path.charAt(nextCB - 1) === '\\') {
+                            nextCB = path.indexOf(quote + ']', nextCB + 2);
+                        }
+                        if (nextCB === -1) {
+                            nextCB = path.length;
+                        }
+                        parts.push(path.slice(index + 2, nextCB)
+                            .replace(new RegExp('\\' + quote, 'g'), quote));
+                        index = nextCB + 2;
+                    }
+                    else { // no enclosing quotes
+                        let nextCB = path.indexOf(']', nextOB); // next close bracket
+                        if (nextCB === -1) {
+                            nextCB = path.length;
+                        }
+                        parts.push(path.slice(index + 1, nextCB));
+                        index = nextCB + 1;
+                    }
+                    if (path.charAt(index) === '.') {
+                        index++;
+                    }
+                }
+            }
+            return parts;
+        }
+        console.error('parseObjectPath error: Input object path must be a string.');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: JsonPointer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: JsonPointer }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: JsonPointer, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jsonpointer.functions.js","sourceRoot":"","sources":["../../../../../../projects/ng-formworks-core/src/lib/shared/jsonpointer.functions.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  cleanValueOfQuotes,\r\n  copy,\r\n  ExpressionType,\r\n  getExpressionType,\r\n  getKeyAndValueByExpressionType,\r\n  hasOwn,\r\n  isEqual,\r\n  isNotEqual,\r\n  isNotExpression\r\n} from './utility.functions';\r\nimport {Injectable} from '@angular/core';\r\nimport {isArray, isDefined, isEmpty, isMap, isNumber, isObject, isString} from './validator.functions';\r\n\r\n/**\r\n * 'JsonPointer' class\r\n *\r\n * Some utilities for using JSON Pointers with JSON objects\r\n * https://tools.ietf.org/html/rfc6901\r\n *\r\n * get, getCopy, getFirst, set, setCopy, insert, insertCopy, remove, has, dict,\r\n * forEachDeep, forEachDeepCopy, escape, unescape, parse, compile, toKey,\r\n * isJsonPointer, isSubPointer, toIndexedPointer, toGenericPointer,\r\n * toControlPointer, toSchemaPointer, toDataPointer, parseObjectPath\r\n *\r\n * Some functions based on manuelstofer's json-pointer utilities\r\n * https://github.com/manuelstofer/json-pointer\r\n */\r\nexport type Pointer = string | string[];\r\n\r\n@Injectable()\r\nexport class JsonPointer {\r\n\r\n  /**\r\n   * 'get' function\r\n   *\r\n   * Uses a JSON Pointer to retrieve a value from an object.\r\n   *\r\n   * //  { object } object - Object to get value from\r\n   * //  { Pointer } pointer - JSON Pointer (string or array)\r\n   * //  { number = 0 } startSlice - Zero-based index of first Pointer key to use\r\n   * //  { number } endSlice - Zero-based index of last Pointer key to use\r\n   * //  { boolean = false } getBoolean - Return only true or false?\r\n   * //  { boolean = false } errors - Show error if not found?\r\n   * // { object } - Located value (or true or false if getBoolean = true)\r\n   */\r\n  static get(\r\n    object, pointer, startSlice = 0, endSlice: number = null,\r\n    getBoolean = false, errors = false\r\n  ) {\r\n    if (object === null) { return getBoolean ? false : undefined; }\r\n    let keyArray: any[] = this.parse(pointer, errors);\r\n    if (typeof object === 'object' && keyArray !== null) {\r\n      let subObject = object;\r\n      if (startSlice >= keyArray.length || endSlice <= -keyArray.length) { return object; }\r\n      if (startSlice <= -keyArray.length) { startSlice = 0; }\r\n      if (!isDefined(endSlice) || endSlice >= keyArray.length) { endSlice = keyArray.length; }\r\n      keyArray = keyArray.slice(startSlice, endSlice);\r\n      for (let key of keyArray) {\r\n        if (key === '-' && isArray(subObject) && subObject.length) {\r\n          key = subObject.length - 1;\r\n        }\r\n        if (isMap(subObject) && subObject.has(key)) {\r\n          subObject = subObject.get(key);\r\n        } else if (typeof subObject === 'object' && subObject !== null &&\r\n          hasOwn(subObject, key)\r\n        ) {\r\n          subObject = subObject[key];\r\n        } else {\r\n          const evaluatedExpression = JsonPointer.evaluateExpression(subObject, key);\r\n          if (evaluatedExpression.passed) {\r\n            subObject = evaluatedExpression.key ? subObject[evaluatedExpression.key] : subObject;\r\n          } else {\r\n            this.logErrors(errors, key, pointer, object);\r\n            return getBoolean ? false : undefined;\r\n          }\r\n        }\r\n      }\r\n      return getBoolean ? true : subObject;\r\n    }\r\n    if (errors && keyArray === null) {\r\n      console.error(`get error: Invalid JSON Pointer: ${pointer}`);\r\n    }\r\n    if (errors && typeof object !== 'object') {\r\n      console.error('get error: Invalid object:');\r\n      console.error(object);\r\n    }\r\n    return getBoolean ? false : undefined;\r\n  }\r\n\r\n  private static logErrors(errors, key, pointer, object) {\r\n    if (errors) {\r\n      console.error(`get error: \"${key}\" key not found in object.`);\r\n      console.error(pointer);\r\n      console.error(object);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Evaluates conditional expression in form of `model.<property>==<value>` or\r\n   * `model.<property>!=<value>` where the first one means that the value must match to be\r\n   * shown in a form, while the former shows the property only when the property value is not\r\n   * set, or does not equal the given value.\r\n   *\r\n   * // { subObject } subObject -  an object containing the data values of properties\r\n   * // { key } key - the key from the for loop in a form of `<property>==<value>`\r\n   *\r\n   * Returns the object with two properties. The property passed informs whether\r\n   * the expression evaluated successfully and the property key returns either the same\r\n   * key if it is not contained inside the subObject or the key of the property if it is contained.\r\n   */\r\n  static evaluateExpression(subObject: Object, key: any) {\r\n    const defaultResult = {passed: false, key: key};\r\n    const keysAndExpression = this.parseKeysAndExpression(key, subObject);\r\n    if (!keysAndExpression) {\r\n      return defaultResult;\r\n    }\r\n\r\n    const ownCheckResult = this.doOwnCheckResult(subObject, keysAndExpression);\r\n    if (ownCheckResult) {\r\n      return ownCheckResult;\r\n    }\r\n\r\n    const cleanedValue = cleanValueOfQuotes(keysAndExpression.keyAndValue[1]);\r\n\r\n    const evaluatedResult = this.performExpressionOnValue(keysAndExpression, cleanedValue, subObject);\r\n    if (evaluatedResult) {\r\n      return evaluatedResult;\r\n    }\r\n\r\n    return defaultResult;\r\n  }\r\n\r\n  /**\r\n   * Performs the actual evaluation on the given expression with given values and keys.\r\n   * // { cleanedValue } cleanedValue - the given valued cleaned of quotes if it had any\r\n   * // { subObject } subObject - the object with properties values\r\n   * // { keysAndExpression } keysAndExpression - an object holding the expressions with\r\n   */\r\n  private static performExpressionOnValue(keysAndExpression: any, cleanedValue: String, subObject: Object) {\r\n    const propertyByKey = subObject[keysAndExpression.keyAndValue[0]];\r\n    if (this.doComparisonByExpressionType(keysAndExpression.expressionType, propertyByKey, cleanedValue)) {\r\n      return {passed: true, key: keysAndExpression.keyAndValue[0]};\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  private static doComparisonByExpressionType(expressionType: ExpressionType, propertyByKey, cleanedValue: String): Boolean {\r\n    if (isEqual(expressionType)) {\r\n      return propertyByKey === cleanedValue;\r\n    }\r\n    if (isNotEqual(expressionType)) {\r\n      return propertyByKey !== cleanedValue;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /**\r\n   * Does the checks when the parsed key is actually no a property inside subObject.\r\n   * That would mean that the equal comparison makes no sense and thus the negative result\r\n   * is returned, and the not equal comparison is not necessary because it doesn't equal\r\n   * obviously. Returns null when the given key is a real property inside the subObject.\r\n   * // { subObject } subObject - the object with properties values\r\n   * // { keysAndExpression } keysAndExpression - an object holding the expressions with\r\n   * the associated keys.\r\n   */\r\n  private static doOwnCheckResult(subObject: Object, keysAndExpression) {\r\n    let ownCheckResult = null;\r\n    if (!hasOwn(subObject, keysAndExpression.keyAndValue[0])) {\r\n      if (isEqual(keysAndExpression.expressionType)) {\r\n        ownCheckResult = {passed: false, key: null};\r\n      }\r\n      if (isNotEqual(keysAndExpression.expressionType)) {\r\n        ownCheckResult = {passed: true, key: null};\r\n      }\r\n    }\r\n    return ownCheckResult;\r\n  }\r\n\r\n  /**\r\n   * Does the basic checks and tries to parse an expression and a pair\r\n   * of key and value.\r\n   * // { key } key - the original for loop created value containing key and value in one string\r\n   * // { subObject } subObject - the object with properties values\r\n   */\r\n  private static parseKeysAndExpression(key: string, subObject) {\r\n    if (this.keyOrSubObjEmpty(key, subObject)) {\r\n      return null;\r\n    }\r\n    const expressionType = getExpressionType(key.toString());\r\n    if (isNotExpression(expressionType)) {\r\n      return null;\r\n    }\r\n    const keyAndValue = getKeyAndValueByExpressionType(expressionType, key);\r\n    if (!keyAndValue || !keyAndValue[0] || !keyAndValue[1]) {\r\n      return null;\r\n    }\r\n    return {expressionType: expressionType, keyAndValue: keyAndValue};\r\n  }\r\n\r\n  private static keyOrSubObjEmpty(key: any, subObject: Object) {\r\n    return !key || !subObject;\r\n  }\r\n\r\n  /**\r\n   * 'getCopy' function\r\n   *\r\n   * Uses a JSON Pointer to deeply clone a value from an object.\r\n   *\r\n   * //  { object } object - Object to get value from\r\n   * //  { Pointer } pointer - JSON Pointer (string or array)\r\n   * //  { number = 0 } startSlice - Zero-based index of first Pointer key to use\r\n   * //  { number } endSlice - Zero-based index of last Pointer key to use\r\n   * //  { boolean = false } getBoolean - Return only true or false?\r\n   * //  { boolean = false } errors - Show error if not found?\r\n   * // { object } - Located value (or true or false if getBoolean = true)\r\n   */\r\n  static getCopy(\r\n    object, pointer, startSlice = 0, endSlice: number = null,\r\n    getBoolean = false, errors = false\r\n  ) {\r\n    const objectToCopy =\r\n      this.get(object, pointer, startSlice, endSlice, getBoolean, errors);\r\n    return this.forEachDeepCopy(objectToCopy);\r\n  }\r\n\r\n  /**\r\n   * 'getFirst' function\r\n   *\r\n   * Takes an array of JSON Pointers and objects,\r\n   * checks each object for a value specified by the pointer,\r\n   * and returns the first value found.\r\n   *\r\n   * //  { [object, pointer][] } items - Array of objects and pointers to check\r\n   * //  { any = null } defaultValue - Value to return if nothing found\r\n   * //  { boolean = false } getCopy - Return a copy instead?\r\n   * //  - First value found\r\n   */\r\n  static getFirst(items, defaultValue: any = null, getCopy = false) {\r\n    if (isEmpty(items)) { return; }\r\n    if (isArray(items)) {\r\n      for (const item of items) {\r\n        if (isEmpty(item)) { continue; }\r\n        if (isArray(item) && item.length >= 2) {\r\n          if (isEmpty(item[0]) || isEmpty(item[1])) { continue; }\r\n          const value = getCopy ?\r\n            this.getCopy(item[0], item[1]) :\r\n            this.get(item[0], item[1]);\r\n          if (value) { return value; }\r\n          continue;\r\n        }\r\n        console.error('getFirst error: Input not in correct format.\\n' +\r\n          'Should be: [ [ object1, pointer1 ], [ object 2, pointer2 ], etc... ]');\r\n        return;\r\n      }\r\n      return defaultValue;\r\n    }\r\n    if (isMap(items)) {\r\n      for (const [object, pointer] of items) {\r\n        if (object === null || !this.isJsonPointer(pointer)) { continue; }\r\n        const value = getCopy ?\r\n          this.getCopy(object, pointer) :\r\n          this.get(object, pointer);\r\n        if (value) { return value; }\r\n      }\r\n      return defaultValue;\r\n    }\r\n    console.error('getFirst error: Input not in correct format.\\n' +\r\n      'Should be: [ [ object1, pointer1 ], [ object 2, pointer2 ], etc... ]');\r\n    return defaultValue;\r\n  }\r\n\r\n  /**\r\n   * 'getFirstCopy' function\r\n   *\r\n   * Similar to getFirst, but always returns a copy.\r\n   *\r\n   * //  { [object, pointer][] } items - Array of objects and pointers to check\r\n   * //  { any = null } defaultValue - Value to return if nothing found\r\n   * //  - Copy of first value found\r\n   */\r\n  static getFirstCopy(items, defaultValue: any = null) {\r\n    const firstCopy = this.getFirst(items, defaultValue, true);\r\n    return firstCopy;\r\n  }\r\n\r\n  /**\r\n   * 'set' function\r\n   *\r\n   * Uses a JSON Pointer to set a value on an object.\r\n   * Also creates any missing sub objects or arrays to contain that value.\r\n   *\r\n   * If the optional fourth parameter is TRUE and the inner-most container\r\n   * is an array, the function will insert the value as a new item at the\r\n   * specified location in the array, rather than overwriting the existing\r\n   * value (if any) at that location.\r\n   *\r\n   * So set([1, 2, 3], '/1', 4) => [1, 4, 3]\r\n   * and\r\n   * So set([1, 2, 3], '/1', 4, true) => [1, 4, 2, 3]\r\n   *\r\n   * //  { object } object - The object to set value in\r\n   * //  { Pointer } pointer - The JSON Pointer (string or array)\r\n   * //   value - The new value to set\r\n   * //  { boolean } insert - insert value?\r\n   * // { object } - The original object, modified with the set value\r\n   */\r\n  static set(object, pointer, value, insert = false) {\r\n    const keyArray = this.parse(pointer);\r\n    if (keyArray !== null && keyArray.length) {\r\n      let subObject = object;\r\n      for (let i = 0; i < keyArray.length - 1; ++i) {\r\n        let key = keyArray[i];\r\n        if (key === '-' && isArray(subObject)) {\r\n          key = subObject.length;\r\n        }\r\n        if (isMap(subObject) && subObject.has(key)) {\r\n          subObject = subObject.get(key);\r\n        } else {\r\n          if (!hasOwn(subObject, key)) {\r\n            subObject[key] = (keyArray[i + 1].match(/^(\\d+|-)$/)) ? [] : {};\r\n          }\r\n          subObject = subObject[key];\r\n        }\r\n      }\r\n      const lastKey = keyArray[keyArray.length - 1];\r\n      if (isArray(subObject) && lastKey === '-') {\r\n        subObject.push(value);\r\n      } else if (insert && isArray(subObject) && !isNaN(+lastKey)) {\r\n        subObject.splice(lastKey, 0, value);\r\n      } else if (isMap(subObject)) {\r\n        subObject.set(lastKey, value);\r\n      } else {\r\n        subObject[lastKey] = value;\r\n      }\r\n      return object;\r\n    }\r\n    console.error(`set error: Invalid JSON Pointer: ${pointer}`);\r\n    return object;\r\n  }\r\n\r\n  /**\r\n   * 'setCopy' function\r\n   *\r\n   * Copies an object and uses a JSON Pointer to set a value on the copy.\r\n   * Also creates any missing sub objects or arrays to contain that value.\r\n   *\r\n   * If the optional fourth parameter is TRUE and the inner-most container\r\n   * is an array, the function will insert the value as a new item at the\r\n   * specified location in the array, rather than overwriting the existing value.\r\n   *\r\n   * //  { object } object - The object to copy and set value in\r\n   * //  { Pointer } pointer - The JSON Pointer (string or array)\r\n   * //   value - The value to set\r\n   * //  { boolean } insert - insert value?\r\n   * // { object } - The new object with the set value\r\n   */\r\n  static setCopy(object, pointer, value, insert = false) {\r\n    const keyArray = this.parse(pointer);\r\n    if (keyArray !== null) {\r\n      const newObject = copy(object);\r\n      let subObject = newObject;\r\n      for (let i = 0; i < keyArray.length - 1; ++i) {\r\n        let key = keyArray[i];\r\n        if (key === '-' && isArray(subObject)) {\r\n          key = subObject.length;\r\n        }\r\n        if (isMap(subObject) && subObject.has(key)) {\r\n          subObject.set(key, copy(subObject.get(key)));\r\n          subObject = subObject.get(key);\r\n        } else {\r\n          if (!hasOwn(subObject, key)) {\r\n            subObject[key] = (keyArray[i + 1].match(/^(\\d+|-)$/)) ? [] : {};\r\n          }\r\n          subObject[key] = copy(subObject[key]);\r\n          subObject = subObject[key];\r\n        }\r\n      }\r\n      const lastKey = keyArray[keyArray.length - 1];\r\n      if (isArray(subObject) && lastKey === '-') {\r\n        subObject.push(value);\r\n      } else if (insert && isArray(subObject) && !isNaN(+lastKey)) {\r\n        subObject.splice(lastKey, 0, value);\r\n      } else if (isMap(subObject)) {\r\n        subObject.set(lastKey, value);\r\n      } else {\r\n        subObject[lastKey] = value;\r\n      }\r\n      return newObject;\r\n    }\r\n    console.error(`setCopy error: Invalid JSON Pointer: ${pointer}`);\r\n    return object;\r\n  }\r\n\r\n  /**\r\n   * 'insert' function\r\n   *\r\n   * Calls 'set' with insert = TRUE\r\n   *\r\n   * //  { object } object - object to insert value in\r\n   * //  { Pointer } pointer - JSON Pointer (string or array)\r\n   * //   value - value to insert\r\n   * // { object }\r\n   */\r\n  static insert(object, pointer, value) {\r\n    const updatedObject = this.set(object, pointer, value, true);\r\n    return updatedObject;\r\n  }\r\n\r\n  /**\r\n   * 'insertCopy' function\r\n   *\r\n   * Calls 'setCopy' with insert = TRUE\r\n   *\r\n   * //  { object } object - object to insert value in\r\n   * //  { Pointer } pointer - JSON Pointer (string or array)\r\n   * //   value - value to insert\r\n   * // { object }\r\n   */\r\n  static insertCopy(object, pointer, value) {\r\n    const updatedObject = this.setCopy(object, pointer, value, true);\r\n    return updatedObject;\r\n  }\r\n\r\n  /**\r\n   * 'remove' function\r\n   *\r\n   * Uses a JSON Pointer to remove a key and its attribute from an object\r\n   *\r\n   * //  { object } object - object to delete attribute from\r\n   * //  { Pointer } pointer - JSON Pointer (string or array)\r\n   * // { object }\r\n   */\r\n  static remove(object, pointer) {\r\n    const keyArray = this.parse(pointer);\r\n    if (keyArray !== null && keyArray.length) {\r\n      let lastKey = keyArray.pop();\r\n      const parentObject = this.get(object, keyArray);\r\n      if (isArray(parentObject)) {\r\n        if (lastKey === '-') { lastKey = parentObject.length - 1; }\r\n        parentObject.splice(lastKey, 1);\r\n      } else if (isObject(parentObject)) {\r\n        delete parentObject[lastKey];\r\n      }\r\n      return object;\r\n    }\r\n    console.error(`remove error: Invalid JSON Pointer: ${pointer}`);\r\n    return object;\r\n  }\r\n\r\n  /**\r\n   * 'has' function\r\n   *\r\n   * Tests if an object has a value at the location specified by a JSON Pointer\r\n   *\r\n   * //  { object } object - object to chek for value\r\n   * //  { Pointer } pointer - JSON Pointer (string or array)\r\n   * // { boolean }\r\n   */\r\n  static has(object, pointer) {\r\n    const hasValue = this.get(object, pointer, 0, null, true);\r\n    return hasValue;\r\n  }\r\n\r\n  /**\r\n   * 'dict' function\r\n   *\r\n   * Returns a (pointer -> value) dictionary for an object\r\n   *\r\n   * //  { object } object - The object to create a dictionary from\r\n   * // { object } - The resulting dictionary object\r\n   */\r\n  static dict(object) {\r\n    const results: any = {};\r\n    this.forEachDeep(object, (value, pointer) => {\r\n      if (typeof value !== 'object') { results[pointer] = value; }\r\n    });\r\n    return results;\r\n  }\r\n\r\n  /**\r\n   * 'forEachDeep' function\r\n   *\r\n   * Iterates over own enumerable properties of an object or items in an array\r\n   * and invokes an iteratee function for each key/value or index/value pair.\r\n   * By default, iterates over items within objects and arrays after calling\r\n   * the iteratee function on the containing object or array itself.\r\n   *\r\n   * The iteratee is invoked with three arguments: (value, pointer, rootObject),\r\n   * where pointer is a JSON pointer indicating the location of the current\r\n   * value within the root object, and rootObject is the root object initially\r\n   * submitted to th function.\r\n   *\r\n   * If a third optional parameter 'bottomUp' is set to TRUE, the iterator\r\n   * function will be called on sub-objects and arrays after being\r\n   * called on their contents, rather than before, which is the default.\r\n   *\r\n   * This function can also optionally be called directly on a sub-object by\r\n   * including optional 4th and 5th parameterss to specify the initial\r\n   * root object and pointer.\r\n   *\r\n   * //  { object } object - the initial object or array\r\n   * //  { (v: any, p?: string, o?: any) => any } function - iteratee function\r\n   * //  { boolean = false } bottomUp - optional, set to TRUE to reverse direction\r\n   * //  { object = object } rootObject - optional, root object or array\r\n   * //  { string = '' } pointer - optional, JSON Pointer to object within rootObject\r\n   * // { object } - The modified object\r\n   */\r\n  static forEachDeep(\r\n    object, fn: (v: any, p?: string, o?: any) => any = (v) => v,\r\n    bottomUp = false, pointer = '', rootObject = object\r\n  ) {\r\n    if (typeof fn !== 'function') {\r\n      console.error(`forEachDeep error: Iterator is not a function:`, fn);\r\n      return;\r\n    }\r\n    if (!bottomUp) { fn(object, pointer, rootObject); }\r\n    if (isObject(object) || isArray(object)) {\r\n      for (const key of Object.keys(object)) {\r\n        const newPointer = pointer + '/' + this.escape(key);\r\n        this.forEachDeep(object[key], fn, bottomUp, newPointer, rootObject);\r\n      }\r\n    }\r\n    if (bottomUp) { fn(object, pointer, rootObject); }\r\n  }\r\n\r\n  /**\r\n   * 'forEachDeepCopy' function\r\n   *\r\n   * Similar to forEachDeep, but returns a copy of the original object, with\r\n   * the same keys and indexes, but with values replaced with the result of\r\n   * the iteratee function.\r\n   *\r\n   * //  { object } object - the initial object or array\r\n   * //  { (v: any, k?: string, o?: any, p?: any) => any } function - iteratee function\r\n   * //  { boolean = false } bottomUp - optional, set to TRUE to reverse direction\r\n   * //  { object = object } rootObject - optional, root object or array\r\n   * //  { string = '' } pointer - optional, JSON Pointer to object within rootObject\r\n   * // { object } - The copied object\r\n   */\r\n  static forEachDeepCopy(\r\n    object, fn: (v: any, p?: string, o?: any) => any = (v) => v,\r\n    bottomUp = false, pointer = '', rootObject = object\r\n  ) {\r\n    if (typeof fn !== 'function') {\r\n      console.error(`forEachDeepCopy error: Iterator is not a function:`, fn);\r\n      return null;\r\n    }\r\n    if (isObject(object) || isArray(object)) {\r\n      let newObject = isArray(object) ? [ ...object ] : { ...object };\r\n      if (!bottomUp) { newObject = fn(newObject, pointer, rootObject); }\r\n      for (const key of Object.keys(newObject)) {\r\n        const newPointer = pointer + '/' + this.escape(key);\r\n        newObject[key] = this.forEachDeepCopy(\r\n          newObject[key], fn, bottomUp, newPointer, rootObject\r\n        );\r\n      }\r\n      if (bottomUp) { newObject = fn(newObject, pointer, rootObject); }\r\n      return newObject;\r\n    } else {\r\n      return fn(object, pointer, rootObject);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * 'escape' function\r\n   *\r\n   * Escapes a string reference key\r\n   *\r\n   * //  { string } key - string key to escape\r\n   * // { string } - escaped key\r\n   */\r\n  static escape(key) {\r\n    const escaped = key.toString().replace(/~/g, '~0').replace(/\\//g, '~1');\r\n    return escaped;\r\n  }\r\n\r\n  /**\r\n   * 'unescape' function\r\n   *\r\n   * Unescapes a string reference key\r\n   *\r\n   * //  { string } key - string key to unescape\r\n   * // { string } - unescaped key\r\n   */\r\n  static unescape(key) {\r\n    const unescaped = key.toString().replace(/~1/g, '/').replace(/~0/g, '~');\r\n    return unescaped;\r\n  }\r\n\r\n  /**\r\n   * 'parse' function\r\n   *\r\n   * Converts a string JSON Pointer into a array of keys\r\n   * (if input is already an an array of keys, it is returned unchanged)\r\n   *\r\n   * //  { Pointer } pointer - JSON Pointer (string or array)\r\n   * //  { boolean = false } errors - Show error if invalid pointer?\r\n   * // { string[] } - JSON Pointer array of keys\r\n   */\r\n  static parse(pointer, errors = false) {\r\n    if (!this.isJsonPointer(pointer)) {\r\n      if (errors) { console.error(`parse error: Invalid JSON Pointer: ${pointer}`); }\r\n      return null;\r\n    }\r\n    if (isArray(pointer)) { return <string[]>pointer; }\r\n    if (typeof pointer === 'string') {\r\n      if ((<string>pointer)[0] === '#') { pointer = pointer.slice(1); }\r\n      if (<string>pointer === '' || <string>pointer === '/') { return []; }\r\n      return (<string>pointer).slice(1).split('/').map(this.unescape);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * 'compile' function\r\n   *\r\n   * Converts an array of keys into a JSON Pointer string\r\n   * (if input is already a string, it is normalized and returned)\r\n   *\r\n   * The optional second parameter is a default which will replace any empty keys.\r\n   *\r\n   * //  { Pointer } pointer - JSON Pointer (string or array)\r\n   * //  { string | number = '' } defaultValue - Default value\r\n   * //  { boolean = false } errors - Show error if invalid pointer?\r\n   * // { string } - JSON Pointer string\r\n   */\r\n  static compile(pointer, defaultValue = '', errors = false) {\r\n    if (pointer === '#') { return ''; }\r\n    if (!this.isJsonPointer(pointer)) {\r\n      if (errors) { console.error(`compile error: Invalid JSON Pointer: ${pointer}`); }\r\n      return null;\r\n    }\r\n    if (isArray(pointer)) {\r\n      if ((<string[]>pointer).length === 0) { return ''; }\r\n      return '/' + (<string[]>pointer).map(\r\n        key => key === '' ? defaultValue : this.escape(key)\r\n      ).join('/');\r\n    }\r\n    if (typeof pointer === 'string') {\r\n      if (pointer[0] === '#') { pointer = pointer.slice(1); }\r\n      return pointer;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * 'toKey' function\r\n   *\r\n   * Extracts name of the final key from a JSON Pointer.\r\n   *\r\n   * //  { Pointer } pointer - JSON Pointer (string or array)\r\n   * //  { boolean = false } errors - Show error if invalid pointer?\r\n   * // { string } - the extracted key\r\n   */\r\n  static toKey(pointer, errors = false) {\r\n    const keyArray = this.parse(pointer, errors);\r\n    if (keyArray === null) { return null; }\r\n    if (!keyArray.length) { return ''; }\r\n    return keyArray[keyArray.length - 1];\r\n  }\r\n\r\n  /**\r\n   * 'isJsonPointer' function\r\n   *\r\n   * Checks a string or array value to determine if it is a valid JSON Pointer.\r\n   * Returns true if a string is empty, or starts with '/' or '#/'.\r\n   * Returns true if an array contains only string values.\r\n   *\r\n   * //   value - value to check\r\n   * // { boolean } - true if value is a valid JSON Pointer, otherwise false\r\n   */\r\n  static isJsonPointer(value) {\r\n    if (isArray(value)) {\r\n      return value.every(key => typeof key === 'string');\r\n    } else if (isString(value)) {\r\n      if (value === '' || value === '#') { return true; }\r\n      if (value[0] === '/' || value.slice(0, 2) === '#/') {\r\n        return !/(~[^01]|~$)/g.test(value);\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /**\r\n   * 'isSubPointer' function\r\n   *\r\n   * Checks whether one JSON Pointer is a subset of another.\r\n   *\r\n   * //  { Pointer } shortPointer - potential subset JSON Pointer\r\n   * //  { Pointer } longPointer - potential superset JSON Pointer\r\n   * //  { boolean = false } trueIfMatching - return true if pointers match?\r\n   * //  { boolean = false } errors - Show error if invalid pointer?\r\n   * // { boolean } - true if shortPointer is a subset of longPointer, false if not\r\n   */\r\n  static isSubPointer(\r\n    shortPointer, longPointer, trueIfMatching = false, errors = false\r\n  ) {\r\n    if (!this.isJsonPointer(shortPointer) || !this.isJsonPointer(longPointer)) {\r\n      if (errors) {\r\n        let invalid = '';\r\n        if (!this.isJsonPointer(shortPointer)) { invalid += ` 1: ${shortPointer}`; }\r\n        if (!this.isJsonPointer(longPointer)) { invalid += ` 2: ${longPointer}`; }\r\n        console.error(`isSubPointer error: Invalid JSON Pointer ${invalid}`);\r\n      }\r\n      return;\r\n    }\r\n    shortPointer = this.compile(shortPointer, '', errors);\r\n    longPointer = this.compile(longPointer, '', errors);\r\n    return shortPointer === longPointer ? trueIfMatching :\r\n      `${shortPointer}/` === longPointer.slice(0, shortPointer.length + 1);\r\n  }\r\n\r\n  /**\r\n   * 'toIndexedPointer' function\r\n   *\r\n   * Merges an array of numeric indexes and a generic pointer to create an\r\n   * indexed pointer for a specific item.\r\n   *\r\n   * For example, merging the generic pointer '/foo/-/bar/-/baz' and\r\n   * the array [4, 2] would result in the indexed pointer '/foo/4/bar/2/baz'\r\n   *\r\n   *\r\n   * //  { Pointer } genericPointer - The generic pointer\r\n   * //  { number[] } indexArray - The array of numeric indexes\r\n   * //  { Map<string, number> } arrayMap - An optional array map\r\n   * // { string } - The merged pointer with indexes\r\n   */\r\n  static toIndexedPointer(\r\n    genericPointer, indexArray, arrayMap: Map<string, number> = null\r\n  ) {\r\n    if (this.isJsonPointer(genericPointer) && isArray(indexArray)) {\r\n      let indexedPointer = this.compile(genericPointer);\r\n      if (isMap(arrayMap)) {\r\n        let arrayIndex = 0;\r\n        return indexedPointer.replace(/\\/\\-(?=\\/|$)/g, (key, stringIndex) =>\r\n          arrayMap.has((<string>indexedPointer).slice(0, stringIndex)) ?\r\n            '/' + indexArray[arrayIndex++] : key\r\n        );\r\n      } else {\r\n        for (const pointerIndex of indexArray) {\r\n          indexedPointer = indexedPointer.replace('/-', '/' + pointerIndex);\r\n        }\r\n        return indexedPointer;\r\n      }\r\n    }\r\n    if (!this.isJsonPointer(genericPointer)) {\r\n      console.error(`toIndexedPointer error: Invalid JSON Pointer: ${genericPointer}`);\r\n    }\r\n    if (!isArray(indexArray)) {\r\n      console.error(`toIndexedPointer error: Invalid indexArray: ${indexArray}`);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * 'toGenericPointer' function\r\n   *\r\n   * Compares an indexed pointer to an array map and removes list array\r\n   * indexes (but leaves tuple arrray indexes and all object keys, including\r\n   * numeric keys) to create a generic pointer.\r\n   *\r\n   * For example, using the indexed pointer '/foo/1/bar/2/baz/3' and\r\n   * the arrayMap [['/foo', 0], ['/foo/-/bar', 3], ['/foo/-/bar/-/baz', 0]]\r\n   * would result in the generic pointer '/foo/-/bar/2/baz/-'\r\n   * Using the indexed pointer '/foo/1/bar/4/baz/3' and the same arrayMap\r\n   * would result in the generic pointer '/foo/-/bar/-/baz/-'\r\n   * (the bar array has 3 tuple items, so index 2 is retained, but 4 is removed)\r\n   *\r\n   * The structure of the arrayMap is: [['path to array', number of tuple items]...]\r\n   *\r\n   *\r\n   * //  { Pointer } indexedPointer - The indexed pointer (array or string)\r\n   * //  { Map<string, number> } arrayMap - The optional array map (for preserving tuple indexes)\r\n   * // { string } - The generic pointer with indexes removed\r\n   */\r\n  static toGenericPointer(indexedPointer, arrayMap = new Map<string, number>()) {\r\n    if (this.isJsonPointer(indexedPointer) && isMap(arrayMap)) {\r\n      const pointerArray = this.parse(indexedPointer);\r\n      for (let i = 1; i < pointerArray.length; i++) {\r\n        const subPointer = this.compile(pointerArray.slice(0, i));\r\n        if (arrayMap.has(subPointer) &&\r\n          arrayMap.get(subPointer) <= +pointerArray[i]\r\n        ) {\r\n          pointerArray[i] = '-';\r\n        }\r\n      }\r\n      return this.compile(pointerArray);\r\n    }\r\n    if (!this.isJsonPointer(indexedPointer)) {\r\n      console.error(`toGenericPointer error: invalid JSON Pointer: ${indexedPointer}`);\r\n    }\r\n    if (!isMap(arrayMap)) {\r\n      console.error(`toGenericPointer error: invalid arrayMap: ${arrayMap}`);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * 'toControlPointer' function\r\n   *\r\n   * Accepts a JSON Pointer for a data object and returns a JSON Pointer for the\r\n   * matching control in an Angular FormGroup.\r\n   *\r\n   * //  { Pointer } dataPointer - JSON Pointer (string or array) to a data object\r\n   * //  { FormGroup } formGroup - Angular FormGroup to get value from\r\n   * //  { boolean = false } controlMustExist - Only return if control exists?\r\n   * // { Pointer } - JSON Pointer (string) to the formGroup object\r\n   */\r\n  static toControlPointer(dataPointer, formGroup, controlMustExist = false) {\r\n    const dataPointerArray = this.parse(dataPointer);\r\n    const controlPointerArray: string[] = [];\r\n    let subGroup = formGroup;\r\n    if (dataPointerArray !== null) {\r\n      for (const key of dataPointerArray) {\r\n        if (hasOwn(subGroup, 'controls')) {\r\n          controlPointerArray.push('controls');\r\n          subGroup = subGroup.controls;\r\n        }\r\n        if (isArray(subGroup) && (key === '-')) {\r\n          controlPointerArray.push((subGroup.length - 1).toString());\r\n          subGroup = subGroup[subGroup.length - 1];\r\n        } else if (hasOwn(subGroup, key)) {\r\n          controlPointerArray.push(key);\r\n          subGroup = subGroup[key];\r\n        } else if (controlMustExist) {\r\n          console.error(`toControlPointer error: Unable to find \"${key}\" item in FormGroup.`);\r\n          console.error(dataPointer);\r\n          console.error(formGroup);\r\n          return;\r\n        } else {\r\n          controlPointerArray.push(key);\r\n          subGroup = { controls: {} };\r\n        }\r\n      }\r\n      return this.compile(controlPointerArray);\r\n    }\r\n    console.error(`toControlPointer error: Invalid JSON Pointer: ${dataPointer}`);\r\n  }\r\n\r\n  /**\r\n   * 'toSchemaPointer' function\r\n   *\r\n   * Accepts a JSON Pointer to a value inside a data object and a JSON schema\r\n   * for that object.\r\n   *\r\n   * Returns a Pointer to the sub-schema for the value inside the object's schema.\r\n   *\r\n   * //  { Pointer } dataPointer - JSON Pointer (string or array) to an object\r\n   * //   schema - JSON schema for the object\r\n   * // { Pointer } - JSON Pointer (string) to the object's schema\r\n   */\r\n  static toSchemaPointer(dataPointer, schema) {\r\n    if (this.isJsonPointer(dataPointer) && typeof schema === 'object') {\r\n      const pointerArray = this.parse(dataPointer);\r\n      if (!pointerArray.length) { return ''; }\r\n      const firstKey = pointerArray.shift();\r\n      if (schema.type === 'object' || schema.properties || schema.additionalProperties) {\r\n        if ((schema.properties || {})[firstKey]) {\r\n          return `/properties/${this.escape(firstKey)}` +\r\n            this.toSchemaPointer(pointerArray, schema.properties[firstKey]);\r\n        } else  if (schema.additionalProperties) {\r\n          return '/additionalProperties' +\r\n            this.toSchemaPointer(pointerArray, schema.additionalProperties);\r\n        }\r\n      }\r\n      if ((schema.type === 'array' || schema.items) &&\r\n        (isNumber(firstKey) || firstKey === '-' || firstKey === '')\r\n      ) {\r\n        const arrayItem = firstKey === '-' || firstKey === '' ? 0 : +firstKey;\r\n        if (isArray(schema.items)) {\r\n          if (arrayItem < schema.items.length) {\r\n            return '/items/' + arrayItem +\r\n              this.toSchemaPointer(pointerArray, schema.items[arrayItem]);\r\n          } else if (schema.additionalItems) {\r\n            return '/additionalItems' +\r\n              this.toSchemaPointer(pointerArray, schema.additionalItems);\r\n          }\r\n        } else if (isObject(schema.items)) {\r\n          return '/items' + this.toSchemaPointer(pointerArray, schema.items);\r\n        } else if (isObject(schema.additionalItems)) {\r\n          return '/additionalItems' +\r\n            this.toSchemaPointer(pointerArray, schema.additionalItems);\r\n        }\r\n      }\r\n      console.error(`toSchemaPointer error: Data pointer ${dataPointer} ` +\r\n        `not compatible with schema ${schema}`);\r\n      return null;\r\n    }\r\n    if (!this.isJsonPointer(dataPointer)) {\r\n      console.error(`toSchemaPointer error: Invalid JSON Pointer: ${dataPointer}`);\r\n    }\r\n    if (typeof schema !== 'object') {\r\n      console.error(`toSchemaPointer error: Invalid JSON Schema: ${schema}`);\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * 'toDataPointer' function\r\n   *\r\n   * Accepts a JSON Pointer to a sub-schema inside a JSON schema and the schema.\r\n   *\r\n   * If possible, returns a generic Pointer to the corresponding value inside\r\n   * the data object described by the JSON schema.\r\n   *\r\n   * Returns null if the sub-schema is in an ambiguous location (such as\r\n   * definitions or additionalProperties) where the corresponding value\r\n   * location cannot be determined.\r\n   *\r\n   * //  { Pointer } schemaPointer - JSON Pointer (string or array) to a JSON schema\r\n   * //   schema - the JSON schema\r\n   * //  { boolean = false } errors - Show errors?\r\n   * // { Pointer } - JSON Pointer (string) to the value in the data object\r\n   */\r\n  static toDataPointer(schemaPointer, schema, errors = false) {\r\n    if (this.isJsonPointer(schemaPointer) && typeof schema === 'object' &&\r\n      this.has(schema, schemaPointer)\r\n    ) {\r\n      const pointerArray = this.parse(schemaPointer);\r\n      if (!pointerArray.length) { return ''; }\r\n      const firstKey = pointerArray.shift();\r\n      if (firstKey === 'properties' ||\r\n        (firstKey === 'items' && isArray(schema.items))\r\n      ) {\r\n        const secondKey = pointerArray.shift();\r\n        const pointerSuffix = this.toDataPointer(pointerArray, schema[firstKey][secondKey]);\r\n        return pointerSuffix === null ? null : '/' + secondKey + pointerSuffix;\r\n      } else if (firstKey === 'additionalItems' ||\r\n        (firstKey === 'items' && isObject(schema.items))\r\n      ) {\r\n        const pointerSuffix = this.toDataPointer(pointerArray, schema[firstKey]);\r\n        return pointerSuffix === null ? null : '/-' + pointerSuffix;\r\n      } else if (['allOf', 'anyOf', 'oneOf'].includes(firstKey)) {\r\n        const secondKey = pointerArray.shift();\r\n        return this.toDataPointer(pointerArray, schema[firstKey][secondKey]);\r\n      } else if (firstKey === 'not') {\r\n        return this.toDataPointer(pointerArray, schema[firstKey]);\r\n      } else if (['contains', 'definitions', 'dependencies', 'additionalItems',\r\n        'additionalProperties', 'patternProperties', 'propertyNames'].includes(firstKey)\r\n      ) {\r\n        if (errors) { console.error(`toDataPointer error: Ambiguous location`); }\r\n      }\r\n      return '';\r\n    }\r\n    if (errors) {\r\n      if (!this.isJsonPointer(schemaPointer)) {\r\n        console.error(`toDataPointer error: Invalid JSON Pointer: ${schemaPointer}`);\r\n      }\r\n      if (typeof schema !== 'object') {\r\n        console.error(`toDataPointer error: Invalid JSON Schema: ${schema}`);\r\n      }\r\n      if (typeof schema !== 'object') {\r\n        console.error(`toDataPointer error: Pointer ${schemaPointer} invalid for Schema: ${schema}`);\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * 'parseObjectPath' function\r\n   *\r\n   * Parses a JavaScript object path into an array of keys, which\r\n   * can then be passed to compile() to convert into a string JSON Pointer.\r\n   *\r\n   * Based on mike-marcacci's excellent objectpath parse function:\r\n   * https://github.com/mike-marcacci/objectpath\r\n   *\r\n   * //  { Pointer } path - The object path to parse\r\n   * // { string[] } - The resulting array of keys\r\n   */\r\n  static parseObjectPath(path) {\r\n    if (isArray(path)) { return <string[]>path; }\r\n    if (this.isJsonPointer(path)) { return this.parse(path); }\r\n    if (typeof path === 'string') {\r\n      let index = 0;\r\n      const parts: string[] = [];\r\n      while (index < path.length) {\r\n        const nextDot = path.indexOf('.', index);\r\n        const nextOB = path.indexOf('[', index); // next open bracket\r\n        if (nextDot === -1 && nextOB === -1) { // last item\r\n          parts.push(path.slice(index));\r\n          index = path.length;\r\n        } else if (nextDot !== -1 && (nextDot < nextOB || nextOB === -1)) { // dot notation\r\n          parts.push(path.slice(index, nextDot));\r\n          index = nextDot + 1;\r\n        } else { // bracket notation\r\n          if (nextOB > index) {\r\n            parts.push(path.slice(index, nextOB));\r\n            index = nextOB;\r\n          }\r\n          const quote = path.charAt(nextOB + 1);\r\n          if (quote === '\"' || quote === '\\'') { // enclosing quotes\r\n            let nextCB = path.indexOf(quote + ']', nextOB); // next close bracket\r\n            while (nextCB !== -1 && path.charAt(nextCB - 1) === '\\\\') {\r\n              nextCB = path.indexOf(quote + ']', nextCB + 2);\r\n            }\r\n            if (nextCB === -1) { nextCB = path.length; }\r\n            parts.push(path.slice(index + 2, nextCB)\r\n              .replace(new RegExp('\\\\' + quote, 'g'), quote));\r\n            index = nextCB + 2;\r\n          } else { // no enclosing quotes\r\n            let nextCB = path.indexOf(']', nextOB); // next close bracket\r\n            if (nextCB === -1) { nextCB = path.length; }\r\n            parts.push(path.slice(index + 1, nextCB));\r\n            index = nextCB + 1;\r\n          }\r\n          if (path.charAt(index) === '.') { index++; }\r\n        }\r\n      }\r\n      return parts;\r\n    }\r\n    console.error('parseObjectPath error: Input object path must be a string.');\r\n  }\r\n}\r\n"]}