@graphql-inspector/core 4.0.2 → 4.0.3

package/esm/diff/rules/ignore-description-changes.js

@@ -0,0 +1,17 @@
+import { ChangeType } from '../changes/change.js';
+const descriptionChangeTypes = [
+    ChangeType.FieldArgumentDescriptionChanged,
+    ChangeType.DirectiveDescriptionChanged,
+    ChangeType.DirectiveArgumentDescriptionChanged,
+    ChangeType.EnumValueDescriptionChanged,
+    ChangeType.FieldDescriptionChanged,
+    ChangeType.FieldDescriptionAdded,
+    ChangeType.FieldDescriptionRemoved,
+    ChangeType.InputFieldDescriptionAdded,
+    ChangeType.InputFieldDescriptionRemoved,
+    ChangeType.InputFieldDescriptionChanged,
+    ChangeType.TypeDescriptionChanged,
+];
+export const ignoreDescriptionChanges = ({ changes }) => {
+    return changes.filter(change => !descriptionChangeTypes.includes(change.type));
+};

package/esm/diff/rules/index.js

@@ -0,0 +1,5 @@
+export * from './consider-usage.js';
+export * from './dangerous-breaking.js';
+export * from './ignore-description-changes.js';
+export * from './safe-unreachable.js';
+export * from './suppress-removal-of-deprecated-field.js';

package/esm/diff/rules/safe-unreachable.js

@@ -0,0 +1,15 @@
+import { getReachableTypes } from '../../utils/graphql.js';
+import { parsePath } from '../../utils/path.js';
+import { CriticalityLevel } from './../changes/change.js';
+export const safeUnreachable = ({ changes, oldSchema }) => {
+    const reachable = getReachableTypes(oldSchema);
+    return changes.map(change => {
+        if (change.criticality.level === CriticalityLevel.Breaking && change.path) {
+            const [typeName] = parsePath(change.path);
+            if (!reachable.has(typeName)) {
+                return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: CriticalityLevel.NonBreaking }), message: 'Unreachable from root' });
+            }
+        }
+        return change;
+    });
+};

package/esm/diff/rules/suppress-removal-of-deprecated-field.js

@@ -0,0 +1,54 @@
+import { isEnumType, isInputObjectType, isInterfaceType, isObjectType } from 'graphql';
+import { isDeprecated } from '../../utils/is-deprecated.js';
+import { parsePath } from '../../utils/path.js';
+import { ChangeType, CriticalityLevel } from './../changes/change.js';
+export const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, newSchema }) => {
+    return changes.map(change => {
+        if (change.type === ChangeType.FieldRemoved &&
+            change.criticality.level === CriticalityLevel.Breaking &&
+            change.path) {
+            const [typeName, fieldName] = parsePath(change.path);
+            const type = oldSchema.getType(typeName);
+            if (isObjectType(type) || isInterfaceType(type)) {
+                const field = type.getFields()[fieldName];
+                if (isDeprecated(field)) {
+                    return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: CriticalityLevel.Dangerous }) });
+                }
+            }
+        }
+        if (change.type === ChangeType.EnumValueRemoved &&
+            change.criticality.level === CriticalityLevel.Breaking &&
+            change.path) {
+            const [enumName, enumItem] = parsePath(change.path);
+            const type = oldSchema.getType(enumName);
+            if (isEnumType(type)) {
+                const item = type.getValue(enumItem);
+                if (item && isDeprecated(item)) {
+                    return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: CriticalityLevel.Dangerous }) });
+                }
+            }
+        }
+        if (change.type === ChangeType.InputFieldRemoved &&
+            change.criticality.level === CriticalityLevel.Breaking &&
+            change.path) {
+            const [inputName, inputItem] = parsePath(change.path);
+            const type = oldSchema.getType(inputName);
+            if (isInputObjectType(type)) {
+                const item = type.getFields()[inputItem];
+                if (item && isDeprecated(item)) {
+                    return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: CriticalityLevel.Dangerous }) });
+                }
+            }
+        }
+        if (change.type === ChangeType.TypeRemoved &&
+            change.criticality.level === CriticalityLevel.Breaking &&
+            change.path) {
+            const [typeName] = parsePath(change.path);
+            const type = newSchema.getType(typeName);
+            if (!type) {
+                return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: CriticalityLevel.Dangerous }) });
+            }
+        }
+        return change;
+    });
+};

