@aws-cdk/assert/lib/assertions/have-resource-matchers.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.annotateMatcher = exports.matcherFrom = exports.encodedJson = exports.Capture = exports.notMatching = exports.anything = exports.stringLike = exports.match = exports.failMatcher = exports.arrayWith = exports.exactValue = exports.deepObjectLike = exports.objectLike = void 0;
const have_resource_1 = require("./have-resource");
/**
 * A matcher for an object that contains at least the given fields with the given matchers (or literals)
 *
 * Only does lenient matching one level deep, at the next level all objects must declare the
 * exact expected keys again.
 */
function objectLike(pattern) {
    return _objectContaining(pattern, false);
}
exports.objectLike = objectLike;
/**
 * A matcher for an object that contains at least the given fields with the given matchers (or literals)
 *
 * Switches to "deep" lenient matching. Nested objects also only need to contain declared keys.
 */
function deepObjectLike(pattern) {
    return _objectContaining(pattern, true);
}
exports.deepObjectLike = deepObjectLike;
function _objectContaining(pattern, deep) {
    const anno = { [deep ? '$deepObjectLike' : '$objectLike']: pattern };
    return annotateMatcher(anno, (value, inspection) => {
        if (typeof value !== 'object' || !value) {
            return failMatcher(inspection, `Expect an object but got '${typeof value}'`);
        }
        const errors = new Array();
        for (const [patternKey, patternValue] of Object.entries(pattern)) {
            if (patternValue === have_resource_1.ABSENT) {
                if (value[patternKey] !== undefined) {
                    errors.push(`Field ${patternKey} present, but shouldn't be`);
                }
                continue;
            }
            if (!(patternKey in value)) {
                errors.push(`Field ${patternKey} missing`);
                continue;
            }
            // If we are doing DEEP objectLike, translate object literals in the pattern into
            // more `deepObjectLike` matchers, even if they occur in lists.
            const matchValue = deep ? deepMatcherFromObjectLiteral(patternValue) : patternValue;
            const innerInspection = { ...inspection, failureReason: '' };
            const valueMatches = match(value[patternKey], matchValue, innerInspection);
            if (!valueMatches) {
                errors.push(`Field ${patternKey} mismatch: ${innerInspection.failureReason}`);
            }
        }
        /**
         * Transform nested object literals into more deep object matchers, if applicable
         *
         * Object literals in lists are also transformed.
         */
        function deepMatcherFromObjectLiteral(nestedPattern) {
            if (isObject(nestedPattern)) {
                return deepObjectLike(nestedPattern);
            }
            if (Array.isArray(nestedPattern)) {
                return nestedPattern.map(deepMatcherFromObjectLiteral);
            }
            return nestedPattern;
        }
        if (errors.length > 0) {
            return failMatcher(inspection, errors.join(', '));
        }
        return true;
    });
}
/**
 * Match exactly the given value
 *
 * This is the default, you only need this to escape from the deep lenient matching
 * of `deepObjectLike`.
 */
function exactValue(expected) {
    const anno = { $exactValue: expected };
    return annotateMatcher(anno, (value, inspection) => {
        return matchLiteral(value, expected, inspection);
    });
}
exports.exactValue = exactValue;
/**
 * A matcher for a list that contains all of the given elements in any order
 */
function arrayWith(...elements) {
    if (elements.length === 0) {
        return anything();
    }
    const anno = { $arrayContaining: elements.length === 1 ? elements[0] : elements };
    return annotateMatcher(anno, (value, inspection) => {
        if (!Array.isArray(value)) {
            return failMatcher(inspection, `Expect an array but got '${typeof value}'`);
        }
        for (const element of elements) {
            const failure = longestFailure(value, element);
            if (failure) {
                return failMatcher(inspection, `Array did not contain expected element, closest match at index ${failure[0]}: ${failure[1]}`);
            }
        }
        return true;
        /**
         * Return 'null' if the matcher matches anywhere in the array, otherwise the longest error and its index
         */
        function longestFailure(array, matcher) {
            let fail = null;
            for (let i = 0; i < array.length; i++) {
                const innerInspection = { ...inspection, failureReason: '' };
                if (match(array[i], matcher, innerInspection)) {
                    return null;
                }
                if (fail === null || innerInspection.failureReason.length > fail[1].length) {
                    fail = [i, innerInspection.failureReason];
                }
            }
            return fail;
        }
    });
}
exports.arrayWith = arrayWith;
/**
 * Whether a value is an object
 */