package/esm/diff/schema.js

@@ -0,0 +1,103 @@
+import { isEnumType, isInputObjectType, isInterfaceType, isObjectType, isScalarType, isUnionType, } from 'graphql';
+import { compareLists, isNotEqual, isVoid } from '../utils/compare.js';
+import { isPrimitive } from '../utils/graphql.js';
+import { directiveAdded, directiveRemoved } from './changes/directive.js';
+import { schemaMutationTypeChanged, schemaQueryTypeChanged, schemaSubscriptionTypeChanged, } from './changes/schema.js';
+import { typeAdded, typeDescriptionAdded, typeDescriptionChanged, typeDescriptionRemoved, typeKindChanged, typeRemoved, } from './changes/type.js';
+import { changesInDirective } from './directive.js';
+import { changesInEnum } from './enum.js';
+import { changesInInputObject } from './input.js';
+import { changesInInterface } from './interface.js';
+import { changesInObject } from './object.js';
+import { changesInUnion } from './union.js';
+export function diffSchema(oldSchema, newSchema) {
+    const changes = [];
+    function addChange(change) {
+        changes.push(change);
+    }
+    changesInSchema(oldSchema, newSchema, addChange);
+    compareLists(Object.values(oldSchema.getTypeMap()).filter(t => !isPrimitive(t)), Object.values(newSchema.getTypeMap()).filter(t => !isPrimitive(t)), {
+        onAdded(type) {
+            addChange(typeAdded(type));
+        },
+        onRemoved(type) {
+            addChange(typeRemoved(type));
+        },
+        onMutual(type) {
+            changesInType(type.oldVersion, type.newVersion, addChange);
+        },
+    });
+    compareLists(oldSchema.getDirectives(), newSchema.getDirectives(), {
+        onAdded(directive) {
+            addChange(directiveAdded(directive));
+        },
+        onRemoved(directive) {
+            addChange(directiveRemoved(directive));
+        },
+        onMutual(directive) {
+            changesInDirective(directive.oldVersion, directive.newVersion, addChange);
+        },
+    });
+    return changes;
+}
+function changesInSchema(oldSchema, newSchema, addChange) {
+    var _a, _b, _c, _d, _e, _f;
+    const defaultNames = {
+        query: 'Query',
+        mutation: 'Mutation',
+        subscription: 'Subscription',
+    };
+    const oldRoot = {
+        query: (_a = (oldSchema.getQueryType() || {}).name) !== null && _a !== void 0 ? _a : defaultNames.query,
+        mutation: (_b = (oldSchema.getMutationType() || {}).name) !== null && _b !== void 0 ? _b : defaultNames.mutation,
+        subscription: (_c = (oldSchema.getSubscriptionType() || {}).name) !== null && _c !== void 0 ? _c : defaultNames.subscription,
+    };
+    const newRoot = {
+        query: (_d = (newSchema.getQueryType() || {}).name) !== null && _d !== void 0 ? _d : defaultNames.query,
+        mutation: (_e = (newSchema.getMutationType() || {}).name) !== null && _e !== void 0 ? _e : defaultNames.mutation,
+        subscription: (_f = (newSchema.getSubscriptionType() || {}).name) !== null && _f !== void 0 ? _f : defaultNames.subscription,
+    };
+    if (isNotEqual(oldRoot.query, newRoot.query)) {
+        addChange(schemaQueryTypeChanged(oldSchema, newSchema));
+    }
+    if (isNotEqual(oldRoot.mutation, newRoot.mutation)) {
+        addChange(schemaMutationTypeChanged(oldSchema, newSchema));
+    }
+    if (isNotEqual(oldRoot.subscription, newRoot.subscription)) {
+        addChange(schemaSubscriptionTypeChanged(oldSchema, newSchema));
+    }
+}
+function changesInType(oldType, newType, addChange) {
+    if (isEnumType(oldType) && isEnumType(newType)) {
+        changesInEnum(oldType, newType, addChange);
+    }
+    else if (isUnionType(oldType) && isUnionType(newType)) {
+        changesInUnion(oldType, newType, addChange);
+    }
+    else if (isInputObjectType(oldType) && isInputObjectType(newType)) {
+        changesInInputObject(oldType, newType, addChange);
+    }
+    else if (isObjectType(oldType) && isObjectType(newType)) {
+        changesInObject(oldType, newType, addChange);
+    }
+    else if (isInterfaceType(oldType) && isInterfaceType(newType)) {
+        changesInInterface(oldType, newType, addChange);
+    }
+    else if (isScalarType(oldType) && isScalarType(newType)) {
+        // what to do with scalar types?
+    }
+    else {
+        addChange(typeKindChanged(oldType, newType));
+    }
+    if (isNotEqual(oldType.description, newType.description)) {
+        if (isVoid(oldType.description)) {
+            addChange(typeDescriptionAdded(newType));
+        }
+        else if (isVoid(newType.description)) {
+            addChange(typeDescriptionRemoved(oldType));
+        }
+        else {
+            addChange(typeDescriptionChanged(oldType, newType));
+        }
+    }
+}

package/esm/diff/union.js

@@ -0,0 +1,14 @@
+import { compareLists } from '../utils/compare.js';
+import { unionMemberAdded, unionMemberRemoved } from './changes/union.js';
+export function changesInUnion(oldUnion, newUnion, addChange) {
+    const oldTypes = oldUnion.getTypes();
+    const newTypes = newUnion.getTypes();
+    compareLists(oldTypes, newTypes, {
+        onAdded(t) {
+            addChange(unionMemberAdded(newUnion, t));
+        },
+        onRemoved(t) {
+            addChange(unionMemberRemoved(oldUnion, t));
+        },
+    });
+}

package/esm/index.js

@@ -0,0 +1,11 @@
+export * from './coverage/index.js';
+export { diff, DiffRule, } from './diff/index.js';
+export { ChangeType, CriticalityLevel } from './diff/changes/change.js';
+export { similar } from './similar/index.js';
+export { getTypePrefix } from './utils/graphql.js';
+export { validate } from './validate/index.js';
+export { countAliases } from './validate/alias-count.js';
+export { calculateOperationComplexity, } from './validate/complexity.js';
+export { countDirectives } from './validate/directive-count.js';
+export { countDepth } from './validate/query-depth.js';
+export { calculateTokenCount } from './validate/token-count.js';

package/esm/similar/index.js