function isObject(x) {
    // Because `typeof null === 'object'`.
    return x && typeof x === 'object';
}
/**
 * Helper function to make matcher failure reporting a little easier
 *
 * Our protocol is weird (change a string on a passed-in object and return 'false'),
 * but I don't want to change that right now.
 */
function failMatcher(inspection, error) {
    inspection.failureReason = error;
    return false;
}
exports.failMatcher = failMatcher;
/**
 * Match a given literal value against a matcher
 *
 * If the matcher is a callable, use that to evaluate the value. Otherwise, the values
 * must be literally the same.
 */
function match(value, matcher, inspection) {
    if (isCallable(matcher)) {
        // Custom matcher (this mostly looks very weird because our `InspectionFailure` signature is weird)
        const innerInspection = { ...inspection, failureReason: '' };
        const result = matcher(value, innerInspection);
        if (typeof result !== 'boolean') {
            return failMatcher(inspection, `Predicate returned non-boolean return value: ${result}`);
        }
        if (!result && !innerInspection.failureReason) {
            // Custom matcher neglected to return an error
            return failMatcher(inspection, 'Predicate returned false');
        }
        // Propagate inner error in case of failure
        if (!result) {
            inspection.failureReason = innerInspection.failureReason;
        }
        return result;
    }
    return matchLiteral(value, matcher, inspection);
}
exports.match = match;
/**
 * Match a literal value at the top level.
 *
 * When recursing into arrays or objects, the nested values can be either matchers
 * or literals.
 */
function matchLiteral(value, pattern, inspection) {
    if (pattern == null) {
        return true;
    }
    const errors = new Array();
    if (Array.isArray(value) !== Array.isArray(pattern)) {
        return failMatcher(inspection, 'Array type mismatch');
    }
    if (Array.isArray(value)) {
        if (pattern.length !== value.length) {
            return failMatcher(inspection, 'Array length mismatch');
        }
        // Recurse comparison for individual objects
        for (let i = 0; i < pattern.length; i++) {
            if (!match(value[i], pattern[i], { ...inspection })) {
                errors.push(`Array element ${i} mismatch`);
            }
        }
        if (errors.length > 0) {
            return failMatcher(inspection, errors.join(', '));
        }
        return true;
    }
    if ((typeof value === 'object') !== (typeof pattern === 'object')) {
        return failMatcher(inspection, 'Object type mismatch');
    }
    if (typeof pattern === 'object') {
        // Check that all fields in the pattern have the right value
        const innerInspection = { ...inspection, failureReason: '' };
        const matcher = objectLike(pattern)(value, innerInspection);
        if (!matcher) {
            inspection.failureReason = innerInspection.failureReason;
            return false;
        }
        // Check no fields uncovered
        const realFields = new Set(Object.keys(value));
        for (const key of Object.keys(pattern)) {
            realFields.delete(key);
        }
        if (realFields.size > 0) {
            return failMatcher(inspection, `Unexpected keys present in object: ${Array.from(realFields).join(', ')}`);
        }
        return true;
    }
    if (value !== pattern) {
        return failMatcher(inspection, 'Different values');
    }
    return true;
}
/**
 * Whether a value is a callable
 */
function isCallable(x) {
    return x && {}.toString.call(x) === '[object Function]';
}
/**
 * Do a glob-like pattern match (which only supports *s). Supports multiline strings.
 */
function stringLike(pattern) {
    // Replace * with .* in the string, escape the rest and brace with ^...$
    const regex = new RegExp(`^${pattern.split('*').map(escapeRegex).join('.*')}$`, 'm');
    return annotateMatcher({ $stringContaining: pattern }, (value, failure) => {
        if (typeof value !== 'string') {
            failure.failureReason = `Expected a string, but got '${typeof value}'`;
            return false;
        }
        if (!regex.test(value)) {
            failure.failureReason = 'String did not match pattern';
            return false;
        }
        return true;
    });
}
exports.stringLike = stringLike;
/**
 * Matches any value
 */
function anything() {
    return annotateMatcher({ $anything: true }, () => true);
}
exports.anything = anything;
/**
 * Negate an inner matcher
 */
function notMatching(matcher) {
    return annotateMatcher({ $notMatching: matcher }, (value, failure) => {
        const result = matcherFrom(matcher)(value, failure);
        if (result) {
            failure.failureReason = 'Should not have matched, but did';
            return false;
        }
        return true;
    });
}
exports.notMatching = notMatching;
/**
 * Captures a value onto an object if it matches a given inner matcher
 *
 * @example
 *
 * const someValue = Capture.aString();
 * expect(stack).toHaveResource({
 *    // ...
 *    Value: someValue.capture(stringMatching('*a*')),
 * });
 * console.log(someValue.capturedValue);
 */
class Capture {
    constructor(typeValidator) {
        this.typeValidator = typeValidator;
        this._didCapture = false;
        this._wasInvoked = false;
    }
    /**
     * A Capture object that captures any type
     */
    static anyType() {
        return new Capture();
    }
    /**
     * A Capture object that captures a string type
     */
    static aString() {
        return new Capture((x) => {
            if (typeof x !== 'string') {
                throw new Error(`Expected to capture a string, got '${x}'`);
            }
            return true;
        });
    }
    /**
     * A Capture object that captures a custom type
     */
    // eslint-disable-next-line @typescript-eslint/no-shadow
    static a(validator) {
        return new Capture(validator);
    }
    /**
     * Capture the value if the inner matcher successfully matches it
     *
     * If no matcher is given, `anything()` is assumed.
     *
     * And exception will be thrown if the inner matcher returns `true` and
     * the value turns out to be of a different type than the `Capture` object
     * is expecting.
     */
    capture(matcher) {
        if (matcher === undefined) {
            matcher = anything();
        }
        return annotateMatcher({ $capture: matcher }, (value, failure) => {
            this._wasInvoked = true;
            const result = matcherFrom(matcher)(value, failure);
            if (result) {
                if (this.typeValidator && !this.typeValidator(value)) {
                    throw new Error(`Value not of the expected type: ${value}`);
                }
                this._didCapture = true;
                this._value = value;
            }
            return result;
        });
    }
    /**
     * Whether a value was successfully captured
     */
    get didCapture() {
        return this._didCapture;
    }
    /**
     * Return the value that was captured
     *
     * Throws an exception if now value was captured
     */
    get capturedValue() {
        // When this module is ported to jsii, the type parameter will obviously
        // have to be dropped and this will have to turn into an `any`.
        if (!this.didCapture) {
            throw new Error(`Did not capture a value: ${this._wasInvoked ? 'inner matcher failed' : 'never invoked'}`);
        }
        return this._value;
    }
}
exports.Capture = Capture;
/**
 * Match on the innards of a JSON string, instead of the complete string
 */
function encodedJson(matcher) {
    return annotateMatcher({ $encodedJson: matcher }, (value, failure) => {
        if (typeof value !== 'string') {
            failure.failureReason = `Expected a string, but got '${typeof value}'`;
            return false;
        }
        let decoded;
        try {
            decoded = JSON.parse(value);
        }
        catch (e) {
            failure.failureReason = `String is not JSON: ${e}`;
            return false;
        }
        return matcherFrom(matcher)(decoded, failure);
    });
}
exports.encodedJson = encodedJson;
function escapeRegex(s) {
    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
}
/**
 * Make a matcher out of the given argument if it's not a matcher already
 *
 * If it's not a matcher, it will be treated as a literal.
 */
function matcherFrom(matcher) {
    return isCallable(matcher) ? matcher : exactValue(matcher);
}
exports.matcherFrom = matcherFrom;
/**
 * Annotate a matcher with toJSON
 *
 * We will JSON.stringify() values if we have a match failure, but for matchers this
 * would show (in traditional JS fashion) something like '[function Function]', or more
 * accurately nothing at all since functions cannot be JSONified.
 *
 * We override to JSON() in order to produce a readadable version of the matcher.
 */