@@ -0,0 +1,53 @@
+import { printType } from 'graphql';
+import { isForIntrospection, isPrimitive } from '../utils/graphql.js';
+import { findBestMatch } from '../utils/string.js';
+export function similar(schema, typeName, threshold = 0.4) {
+    const typeMap = schema.getTypeMap();
+    const targets = Object.keys(schema.getTypeMap())
+        .filter(name => !isPrimitive(name) && !isForIntrospection(name))
+        .map(name => ({
+        typeId: name,
+        value: stripType(typeMap[name]),
+    }));
+    const results = {};
+    if (typeof typeName !== 'undefined' && !targets.some(t => t.typeId === typeName)) {
+        throw new Error(`Type '${typeName}' doesn't exist`);
+    }
+    (typeName ? [{ typeId: typeName, value: '' }] : targets).forEach(source => {
+        const sourceType = schema.getType(source.typeId);
+        const matchWith = targets.filter(target => schema.getType(target.typeId).astNode.kind === sourceType.astNode.kind &&
+            target.typeId !== source.typeId);
+        if (matchWith.length > 0) {
+            const found = similarTo(sourceType, matchWith, threshold);
+            if (found) {
+                results[source.typeId] = found;
+            }
+        }
+    });
+    return results;
+}
+function similarTo(type, targets, threshold) {
+    const types = targets.filter(target => target.typeId !== type.name);
+    const result = findBestMatch(stripType(type), types);
+    if (result.bestMatch.rating < threshold) {
+        return;
+    }
+    return {
+        bestMatch: result.bestMatch,
+        ratings: result.ratings
+            .filter(r => r.rating >= threshold && r.target !== result.bestMatch.target)
+            .sort((a, b) => a.rating - b.rating)
+            .reverse(),
+    };
+}
+function stripType(type) {
+    return printType(type)
+        .trim()
+        .replace(/^[a-z]+ [^{]+\{/g, '')
+        .replace(/\}$/g, '')
+        .trim()
+        .split('\n')
+        .map(s => s.trim())
+        .sort((a, b) => a.localeCompare(b))
+        .join(' ');
+}

package/esm/utils/apollo.js

@@ -0,0 +1,16 @@
+import { extendSchema, parse, visit } from 'graphql';
+import { removeDirectives, removeFieldIfDirectives } from './graphql.js';
+export function transformDocumentWithApollo(doc, { keepClientFields }) {
+    return visit(doc, {
+        Field(node) {
+            return keepClientFields
+                ? removeDirectives(node, ['client'])
+                : removeFieldIfDirectives(node, ['client']);
+        },
+    });
+}
+export function transformSchemaWithApollo(schema) {
+    return extendSchema(schema, parse(/* GraphQL */ `
+      directive @connection(key: String!, filter: [String]) on FIELD
+    `));
+}

package/esm/utils/compare.js

@@ -0,0 +1,82 @@
+export function keyMap(list, keyFn) {
+    return list.reduce((map, item) => {
+        map[keyFn(item)] = item;
+        return map;
+    }, Object.create(null));
+}
+export function isEqual(a, b) {
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        for (let index = 0; index < a.length; index++) {
+            if (!isEqual(a[index], b[index])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (a && b && typeof a === 'object' && typeof b === 'object') {
+        const aRecord = a;
+        const bRecord = b;
+        const aKeys = Object.keys(aRecord);
+        const bKeys = Object.keys(bRecord);
+        if (aKeys.length !== bKeys.length)
+            return false;
+        for (const key of aKeys) {
+            if (!isEqual(aRecord[key], bRecord[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return a === b || (!a && !b);
+}
+export function isNotEqual(a, b) {
+    return !isEqual(a, b);
+}
+export function isVoid(a) {
+    return typeof a === 'undefined' || a === null;
+}
+export function diffArrays(a, b) {
+    return a.filter(c => !b.some(d => isEqual(d, c)));
+}
+export function compareLists(oldList, newList, callbacks) {
+    const oldMap = keyMap(oldList, ({ name }) => name);
+    const newMap = keyMap(newList, ({ name }) => name);
+    const added = [];
+    const removed = [];
+    const mutual = [];
+    for (const oldItem of oldList) {
+        const newItem = newMap[oldItem.name];
+        if (newItem === undefined) {
+            removed.push(oldItem);
+        }
+        else {
+            mutual.push({
+                newVersion: newItem,
+                oldVersion: oldItem,
+            });
+        }
+    }
+    for (const newItem of newList) {
+        if (oldMap[newItem.name] === undefined) {
+            added.push(newItem);
+        }
+    }
+    if (callbacks) {
+        if (callbacks.onAdded) {
+            added.forEach(callbacks.onAdded);
+        }
+        if (callbacks.onRemoved) {
+            removed.forEach(callbacks.onRemoved);
+        }
+        if (callbacks.onMutual) {
+            mutual.forEach(callbacks.onMutual);
+        }
+    }
+    return {
+        added,
+        removed,
+        mutual,
+    };
+}

package/esm/utils/graphql.js

@@ -0,0 +1,181 @@
+import { getNamedType, GraphQLError, isInputObjectType, isInterfaceType, isListType, isNonNullType, isObjectType, isScalarType, isUnionType, isWrappingType, Kind, TypeInfo, visit, visitWithTypeInfo, } from 'graphql';
+import { isDeprecated } from './is-deprecated.js';
+export function safeChangeForField(oldType, newType) {
+    if (!isWrappingType(oldType) && !isWrappingType(newType)) {
+        return oldType.toString() === newType.toString();
+    }
+    if (isNonNullType(newType)) {
+        const ofType = isNonNullType(oldType) ? oldType.ofType : oldType;
+        return safeChangeForField(ofType, newType.ofType);
+    }
+    if (isListType(oldType)) {
+        return ((isListType(newType) && safeChangeForField(oldType.ofType, newType.ofType)) ||
+            (isNonNullType(newType) && safeChangeForField(oldType, newType.ofType)));
+    }
+    return false;
+}
+export function safeChangeForInputValue(oldType, newType) {
+    if (!isWrappingType(oldType) && !isWrappingType(newType)) {
+        return oldType.toString() === newType.toString();
+    }
+    if (isListType(oldType) && isListType(newType)) {
+        return safeChangeForInputValue(oldType.ofType, newType.ofType);
+    }
+    if (isNonNullType(oldType)) {
+        const ofType = isNonNullType(newType) ? newType.ofType : newType;
+        return safeChangeForInputValue(oldType.ofType, ofType);
+    }
+    return false;
+}
+export function getKind(type) {
+    const node = type.astNode;
+    return (node === null || node === void 0 ? void 0 : node.kind) || '';
+}
+export function getTypePrefix(type) {
+    const kind = getKind(type);
+    const kindsMap = {
+        [Kind.SCALAR_TYPE_DEFINITION]: 'scalar',
+        [Kind.OBJECT_TYPE_DEFINITION]: 'type',
+        [Kind.INTERFACE_TYPE_DEFINITION]: 'interface',
+        [Kind.UNION_TYPE_DEFINITION]: 'union',
+        [Kind.ENUM_TYPE_DEFINITION]: 'enum',
+        [Kind.INPUT_OBJECT_TYPE_DEFINITION]: 'input',
+    };
+    return kindsMap[kind.toString()];
+}
+export function isPrimitive(type) {
+    return ['String', 'Int', 'Float', 'Boolean', 'ID'].includes(typeof type === 'string' ? type : type.name);
+}
+export function isForIntrospection(type) {
+    return [
+        '__Schema',
+        '__Type',
+        '__TypeKind',
+        '__Field',
+        '__InputValue',
+        '__EnumValue',
+        '__Directive',
+        '__DirectiveLocation',
+    ].includes(typeof type === 'string' ? type : type.name);
+}
+export function findDeprecatedUsages(schema, ast) {
+    const errors = [];
+    const typeInfo = new TypeInfo(schema);
+    visit(ast, visitWithTypeInfo(typeInfo, {
+        Argument(node) {
+            const argument = typeInfo.getArgument();
+            if (argument) {
+                const reason = argument.deprecationReason;
+                if (reason) {
+                    const fieldDef = typeInfo.getFieldDef();
+                    if (fieldDef) {
+                        errors.push(new GraphQLError(`The argument '${argument === null || argument === void 0 ? void 0 : argument.name}' of '${fieldDef.name}' is deprecated. ${reason}`, [node]));
+                    }
+                }
+            }
+        },
+        Field(node) {
+            const fieldDef = typeInfo.getFieldDef();
+            if (fieldDef && isDeprecated(fieldDef)) {
+                const parentType = typeInfo.getParentType();
+                if (parentType) {
+                    const reason = fieldDef.deprecationReason;
+                    errors.push(new GraphQLError(`The field '${parentType.name}.${fieldDef.name}' is deprecated.${reason ? ' ' + reason : ''}`, [node]));
+                }
+            }
+        },
+        EnumValue(node) {
+            const enumVal = typeInfo.getEnumValue();
+            if (enumVal && isDeprecated(enumVal)) {
+                const type = getNamedType(typeInfo.getInputType());
+                if (type) {
+                    const reason = enumVal.deprecationReason;
+                    errors.push(new GraphQLError(`The enum value '${type.name}.${enumVal.name}' is deprecated.${reason ? ' ' + reason : ''}`, [node]));
+                }
+            }
+        },
+    }));
+    return errors;
+}
+export function removeFieldIfDirectives(node, directiveNames) {
+    var _a;
+    if ((_a = node.directives) === null || _a === void 0 ? void 0 : _a.some(d => directiveNames.includes(d.name.value))) {
+        return null;
+    }
+    return node;
+}
+export function removeDirectives(node, directiveNames) {
+    if (node.directives) {
+        return Object.assign(Object.assign({}, node), { directives: node.directives.filter(d => !directiveNames.includes(d.name.value)) });
+    }
+    return node;
+}
+export function getReachableTypes(schema) {
+    const reachableTypes = new Set();
+    const collect = (type) => {
+        const typeName = type.name;
+        if (reachableTypes.has(typeName)) {
+            return;
+        }
+        reachableTypes.add(typeName);
+        if (isScalarType(type)) {
+            return;
+        }
+        if (isInterfaceType(type) || isObjectType(type)) {
+            if (isInterfaceType(type)) {
+                const { objects, interfaces } = schema.getImplementations(type);
+                for (const child of objects) {
+                    collect(child);
+                }
+                for (const child of interfaces) {
+                    collect(child);
+                }
+            }
+            const fields = type.getFields();
+            for (const fieldName in fields) {
+                const field = fields[fieldName];
+                collect(resolveOutputType(field.type));
+                const args = field.args;
+                for (const argName in args) {
+                    const arg = args[argName];
+                    collect(resolveInputType(arg.type));
+                }
+            }
+        }
+        else if (isUnionType(type)) {
+            const types = type.getTypes();
+            for (const child of types) {
+                collect(child);
+            }
+        }
+        else if (isInputObjectType(type)) {
+            const fields = type.getFields();
+            for (const fieldName in fields) {
+                const field = fields[fieldName];
+                collect(resolveInputType(field.type));
+            }
+        }
+    };
+    for (const type of [
+        schema.getQueryType(),
+        schema.getMutationType(),
+        schema.getSubscriptionType(),
+    ]) {
+        if (type) {
+            collect(type);
+        }
+    }
+    return reachableTypes;
+}
+function resolveOutputType(output) {
+    if (isListType(output) || isNonNullType(output)) {
+        return resolveOutputType(output.ofType);
+    }
+    return output;
+}
+function resolveInputType(input) {
+    if (isListType(input) || isNonNullType(input)) {
+        return resolveInputType(input.ofType);
+    }
+    return input;
+}

package/esm/utils/is-deprecated.js

@@ -0,0 +1,13 @@
+export function isDeprecated(fieldOrEnumValue) {
+    var _a, _b;
+    if ('isDeprecated' in fieldOrEnumValue) {
+        return fieldOrEnumValue['isDeprecated'];
+    }
+    if (fieldOrEnumValue.deprecationReason != null) {
+        return true;
+    }
+    if ((_b = (_a = fieldOrEnumValue.astNode) === null || _a === void 0 ? void 0 : _a.directives) === null || _b === void 0 ? void 0 : _b.some(directive => directive.name.value === 'deprecated')) {
+        return true;
+    }
+    return false;
+}

package/esm/utils/path.js

@@ -0,0 +1,3 @@
+export function parsePath(path) {
+    return path.split('.');
+}

package/esm/utils/string.js

@@ -0,0 +1,64 @@
+import inspect from 'object-inspect';
+function compareTwoStrings(str1, str2) {
+    if (!str1.length && !str2.length)
+        return 1;
+    if (!str1.length || !str2.length)
+        return 0;
+    if (str1.toUpperCase() === str2.toUpperCase())
+        return 1;
+    if (str1.length === 1 && str2.length === 1)
+        return 0;
+    const pairs1 = wordLetterPairs(str1);
+    const pairs2 = wordLetterPairs(str2);
+    const union = pairs1.length + pairs2.length;
+    let intersection = 0;
+    pairs1.forEach(pair1 => {
+        for (let i = 0, pair2; (pair2 = pairs2[i]); i++) {
+            if (pair1 !== pair2)
+                continue;
+            intersection++;
+            pairs2.splice(i, 1);
+            break;
+        }
+    });
+    return (intersection * 2) / union;
+}
+export function findBestMatch(mainString, targetStrings) {
+    if (!areArgsValid(mainString, targetStrings))
+        throw new Error('Bad arguments: First argument should be a string, second should be an array of strings');
+    const ratings = targetStrings.map(target => ({
+        target,
+        rating: compareTwoStrings(mainString, target.value),
+    }));
+    const bestMatch = Array.from(ratings).sort((a, b) => b.rating - a.rating)[0];
+    return { ratings, bestMatch };
+}
+function flattenDeep(arr) {
+    return Array.isArray(arr) ? arr.reduce((a, b) => a.concat(flattenDeep(b)), []) : [arr];
+}
+function areArgsValid(mainString, targetStrings) {
+    if (typeof mainString !== 'string')
+        return false;
+    if (!Array.isArray(targetStrings))
+        return false;
+    if (!targetStrings.length)
+        return false;
+    if (targetStrings.find(s => typeof s.value !== 'string'))
+        return false;
+    return true;
+}
+function letterPairs(str) {
+    const pairs = [];
+    for (let i = 0, max = str.length - 1; i < max; i++)
+        pairs[i] = str.substring(i, i + 2);
+    return pairs;
+}
+function wordLetterPairs(str) {
+    const pairs = str.toUpperCase().split(' ').map(letterPairs);
+    return flattenDeep(pairs);
+}
+export function safeString(obj) {
+    return inspect(obj)
+        .replace(/\[Object: null prototype\] /g, '')
+        .replace(/(^')|('$)/g, '');
+}