function annotateMatcher(how, matcher) {
    matcher.toJSON = () => how;
    return matcher;
}
exports.annotateMatcher = annotateMatcher;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"have-resource-matchers.js","sourceRoot":"","sources":["have-resource-matchers.ts"],"names":[],"mappings":"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","sourcesContent":["import { ABSENT, InspectionFailure, PropertyMatcher } from './have-resource';\n\n/**\n * A matcher for an object that contains at least the given fields with the given matchers (or literals)\n *\n * Only does lenient matching one level deep, at the next level all objects must declare the\n * exact expected keys again.\n */\nexport function objectLike<A extends object>(pattern: A): PropertyMatcher {\n  return _objectContaining(pattern, false);\n}\n\n/**\n * A matcher for an object that contains at least the given fields with the given matchers (or literals)\n *\n * Switches to \"deep\" lenient matching. Nested objects also only need to contain declared keys.\n */\nexport function deepObjectLike<A extends object>(pattern: A): PropertyMatcher {\n  return _objectContaining(pattern, true);\n}\n\nfunction _objectContaining<A extends object>(pattern: A, deep: boolean): PropertyMatcher {\n  const anno = { [deep ? '$deepObjectLike' : '$objectLike']: pattern };\n\n  return annotateMatcher(anno, (value: any, inspection: InspectionFailure): boolean => {\n    if (typeof value !== 'object' || !value) {\n      return failMatcher(inspection, `Expect an object but got '${typeof value}'`);\n    }\n\n    const errors = new Array<string>();\n\n    for (const [patternKey, patternValue] of Object.entries(pattern)) {\n      if (patternValue === ABSENT) {\n        if (value[patternKey] !== undefined) { errors.push(`Field ${patternKey} present, but shouldn't be`); }\n        continue;\n      }\n\n      if (!(patternKey in value)) {\n        errors.push(`Field ${patternKey} missing`);\n        continue;\n      }\n\n      // If we are doing DEEP objectLike, translate object literals in the pattern into\n      // more `deepObjectLike` matchers, even if they occur in lists.\n      const matchValue = deep ? deepMatcherFromObjectLiteral(patternValue) : patternValue;\n\n      const innerInspection = { ...inspection, failureReason: '' };\n      const valueMatches = match(value[patternKey], matchValue, innerInspection);\n      if (!valueMatches) {\n        errors.push(`Field ${patternKey} mismatch: ${innerInspection.failureReason}`);\n      }\n    }\n\n    /**\n     * Transform nested object literals into more deep object matchers, if applicable\n     *\n     * Object literals in lists are also transformed.\n     */\n    function deepMatcherFromObjectLiteral(nestedPattern: any): any {\n      if (isObject(nestedPattern)) {\n        return deepObjectLike(nestedPattern);\n      }\n      if (Array.isArray(nestedPattern)) {\n        return nestedPattern.map(deepMatcherFromObjectLiteral);\n      }\n      return nestedPattern;\n    }\n\n    if (errors.length > 0) {\n      return failMatcher(inspection, errors.join(', '));\n    }\n    return true;\n  });\n}\n\n/**\n * Match exactly the given value\n *\n * This is the default, you only need this to escape from the deep lenient matching\n * of `deepObjectLike`.\n */\nexport function exactValue(expected: any): PropertyMatcher {\n  const anno = { $exactValue: expected };\n  return annotateMatcher(anno, (value: any, inspection: InspectionFailure): boolean => {\n    return matchLiteral(value, expected, inspection);\n  });\n}\n\n/**\n * A matcher for a list that contains all of the given elements in any order\n */\nexport function arrayWith(...elements: any[]): PropertyMatcher {\n  if (elements.length === 0) { return anything(); }\n\n  const anno = { $arrayContaining: elements.length === 1 ? elements[0] : elements };\n  return annotateMatcher(anno, (value: any, inspection: InspectionFailure): boolean => {\n    if (!Array.isArray(value)) {\n      return failMatcher(inspection, `Expect an array but got '${typeof value}'`);\n    }\n\n    for (const element of elements) {\n      const failure = longestFailure(value, element);\n      if (failure) {\n        return failMatcher(inspection, `Array did not contain expected element, closest match at index ${failure[0]}: ${failure[1]}`);\n      }\n    }\n\n    return true;\n\n    /**\n     * Return 'null' if the matcher matches anywhere in the array, otherwise the longest error and its index\n     */\n    function longestFailure(array: any[], matcher: any): [number, string] | null {\n      let fail: [number, string] | null = null;\n      for (let i = 0; i < array.length; i++) {\n        const innerInspection = { ...inspection, failureReason: '' };\n        if (match(array[i], matcher, innerInspection)) {\n          return null;\n        }\n\n        if (fail === null || innerInspection.failureReason.length > fail[1].length) {\n          fail = [i, innerInspection.failureReason];\n        }\n      }\n      return fail;\n    }\n  });\n}\n\n/**\n * Whether a value is an object\n */\nfunction isObject(x: any): x is object {\n  // Because `typeof null === 'object'`.\n  return x && typeof x === 'object';\n}\n\n/**\n * Helper function to make matcher failure reporting a little easier\n *\n * Our protocol is weird (change a string on a passed-in object and return 'false'),\n * but I don't want to change that right now.\n */\nexport function failMatcher(inspection: InspectionFailure, error: string): boolean {\n  inspection.failureReason = error;\n  return false;\n}\n\n/**\n * Match a given literal value against a matcher\n *\n * If the matcher is a callable, use that to evaluate the value. Otherwise, the values\n * must be literally the same.\n */\nexport function match(value: any, matcher: any, inspection: InspectionFailure) {\n  if (isCallable(matcher)) {\n    // Custom matcher (this mostly looks very weird because our `InspectionFailure` signature is weird)\n    const innerInspection: InspectionFailure = { ...inspection, failureReason: '' };\n    const result = matcher(value, innerInspection);\n    if (typeof result !== 'boolean') {\n      return failMatcher(inspection, `Predicate returned non-boolean return value: ${result}`);\n    }\n    if (!result && !innerInspection.failureReason) {\n      // Custom matcher neglected to return an error\n      return failMatcher(inspection, 'Predicate returned false');\n    }\n    // Propagate inner error in case of failure\n    if (!result) { inspection.failureReason = innerInspection.failureReason; }\n    return result;\n  }\n\n  return matchLiteral(value, matcher, inspection);\n}\n\n/**\n * Match a literal value at the top level.\n *\n * When recursing into arrays or objects, the nested values can be either matchers\n * or literals.\n */\nfunction matchLiteral(value: any, pattern: any, inspection: InspectionFailure) {\n  if (pattern == null) { return true; }\n\n  const errors = new Array<string>();\n\n  if (Array.isArray(value) !== Array.isArray(pattern)) {\n    return failMatcher(inspection, 'Array type mismatch');\n  }\n  if (Array.isArray(value)) {\n    if (pattern.length !== value.length) {\n      return failMatcher(inspection, 'Array length mismatch');\n    }\n\n    // Recurse comparison for individual objects\n    for (let i = 0; i < pattern.length; i++) {\n      if (!match(value[i], pattern[i], { ...inspection })) {\n        errors.push(`Array element ${i} mismatch`);\n      }\n    }\n\n    if (errors.length > 0) {\n      return failMatcher(inspection, errors.join(', '));\n    }\n    return true;\n  }\n  if ((typeof value === 'object') !== (typeof pattern === 'object')) {\n    return failMatcher(inspection, 'Object type mismatch');\n  }\n  if (typeof pattern === 'object') {\n    // Check that all fields in the pattern have the right value\n    const innerInspection = { ...inspection, failureReason: '' };\n    const matcher = objectLike(pattern)(value, innerInspection);\n    if (!matcher) {\n      inspection.failureReason = innerInspection.failureReason;\n      return false;\n    }\n\n    // Check no fields uncovered\n    const realFields = new Set(Object.keys(value));\n    for (const key of Object.keys(pattern)) { realFields.delete(key); }\n    if (realFields.size > 0) {\n      return failMatcher(inspection, `Unexpected keys present in object: ${Array.from(realFields).join(', ')}`);\n    }\n    return true;\n  }\n\n  if (value !== pattern) {\n    return failMatcher(inspection, 'Different values');\n  }\n\n  return true;\n}\n\n/**\n * Whether a value is a callable\n */\nfunction isCallable(x: any): x is ((...args: any[]) => any) {\n  return x && {}.toString.call(x) === '[object Function]';\n}\n\n/**\n * Do a glob-like pattern match (which only supports *s). Supports multiline strings.\n */\nexport function stringLike(pattern: string): PropertyMatcher {\n  // Replace * with .* in the string, escape the rest and brace with ^...$\n  const regex = new RegExp(`^${pattern.split('*').map(escapeRegex).join('.*')}$`, 'm');\n\n  return annotateMatcher({ $stringContaining: pattern }, (value: any, failure: InspectionFailure) => {\n    if (typeof value !== 'string') {\n      failure.failureReason = `Expected a string, but got '${typeof value}'`;\n      return false;\n    }\n\n    if (!regex.test(value)) {\n      failure.failureReason = 'String did not match pattern';\n      return false;\n    }\n\n    return true;\n  });\n}\n\n/**\n * Matches any value\n */\nexport function anything(): PropertyMatcher {\n  return annotateMatcher({ $anything: true }, () => true);\n}\n\n/**\n * Negate an inner matcher\n */\nexport function notMatching(matcher: any): PropertyMatcher {\n  return annotateMatcher({ $notMatching: matcher }, (value: any, failure: InspectionFailure) => {\n    const result = matcherFrom(matcher)(value, failure);\n    if (result) {\n      failure.failureReason = 'Should not have matched, but did';\n      return false;\n    }\n    return true;\n  });\n}\n\nexport type TypeValidator<T> = (x: any) => x is T;\n\n/**\n * Captures a value onto an object if it matches a given inner matcher\n *\n * @example\n *\n * const someValue = Capture.aString();\n * expect(stack).toHaveResource({\n *    // ...\n *    Value: someValue.capture(stringMatching('*a*')),\n * });\n * console.log(someValue.capturedValue);\n */\nexport class Capture<T=any> {\n  /**\n   * A Capture object that captures any type\n   */\n  public static anyType(): Capture<any> {\n    return new Capture();\n  }\n\n  /**\n   * A Capture object that captures a string type\n   */\n  public static aString(): Capture<string> {\n    return new Capture((x: any): x is string => {\n      if (typeof x !== 'string') {\n        throw new Error(`Expected to capture a string, got '${x}'`);\n      }\n      return true;\n    });\n  }\n\n  /**\n   * A Capture object that captures a custom type\n   */\n  // eslint-disable-next-line @typescript-eslint/no-shadow\n  public static a<T>(validator: TypeValidator<T>): Capture<T> {\n    return new Capture(validator);\n  }\n\n  private _value?: T;\n  private _didCapture = false;\n  private _wasInvoked = false;\n\n  protected constructor(private readonly typeValidator?: TypeValidator<T>) {\n  }\n\n  /**\n   * Capture the value if the inner matcher successfully matches it\n   *\n   * If no matcher is given, `anything()` is assumed.\n   *\n   * And exception will be thrown if the inner matcher returns `true` and\n   * the value turns out to be of a different type than the `Capture` object\n   * is expecting.\n   */\n  public capture(matcher?: any): PropertyMatcher {\n    if (matcher === undefined) {\n      matcher = anything();\n    }\n\n    return annotateMatcher({ $capture: matcher }, (value: any, failure: InspectionFailure) => {\n      this._wasInvoked = true;\n      const result = matcherFrom(matcher)(value, failure);\n      if (result) {\n        if (this.typeValidator && !this.typeValidator(value)) {\n          throw new Error(`Value not of the expected type: ${value}`);\n        }\n        this._didCapture = true;\n        this._value = value;\n      }\n      return result;\n    });\n  }\n\n  /**\n   * Whether a value was successfully captured\n   */\n  public get didCapture() {\n    return this._didCapture;\n  }\n\n  /**\n   * Return the value that was captured\n   *\n   * Throws an exception if now value was captured\n   */\n  public get capturedValue(): T {\n    // When this module is ported to jsii, the type parameter will obviously\n    // have to be dropped and this will have to turn into an `any`.\n    if (!this.didCapture) {\n      throw new Error(`Did not capture a value: ${this._wasInvoked ? 'inner matcher failed' : 'never invoked'}`);\n    }\n    return this._value!;\n  }\n}\n\n/**\n * Match on the innards of a JSON string, instead of the complete string\n */\nexport function encodedJson(matcher: any): PropertyMatcher {\n  return annotateMatcher({ $encodedJson: matcher }, (value: any, failure: InspectionFailure) => {\n    if (typeof value !== 'string') {\n      failure.failureReason = `Expected a string, but got '${typeof value}'`;\n      return false;\n    }\n\n    let decoded;\n    try {\n      decoded = JSON.parse(value);\n    } catch (e) {\n      failure.failureReason = `String is not JSON: ${e}`;\n      return false;\n    }\n\n    return matcherFrom(matcher)(decoded, failure);\n  });\n}\n\nfunction escapeRegex(s: string) {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&'); // $& means the whole matched string\n}\n\n/**\n * Make a matcher out of the given argument if it's not a matcher already\n *\n * If it's not a matcher, it will be treated as a literal.\n */\nexport function matcherFrom(matcher: any): PropertyMatcher {\n  return isCallable(matcher) ? matcher : exactValue(matcher);\n}\n\n/**\n * Annotate a matcher with toJSON\n *\n * We will JSON.stringify() values if we have a match failure, but for matchers this\n * would show (in traditional JS fashion) something like '[function Function]', or more\n * accurately nothing at all since functions cannot be JSONified.\n *\n * We override to JSON() in order to produce a readadable version of the matcher.\n */\nexport function annotateMatcher<A extends object>(how: A, matcher: PropertyMatcher): PropertyMatcher {\n  (matcher as any).toJSON = () => how;\n  return matcher;\n}\n"]}