proskomma-core 0.10.10 → 0.10.12

package/dist/index.js

@@ -1237,10 +1237,7 @@ function getAugmentedNamespace(n) {
   if (typeof f == "function") {
     var a = function a2() {
       if (this instanceof a2) {
-        var args = [null];
-        args.push.apply(args, arguments);
-        var Ctor = Function.bind.apply(f, args);
-        return new Ctor();
+        return Reflect.construct(f, arguments, this.constructor);
       }
       return f.apply(this, arguments);
     };
@@ -1477,6 +1474,7 @@ var categories = [
     "bmp": "    -   　"
   }
 ];
+const categories$1 = /* @__PURE__ */ getDefaultExportFromCjs(categories);
 /*!
  * XRegExp Unicode Categories 5.1.1
  * <xregexp.com>
@@ -1487,7 +1485,7 @@ const unicodeCategories = (XRegExp2) => {
   if (!XRegExp2.addUnicodeData) {
     throw new ReferenceError("Unicode Base must be loaded before Unicode Categories");
   }
-  XRegExp2.addUnicodeData(categories);
+  XRegExp2.addUnicodeData(categories$1);
 };
 var properties$o = [
   {
@@ -1530,6 +1528,7 @@ var properties$o = [
     "bmp": "	-\r …   - \u2028\u2029  　"
   }
 ];
+const properties$p = /* @__PURE__ */ getDefaultExportFromCjs(properties$o);
 /*!
  * XRegExp Unicode Properties 5.1.1
  * <xregexp.com>
@@ -1540,7 +1539,7 @@ const unicodeProperties = (XRegExp2) => {
   if (!XRegExp2.addUnicodeData) {
     throw new ReferenceError("Unicode Base must be loaded before Unicode Properties");
   }
-  const unicodeData = properties$o;
+  const unicodeData = properties$p;
   unicodeData.push({
     name: "Assigned",
     // Since this is defined as the inverse of Unicode category Cn (Unassigned), the Unicode
@@ -2211,6 +2210,7 @@ var scripts$1 = [
     "astral": "\uD806[\uDE00-\uDE47]"
   }
 ];
+const scripts$2 = /* @__PURE__ */ getDefaultExportFromCjs(scripts$1);
 /*!
  * XRegExp Unicode Scripts 5.1.1
  * <xregexp.com>
@@ -2221,7 +2221,7 @@ const unicodeScripts = (XRegExp2) => {
   if (!XRegExp2.addUnicodeData) {
     throw new ReferenceError("Unicode Base must be loaded before Unicode Scripts");
   }
-  XRegExp2.addUnicodeData(scripts$1, "Script");
+  XRegExp2.addUnicodeData(scripts$2, "Script");
 };
 build(XRegExp);
 matchRecursive(XRegExp);
@@ -3380,8 +3380,7 @@ function getObjectTag$1(object) {
 const instanceOf = (
   /* c8 ignore next 6 */
   // FIXME: https://github.com/graphql/graphql-js/issues/2317
-  // eslint-disable-next-line no-undef
-  process.env.NODE_ENV === "production" ? function instanceOf2(value, constructor) {
+  globalThis.process && globalThis.process.env.NODE_ENV === "production" ? function instanceOf2(value, constructor) {
     return value instanceof constructor;
   } : function instanceOf3(value, constructor) {
     if (value instanceof constructor) {
@@ -8852,7 +8851,7 @@ function findConflict(context, cachedFieldsAndFragmentNames, comparedFragmentPai
         [node2]
       ];
     }
-    if (stringifyArguments(node1) !== stringifyArguments(node2)) {
+    if (!sameArguments(node1, node2)) {
       return [
         [responseName, "they have differing arguments"],
         [node1],
@@ -8890,21 +8889,30 @@ function findConflict(context, cachedFieldsAndFragmentNames, comparedFragmentPai
     return subfieldConflicts(conflicts, responseName, node1, node2);
   }
 }
-function stringifyArguments(fieldNode) {
-  var _fieldNode$arguments;
-  const args = (
-    /* c8 ignore next */
-    (_fieldNode$arguments = fieldNode.arguments) !== null && _fieldNode$arguments !== void 0 ? _fieldNode$arguments : []
-  );
-  const inputObjectWithArgs = {
-    kind: Kind.OBJECT,
-    fields: args.map((argNode) => ({
-      kind: Kind.OBJECT_FIELD,
-      name: argNode.name,
-      value: argNode.value
-    }))
-  };
-  return print(sortValueNode(inputObjectWithArgs));
+function sameArguments(node1, node2) {
+  const args1 = node1.arguments;
+  const args2 = node2.arguments;
+  if (args1 === void 0 || args1.length === 0) {
+    return args2 === void 0 || args2.length === 0;
+  }
+  if (args2 === void 0 || args2.length === 0) {
+    return false;
+  }
+  if (args1.length !== args2.length) {
+    return false;
+  }
+  const values2 = new Map(args2.map(({ name: name2, value }) => [name2.value, value]));
+  return args1.every((arg1) => {
+    const value1 = arg1.value;
+    const value2 = values2.get(arg1.name.value);
+    if (value2 === void 0) {
+      return false;
+    }
+    return stringifyValue(value1) === stringifyValue(value2);
+  });
+}
+function stringifyValue(value) {
+  return print(sortValueNode(value));
 }
 function doTypesConflict(type1, type2) {
   if (isListType(type1)) {
@@ -9605,7 +9613,7 @@ function coerceVariableValues(schema, varDefNodes, inputs, onError) {
         onError(
           new GraphQLError(prefix + "; " + error2.message, {
             nodes: varDefNode,
-            originalError: error2.originalError
+            originalError: error2
           })
         );
       }
@@ -11011,21 +11019,30 @@ function executeFieldsSerially(exeContext, parentType, sourceValue, path, fields
 function executeFields(exeContext, parentType, sourceValue, path, fields) {
   const results = /* @__PURE__ */ Object.create(null);
   let containsPromise = false;
-  for (const [responseName, fieldNodes] of fields.entries()) {
-    const fieldPath = addPath(path, responseName, parentType.name);
-    const result = executeField(
-      exeContext,
-      parentType,
-      sourceValue,
-      fieldNodes,
-      fieldPath
-    );
-    if (result !== void 0) {
-      results[responseName] = result;
-      if (isPromise(result)) {
-        containsPromise = true;
+  try {
+    for (const [responseName, fieldNodes] of fields.entries()) {
+      const fieldPath = addPath(path, responseName, parentType.name);
+      const result = executeField(
+        exeContext,
+        parentType,
+        sourceValue,
+        fieldNodes,
+        fieldPath
+      );
+      if (result !== void 0) {
+        results[responseName] = result;
+        if (isPromise(result)) {
+          containsPromise = true;
+        }
       }
     }
+  } catch (error2) {
+    if (containsPromise) {
+      return promiseForObject(results).finally(() => {
+        throw error2;
+      });
+    }
+    throw error2;
   }
   if (!containsPromise) {
     return results;
@@ -14116,17 +14133,19 @@ function mergeResolvers(resolversDefinitions, options2) {
   return result;
 }
 function mergeArguments$1(args1, args2, config) {
-  const result = deduplicateArguments([...args2, ...args1].filter(isSome));
+  const result = deduplicateArguments([...args2, ...args1].filter(isSome), config);
   if (config && config.sort) {
     result.sort(compareNodes);
   }
   return result;
 }
-function deduplicateArguments(args) {
+function deduplicateArguments(args, config) {
   return args.reduce((acc, current) => {
-    const dup = acc.find((arg) => arg.name.value === current.name.value);
-    if (!dup) {
+    const dupIndex = acc.findIndex((arg) => arg.name.value === current.name.value);
+    if (dupIndex === -1) {
       return acc.concat([current]);
+    } else if (!(config === null || config === void 0 ? void 0 : config.reverseArguments)) {
+      acc[dupIndex] = current;
     }
     return acc;
   }, []);
@@ -14134,6 +14153,10 @@ function deduplicateArguments(args) {
 function directiveAlreadyExists(directivesArr, otherDirective) {
   return !!directivesArr.find((directive) => directive.name.value === otherDirective.name.value);
 }
+function isRepeatableDirective(directive, directives) {
+  var _a;
+  return !!((_a = directives === null || directives === void 0 ? void 0 : directives[directive.name.value]) === null || _a === void 0 ? void 0 : _a.repeatable);
+}
 function nameAlreadyExists(name2, namesArr) {
   return namesArr.some(({ value }) => value === name2.value);
 }
@@ -14159,10 +14182,10 @@ function mergeArguments(a1, a2) {
   }
   return result;
 }
-function deduplicateDirectives(directives) {
+function deduplicateDirectives(directives, definitions2) {
   return directives.map((directive, i, all) => {
     const firstAt = all.findIndex((d) => d.name.value === directive.name.value);
-    if (firstAt !== i) {
+    if (firstAt !== i && !isRepeatableDirective(directive, definitions2)) {
       const dup = all[firstAt];
       directive.arguments = mergeArguments(directive.arguments, dup.arguments);
       return null;
@@ -14170,13 +14193,13 @@ function deduplicateDirectives(directives) {
     return directive;
   }).filter(isSome);
 }
-function mergeDirectives(d1 = [], d2 = [], config) {
+function mergeDirectives(d1 = [], d2 = [], config, directives) {
   const reverseOrder = config && config.reverseDirectives;
   const asNext = reverseOrder ? d1 : d2;
   const asFirst = reverseOrder ? d2 : d1;
-  const result = deduplicateDirectives([...asNext]);
+  const result = deduplicateDirectives([...asNext], directives);
   for (const directive of asFirst) {
-    if (directiveAlreadyExists(result, directive)) {
+    if (directiveAlreadyExists(result, directive) && !isRepeatableDirective(directive, directives)) {
       const existingDirectiveIndex = result.findIndex((d) => d.name.value === directive.name.value);
       const existingDirective = result[existingDirectiveIndex];
       result[existingDirectiveIndex].arguments = mergeArguments(directive.arguments || [], existingDirective.arguments || []);
@@ -14196,8 +14219,8 @@ function validateInputs(node, existingNode) {
     description: void 0
   });
   const leaveInputs = new RegExp("(directive @w*d*)|( on .*$)", "g");
-  const sameArguments = printedNode.replace(leaveInputs, "") === printedExistingNode.replace(leaveInputs, "");
-  if (!sameArguments) {
+  const sameArguments2 = printedNode.replace(leaveInputs, "") === printedExistingNode.replace(leaveInputs, "");
+  if (!sameArguments2) {
     throw new Error(`Unable to merge GraphQL directive "${node.name.value}". 
 Existing directive:  
 	${printedExistingNode} 
@@ -14221,7 +14244,7 @@ function mergeDirective(node, existingNode) {
 function deduplicateLists(source, target, filterFn) {
   return source.concat(target.filter((val) => filterFn(val, source)));
 }
-function mergeEnumValues(first, second, config) {
+function mergeEnumValues(first, second, config, directives) {
   if (config === null || config === void 0 ? void 0 : config.consistentEnumMerge) {
     const reversed = [];
     if (first) {
@@ -14242,7 +14265,7 @@ function mergeEnumValues(first, second, config) {
       if (enumValueMap.has(enumValue)) {
         const firstValue = enumValueMap.get(enumValue);
         firstValue.description = secondValue.description || firstValue.description;
-        firstValue.directives = mergeDirectives(secondValue.directives, firstValue.directives);
+        firstValue.directives = mergeDirectives(secondValue.directives, firstValue.directives, directives);
       } else {
         enumValueMap.set(enumValue, secondValue);
       }
@@ -14254,14 +14277,14 @@ function mergeEnumValues(first, second, config) {
   }
   return result;
 }
-function mergeEnum(e1, e2, config) {
+function mergeEnum(e1, e2, config, directives) {
   if (e2) {
     return {
       name: e1.name,
       description: e1["description"] || e2["description"],
       kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) || e1.kind === "EnumTypeDefinition" || e2.kind === "EnumTypeDefinition" ? "EnumTypeDefinition" : "EnumTypeExtension",
       loc: e1.loc,
-      directives: mergeDirectives(e1.directives, e2.directives, config),
+      directives: mergeDirectives(e1.directives, e2.directives, config, directives),
       values: mergeEnumValues(e1.values, e2.values, config)
     };
   }
@@ -14323,39 +14346,24 @@ function defaultStringComparator(a, b) {
     return CompareVal.A_GREATER_THAN_B;
   return CompareVal.A_EQUALS_B;
 }
-function fieldAlreadyExists(fieldsArr, otherField, config) {
-  const result = fieldsArr.find((field) => field.name.value === otherField.name.value);
-  if (result && !(config === null || config === void 0 ? void 0 : config.ignoreFieldConflicts)) {
-    const t1 = extractType(result.type);
-    const t2 = extractType(otherField.type);
-    if (t1.name.value !== t2.name.value) {
-      throw new Error(`Field "${otherField.name.value}" already defined with a different type. Declared as "${t1.name.value}", but you tried to override with "${t2.name.value}"`);
-    }
-  }
-  return !!result;
+function fieldAlreadyExists(fieldsArr, otherField) {
+  const resultIndex = fieldsArr.findIndex((field) => field.name.value === otherField.name.value);
+  return [resultIndex > -1 ? fieldsArr[resultIndex] : null, resultIndex];
 }
-function mergeFields(type2, f1, f2, config) {
+function mergeFields(type2, f1, f2, config, directives) {
   const result = [];
   if (f2 != null) {
     result.push(...f2);
   }
   if (f1 != null) {
     for (const field of f1) {
-      if (fieldAlreadyExists(result, field, config)) {
-        const existing = result.find((f) => f.name.value === field.name.value);
-        if (!(config === null || config === void 0 ? void 0 : config.ignoreFieldConflicts)) {
-          if (config === null || config === void 0 ? void 0 : config.throwOnConflict) {
-            preventConflicts(type2, existing, field, false);
-          } else {
-            preventConflicts(type2, existing, field, true);
-          }
-          if (isNonNullTypeNode(field.type) && !isNonNullTypeNode(existing.type)) {
-            existing.type = field.type;
-          }
-        }
-        existing.arguments = mergeArguments$1(field["arguments"] || [], existing.arguments || [], config);
-        existing.directives = mergeDirectives(field.directives, existing.directives, config);
-        existing.description = field.description || existing.description;
+      const [existing, existingIndex] = fieldAlreadyExists(result, field);
+      if (existing && !(config === null || config === void 0 ? void 0 : config.ignoreFieldConflicts)) {
+        const newField = (config === null || config === void 0 ? void 0 : config.onFieldTypeConflict) && config.onFieldTypeConflict(existing, field, type2, config === null || config === void 0 ? void 0 : config.throwOnConflict) || preventConflicts(type2, existing, field, config === null || config === void 0 ? void 0 : config.throwOnConflict);
+        newField.arguments = mergeArguments$1(field["arguments"] || [], existing["arguments"] || [], config);
+        newField.directives = mergeDirectives(field.directives, existing.directives, config, directives);
+        newField.description = field.description || existing.description;
+        result[existingIndex] = newField;
       } else {
         result.push(field);
       }
@@ -14373,9 +14381,20 @@ function mergeFields(type2, f1, f2, config) {
 function preventConflicts(type2, a, b, ignoreNullability = false) {
   const aType = printTypeNode(a.type);
   const bType = printTypeNode(b.type);
-  if (aType !== bType && !safeChangeForFieldType(a.type, b.type, ignoreNullability)) {
-    throw new Error(`Field '${type2.name.value}.${a.name.value}' changed type from '${aType}' to '${bType}'`);
+  if (aType !== bType) {
+    const t1 = extractType(a.type);
+    const t2 = extractType(b.type);
+    if (t1.name.value !== t2.name.value) {
+      throw new Error(`Field "${b.name.value}" already defined with a different type. Declared as "${t1.name.value}", but you tried to override with "${t2.name.value}"`);
+    }
+    if (!safeChangeForFieldType(a.type, b.type, !ignoreNullability)) {
+      throw new Error(`Field '${type2.name.value}.${a.name.value}' changed type from '${aType}' to '${bType}'`);
+    }
+  }
+  if (isNonNullTypeNode(b.type) && !isNonNullTypeNode(a.type)) {
+    a.type = b.type;
   }
+  return a;
 }
 function safeChangeForFieldType(oldType, newType, ignoreNullability = false) {
   if (!isWrappingTypeNode(oldType) && !isWrappingTypeNode(newType)) {
@@ -14393,7 +14412,7 @@ function safeChangeForFieldType(oldType, newType, ignoreNullability = false) {
   }
   return false;
 }
-function mergeInputType(node, existingNode, config) {
+function mergeInputType(node, existingNode, config, directives) {
   if (existingNode) {
     try {
       return {
@@ -14402,7 +14421,7 @@ function mergeInputType(node, existingNode, config) {
         kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) || node.kind === "InputObjectTypeDefinition" || existingNode.kind === "InputObjectTypeDefinition" ? "InputObjectTypeDefinition" : "InputObjectTypeExtension",
         loc: node.loc,
         fields: mergeFields(node, node.fields, existingNode.fields, config),
-        directives: mergeDirectives(node.directives, existingNode.directives, config)
+        directives: mergeDirectives(node.directives, existingNode.directives, config, directives)
       };
     } catch (e) {
       throw new Error(`Unable to merge GraphQL input type "${node.name.value}": ${e.message}`);
@@ -14423,7 +14442,7 @@ function mergeNamedTypeArray(first = [], second = [], config = {}) {
   }
   return result;
 }
-function mergeInterface(node, existingNode, config) {
+function mergeInterface(node, existingNode, config, directives) {
   if (existingNode) {
     try {
       return {
@@ -14432,7 +14451,7 @@ function mergeInterface(node, existingNode, config) {
         kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) || node.kind === "InterfaceTypeDefinition" || existingNode.kind === "InterfaceTypeDefinition" ? "InterfaceTypeDefinition" : "InterfaceTypeExtension",
         loc: node.loc,
         fields: mergeFields(node, node.fields, existingNode.fields, config),
-        directives: mergeDirectives(node.directives, existingNode.directives, config),
+        directives: mergeDirectives(node.directives, existingNode.directives, config, directives),
         interfaces: node["interfaces"] ? mergeNamedTypeArray(node["interfaces"], existingNode["interfaces"], config) : void 0
       };
     } catch (e) {
@@ -14444,7 +14463,7 @@ function mergeInterface(node, existingNode, config) {
     kind: Kind.INTERFACE_TYPE_DEFINITION
   } : node;
 }
-function mergeType(node, existingNode, config) {
+function mergeType(node, existingNode, config, directives) {
   if (existingNode) {
     try {
       return {
@@ -14453,7 +14472,7 @@ function mergeType(node, existingNode, config) {
         kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) || node.kind === "ObjectTypeDefinition" || existingNode.kind === "ObjectTypeDefinition" ? "ObjectTypeDefinition" : "ObjectTypeExtension",
         loc: node.loc,
         fields: mergeFields(node, node.fields, existingNode.fields, config),
-        directives: mergeDirectives(node.directives, existingNode.directives, config),
+        directives: mergeDirectives(node.directives, existingNode.directives, config, directives),
         interfaces: mergeNamedTypeArray(node.interfaces, existingNode.interfaces, config)
       };
     } catch (e) {
@@ -14465,14 +14484,14 @@ function mergeType(node, existingNode, config) {
     kind: Kind.OBJECT_TYPE_DEFINITION
   } : node;
 }
-function mergeScalar(node, existingNode, config) {
+function mergeScalar(node, existingNode, config, directives) {
   if (existingNode) {
     return {
       name: node.name,
       description: node["description"] || existingNode["description"],
       kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) || node.kind === "ScalarTypeDefinition" || existingNode.kind === "ScalarTypeDefinition" ? "ScalarTypeDefinition" : "ScalarTypeExtension",
       loc: node.loc,
-      directives: mergeDirectives(node.directives, existingNode.directives, config)
+      directives: mergeDirectives(node.directives, existingNode.directives, config, directives)
     };
   }
   return (config === null || config === void 0 ? void 0 : config.convertExtensions) ? {
@@ -14480,13 +14499,13 @@ function mergeScalar(node, existingNode, config) {
     kind: Kind.SCALAR_TYPE_DEFINITION
   } : node;
 }
-function mergeUnion(first, second, config) {
+function mergeUnion(first, second, config, directives) {
   if (second) {
     return {
       name: first.name,
       description: first["description"] || second["description"],
       // ConstXNode has been introduced in v16 but it is not compatible with XNode so we do `as any` for backwards compatibility
-      directives: mergeDirectives(first.directives, second.directives, config),
+      directives: mergeDirectives(first.directives, second.directives, config, directives),
       kind: (config === null || config === void 0 ? void 0 : config.convertExtensions) || first.kind === "UnionTypeDefinition" || second.kind === "UnionTypeDefinition" ? Kind.UNION_TYPE_DEFINITION : Kind.UNION_TYPE_EXTENSION,
       loc: first.loc,
       types: mergeNamedTypeArray(first.types, second.types, config)
@@ -14512,12 +14531,12 @@ function mergeOperationTypes(opNodeList = [], existingOpNodeList = []) {
   }
   return finalOpNodeList;
 }
-function mergeSchemaDefs(node, existingNode, config) {
+function mergeSchemaDefs(node, existingNode, config, directives) {
   if (existingNode) {
     return {
       kind: node.kind === Kind.SCHEMA_DEFINITION || existingNode.kind === Kind.SCHEMA_DEFINITION ? Kind.SCHEMA_DEFINITION : Kind.SCHEMA_EXTENSION,
       description: node["description"] || existingNode["description"],
-      directives: mergeDirectives(node.directives, existingNode.directives, config),
+      directives: mergeDirectives(node.directives, existingNode.directives, config, directives),
       operationTypes: mergeOperationTypes(node.operationTypes, existingNode.operationTypes)
     };
   }
@@ -14530,9 +14549,9 @@ const schemaDefSymbol = "SCHEMA_DEF_SYMBOL";
 function isNamedDefinitionNode(definitionNode) {
   return "name" in definitionNode;
 }
-function mergeGraphQLNodes(nodes, config) {
+function mergeGraphQLNodes(nodes, config, directives = {}) {
   var _a, _b, _c;
-  const mergedResultMap = {};
+  const mergedResultMap = directives;
   for (const nodeDefinition of nodes) {
     if (isNamedDefinitionNode(nodeDefinition)) {
       const name2 = (_a = nodeDefinition.name) === null || _a === void 0 ? void 0 : _a.value;
@@ -14548,27 +14567,27 @@ function mergeGraphQLNodes(nodes, config) {
         switch (nodeDefinition.kind) {
           case Kind.OBJECT_TYPE_DEFINITION:
           case Kind.OBJECT_TYPE_EXTENSION:
-            mergedResultMap[name2] = mergeType(nodeDefinition, mergedResultMap[name2], config);
+            mergedResultMap[name2] = mergeType(nodeDefinition, mergedResultMap[name2], config, directives);
             break;
           case Kind.ENUM_TYPE_DEFINITION:
           case Kind.ENUM_TYPE_EXTENSION:
-            mergedResultMap[name2] = mergeEnum(nodeDefinition, mergedResultMap[name2], config);
+            mergedResultMap[name2] = mergeEnum(nodeDefinition, mergedResultMap[name2], config, directives);
             break;
           case Kind.UNION_TYPE_DEFINITION:
           case Kind.UNION_TYPE_EXTENSION:
-            mergedResultMap[name2] = mergeUnion(nodeDefinition, mergedResultMap[name2], config);
+            mergedResultMap[name2] = mergeUnion(nodeDefinition, mergedResultMap[name2], config, directives);
             break;
           case Kind.SCALAR_TYPE_DEFINITION:
           case Kind.SCALAR_TYPE_EXTENSION:
-            mergedResultMap[name2] = mergeScalar(nodeDefinition, mergedResultMap[name2], config);
+            mergedResultMap[name2] = mergeScalar(nodeDefinition, mergedResultMap[name2], config, directives);
             break;
           case Kind.INPUT_OBJECT_TYPE_DEFINITION:
           case Kind.INPUT_OBJECT_TYPE_EXTENSION:
-            mergedResultMap[name2] = mergeInputType(nodeDefinition, mergedResultMap[name2], config);
+            mergedResultMap[name2] = mergeInputType(nodeDefinition, mergedResultMap[name2], config, directives);
             break;
           case Kind.INTERFACE_TYPE_DEFINITION:
           case Kind.INTERFACE_TYPE_EXTENSION:
-            mergedResultMap[name2] = mergeInterface(nodeDefinition, mergedResultMap[name2], config);
+            mergedResultMap[name2] = mergeInterface(nodeDefinition, mergedResultMap[name2], config, directives);
             break;
           case Kind.DIRECTIVE_DEFINITION:
             mergedResultMap[name2] = mergeDirective(nodeDefinition, mergedResultMap[name2]);
@@ -14602,36 +14621,41 @@ function mergeTypeDefs(typeSource, config) {
   resetComments();
   return result;
 }
-function visitTypeSources(typeSource, options2, allNodes = [], visitedTypeSources = /* @__PURE__ */ new Set()) {
+function visitTypeSources(typeSource, options2, allDirectives = [], allNodes = [], visitedTypeSources = /* @__PURE__ */ new Set()) {
   if (typeSource && !visitedTypeSources.has(typeSource)) {
     visitedTypeSources.add(typeSource);
     if (typeof typeSource === "function") {
-      visitTypeSources(typeSource(), options2, allNodes, visitedTypeSources);
+      visitTypeSources(typeSource(), options2, allDirectives, allNodes, visitedTypeSources);
     } else if (Array.isArray(typeSource)) {
       for (const type2 of typeSource) {
-        visitTypeSources(type2, options2, allNodes, visitedTypeSources);
+        visitTypeSources(type2, options2, allDirectives, allNodes, visitedTypeSources);
       }
     } else if (isSchema(typeSource)) {
       const documentNode = getDocumentNodeFromSchema(typeSource, options2);
-      visitTypeSources(documentNode.definitions, options2, allNodes, visitedTypeSources);
+      visitTypeSources(documentNode.definitions, options2, allDirectives, allNodes, visitedTypeSources);
     } else if (isStringTypes(typeSource) || isSourceTypes(typeSource)) {
       const documentNode = parse(typeSource, options2);
-      visitTypeSources(documentNode.definitions, options2, allNodes, visitedTypeSources);
+      visitTypeSources(documentNode.definitions, options2, allDirectives, allNodes, visitedTypeSources);
     } else if (typeof typeSource === "object" && isDefinitionNode(typeSource)) {
-      allNodes.push(typeSource);
+      if (typeSource.kind === Kind.DIRECTIVE_DEFINITION) {
+        allDirectives.push(typeSource);
+      } else {
+        allNodes.push(typeSource);
+      }
     } else if (isDocumentNode(typeSource)) {
-      visitTypeSources(typeSource.definitions, options2, allNodes, visitedTypeSources);
+      visitTypeSources(typeSource.definitions, options2, allDirectives, allNodes, visitedTypeSources);
     } else {
       throw new Error(`typeDefs must contain only strings, documents, schemas, or functions, got ${typeof typeSource}`);
     }
   }
-  return allNodes;
+  return { allDirectives, allNodes };
 }
 function mergeGraphQLTypes(typeSource, config) {
   var _a, _b, _c;
   resetComments();
-  const allNodes = visitTypeSources(typeSource, config);
-  const mergedNodes = mergeGraphQLNodes(allNodes, config);
+  const { allDirectives, allNodes } = visitTypeSources(typeSource, config);
+  const mergedDirectives = mergeGraphQLNodes(allDirectives, config);
+  const mergedNodes = mergeGraphQLNodes(allNodes, config, mergedDirectives);
   if (config === null || config === void 0 ? void 0 : config.useSchemaDefinition) {
     const schemaDef = mergedNodes[schemaDefSymbol] || {
       kind: Kind.SCHEMA_DEFINITION,
@@ -14934,17 +14958,8 @@ class Mutex {
     return this._semaphore.cancel();
   }
 }
-var easyCrc32Exports = {};
-var easyCrc32$1 = {
-  get exports() {
-    return easyCrc32Exports;
-  },
-  set exports(v) {
-    easyCrc32Exports = v;
-  }
-};
-var easyCrc32 = {};
-easyCrc32.calculate = function(str) {
+var easyCrc32$1 = {};
+easyCrc32$1.calculate = function(str) {
   if (str == null)
     return null;
   var utf8CharCodes = utf8encode(str), crc = -1;
@@ -15227,19 +15242,9 @@ var crcTable = [
   1510334235,
   755167117
 ];
-(function(module2) {
-  module2.exports = easyCrc32;
-})(easyCrc32$1);
-const crc32 = /* @__PURE__ */ getDefaultExportFromCjs(easyCrc32Exports);
-var bitsetExports = {};
-var bitset = {
-  get exports() {
-    return bitsetExports;
-  },
-  set exports(v) {
-    bitsetExports = v;
-  }
-};
+var easyCrc32 = easyCrc32$1;
+const crc32 = /* @__PURE__ */ getDefaultExportFromCjs(easyCrc32);
+var bitset = { exports: {} };
 /**
  * @license BitSet.js v5.1.1 2/1/2020
  * http://www.xarg.org/2014/03/javascript-bit-array/
@@ -15983,10 +15988,11 @@ var bitset = {
       module2["exports"] = BitSet2;
     }
   })();
-})(bitset, bitsetExports);
+})(bitset, bitset.exports);
+var bitsetExports = bitset.exports;
 const BitSet = /* @__PURE__ */ getDefaultExportFromCjs(bitsetExports);
 const name = "proskomma-core";
-const version = "0.10.10";
+const version = "0.10.12";
 const description$b = "A Scripture Runtime Engine";
 const files = [
   "dist"
@@ -16580,18 +16586,10 @@ const enumRegexIndexTuples = (enumSuccinct, regex) => {
   return ret;
 };
 const enums = { enumStringIndex, enumRegexIndexTuples };
-var uuidExports = {};
-var uuid = {
-  get exports() {
-    return uuidExports;
-  },
-  set exports(v) {
-    uuidExports = v;
-  }
-};
+var uuid = { exports: {} };
 /*!
 **  Pure-UUID -- Pure JavaScript Based Universally Unique Identifier (UUID)
-**  Copyright (c) 2004-2021 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Copyright (c) 2004-2023 Dr. Ralf S. Engelschall <rse@engelschall.com>
 **
 **  Permission is hereby granted, free of charge, to any person obtaining
 **  a copy of this software and associated documentation files (the
@@ -17159,7 +17157,21 @@ var uuid = {
       this.state = ui64_clone(this.inc);
       this.next();
       ui64_and(this.state, this.mask);
-      seed = ui64_n2i(seed !== void 0 ? seed >>> 0 : Math.random() * 4294967295 >>> 0);
+      var arr;
+      if (seed !== void 0)
+        seed = ui64_n2i(seed >>> 0);
+      else if (typeof window === "object" && typeof window.crypto === "object" && typeof window.crypto.getRandomValues === "function") {
+        arr = new Uint32Array(2);
+        window.crypto.getRandomValues(arr);
+        seed = ui64_or(ui64_n2i(arr[0] >>> 0), ui64_ror(ui64_n2i(arr[1] >>> 0), 32));
+      } else if (typeof globalThis === "object" && typeof globalThis.crypto === "object" && typeof globalThis.crypto.getRandomValues === "function") {
+        arr = new Uint32Array(2);
+        globalThis.crypto.getRandomValues(arr);
+        seed = ui64_or(ui64_n2i(arr[0] >>> 0), ui64_ror(ui64_n2i(arr[1] >>> 0), 32));
+      } else {
+        seed = ui64_n2i(Math.random() * 4294967295 >>> 0);
+        ui64_or(seed, ui64_ror(ui64_n2i((/* @__PURE__ */ new Date()).getTime()), 32));
+      }
       ui64_or(this.state, seed);
       this.next();
     };
@@ -17181,7 +17193,17 @@ var uuid = {
       ui64_xor(output, output2);
       return ui64_i2n(output);
     };
+    PCG.prototype.reseed = function(seed) {
+      if (typeof seed !== "string")
+        throw new Error("UUID: PCG: seed: invalid argument (string expected)");
+      var arr = sha1_core(s2a(seed, { ibits: 8, obits: 32, obigendian: true }), seed.length * 8);
+      for (var i = 0; i < arr.length; i++)
+        ui64_xor(pcg.state, ui64_n2i(arr[i] >>> 0));
+    };
     var pcg = new PCG();
+    PCG.reseed = function(seed) {
+      pcg.reseed(seed);
+    };
     var prng = function(len, radix) {
       var bytes = [];
       for (var i = 0; i < len; i++)
@@ -17212,7 +17234,7 @@ var uuid = {
       var i;
       var uuid2 = this;
       if (version2 === 1) {
-        var date = new Date();
+        var date = /* @__PURE__ */ new Date();
         var time_now = date.getTime();
         if (time_now !== time_last)
           time_seq = 0;
@@ -17383,17 +17405,11 @@ var uuid = {
     return UUID2;
   });
 })(uuid);
-const UUID = uuidExports;
-var base64Exports = {};
-var base64$1 = {
-  get exports() {
-    return base64Exports;
-  },
-  set exports(v) {
-    base64Exports = v;
-  }
-};
+var uuidExports = uuid.exports;
+const UUID = /* @__PURE__ */ getDefaultExportFromCjs(uuidExports);
+var base64$1 = { exports: {} };
 /*! https://mths.be/base64 v1.0.0 by @mathias | MIT license */
+base64$1.exports;
 (function(module2, exports2) {
   (function(root) {
     var freeExports = exports2;
@@ -17491,8 +17507,9 @@ var base64$1 = {
       root.base64 = base642;
     }
   })(commonjsGlobal);
-})(base64$1, base64Exports);
-const base64 = base64Exports;
+})(base64$1, base64$1.exports);
+var base64Exports = base64$1.exports;
+const base64 = /* @__PURE__ */ getDefaultExportFromCjs(base64Exports);
 const generateId = () => base64.encode(new UUID(4)).substring(0, 12);
 const graftLocation = {
   heading: "block",
@@ -19723,15 +19740,7 @@ class DocSet {
     return crc32.calculate(docIdsString);
   }
 }
-var ajvExports = {};
-var ajv = {
-  get exports() {
-    return ajvExports;
-  },
-  set exports(v) {
-    ajvExports = v;
-  }
-};
+var ajv = { exports: {} };
 var core$2 = {};
 var validate = {};
 var boolSchema = {};
@@ -19902,7 +19911,7 @@ var scope = {};
   (function(UsedValueState2) {
     UsedValueState2[UsedValueState2["Started"] = 0] = "Started";
     UsedValueState2[UsedValueState2["Completed"] = 1] = "Completed";
-  })(UsedValueState = exports2.UsedValueState || (exports2.UsedValueState = {}));
+  })(UsedValueState || (exports2.UsedValueState = UsedValueState = {}));
   exports2.varKinds = {
     const: new code_12.Name("const"),
     let: new code_12.Name("let"),
@@ -20744,193 +20753,197 @@ var scope = {};
   }
 })(codegen);
 var util = {};
-(function(exports2) {
-  Object.defineProperty(exports2, "__esModule", { value: true });
-  exports2.checkStrictMode = exports2.getErrorPath = exports2.Type = exports2.useFunc = exports2.setEvaluated = exports2.evaluatedPropsToName = exports2.mergeEvaluated = exports2.eachItem = exports2.unescapeJsonPointer = exports2.escapeJsonPointer = exports2.escapeFragment = exports2.unescapeFragment = exports2.schemaRefOrVal = exports2.schemaHasRulesButRef = exports2.schemaHasRules = exports2.checkUnknownRules = exports2.alwaysValidSchema = exports2.toHash = void 0;
-  const codegen_12 = codegen;
-  const code_12 = code$1;
-  function toHash(arr) {
-    const hash = {};
-    for (const item of arr)
-      hash[item] = true;
-    return hash;
-  }
-  exports2.toHash = toHash;
-  function alwaysValidSchema(it, schema) {
-    if (typeof schema == "boolean")
-      return schema;
-    if (Object.keys(schema).length === 0)
-      return true;
-    checkUnknownRules(it, schema);
-    return !schemaHasRules(schema, it.self.RULES.all);
-  }
-  exports2.alwaysValidSchema = alwaysValidSchema;
-  function checkUnknownRules(it, schema = it.schema) {
-    const { opts, self: self2 } = it;
-    if (!opts.strictSchema)
-      return;
-    if (typeof schema === "boolean")
-      return;
-    const rules2 = self2.RULES.keywords;
-    for (const key in schema) {
-      if (!rules2[key])
-        checkStrictMode(it, `unknown keyword: "${key}"`);
-    }
-  }
-  exports2.checkUnknownRules = checkUnknownRules;
-  function schemaHasRules(schema, rules2) {
-    if (typeof schema == "boolean")
-      return !schema;
-    for (const key in schema)
-      if (rules2[key])
-        return true;
-    return false;
-  }
-  exports2.schemaHasRules = schemaHasRules;
-  function schemaHasRulesButRef(schema, RULES) {
-    if (typeof schema == "boolean")
-      return !schema;
-    for (const key in schema)
-      if (key !== "$ref" && RULES.all[key])
-        return true;
-    return false;
+Object.defineProperty(util, "__esModule", { value: true });
+util.checkStrictMode = util.getErrorPath = util.Type = util.useFunc = util.setEvaluated = util.evaluatedPropsToName = util.mergeEvaluated = util.eachItem = util.unescapeJsonPointer = util.escapeJsonPointer = util.escapeFragment = util.unescapeFragment = util.schemaRefOrVal = util.schemaHasRulesButRef = util.schemaHasRules = util.checkUnknownRules = util.alwaysValidSchema = util.toHash = void 0;
+const codegen_1$v = codegen;
+const code_1$a = code$1;
+function toHash(arr) {
+  const hash = {};
+  for (const item of arr)
+    hash[item] = true;
+  return hash;
+}
+util.toHash = toHash;
+function alwaysValidSchema(it, schema) {
+  if (typeof schema == "boolean")
+    return schema;
+  if (Object.keys(schema).length === 0)
+    return true;
+  checkUnknownRules(it, schema);
+  return !schemaHasRules(schema, it.self.RULES.all);
+}
+util.alwaysValidSchema = alwaysValidSchema;
+function checkUnknownRules(it, schema = it.schema) {
+  const { opts, self: self2 } = it;
+  if (!opts.strictSchema)
+    return;
+  if (typeof schema === "boolean")
+    return;
+  const rules2 = self2.RULES.keywords;
+  for (const key in schema) {
+    if (!rules2[key])
+      checkStrictMode(it, `unknown keyword: "${key}"`);
   }
-  exports2.schemaHasRulesButRef = schemaHasRulesButRef;
-  function schemaRefOrVal({ topSchemaRef, schemaPath }, schema, keyword2, $data) {
-    if (!$data) {
-      if (typeof schema == "number" || typeof schema == "boolean")
-        return schema;
-      if (typeof schema == "string")
-        return (0, codegen_12._)`${schema}`;
-    }
-    return (0, codegen_12._)`${topSchemaRef}${schemaPath}${(0, codegen_12.getProperty)(keyword2)}`;
-  }
-  exports2.schemaRefOrVal = schemaRefOrVal;
-  function unescapeFragment(str) {
-    return unescapeJsonPointer(decodeURIComponent(str));
-  }
-  exports2.unescapeFragment = unescapeFragment;
-  function escapeFragment(str) {
-    return encodeURIComponent(escapeJsonPointer(str));
-  }
-  exports2.escapeFragment = escapeFragment;
-  function escapeJsonPointer(str) {
-    if (typeof str == "number")
-      return `${str}`;
-    return str.replace(/~/g, "~0").replace(/\//g, "~1");
-  }
-  exports2.escapeJsonPointer = escapeJsonPointer;
-  function unescapeJsonPointer(str) {
-    return str.replace(/~1/g, "/").replace(/~0/g, "~");
-  }
-  exports2.unescapeJsonPointer = unescapeJsonPointer;
-  function eachItem(xs, f) {
-    if (Array.isArray(xs)) {
-      for (const x of xs)
-        f(x);
-    } else {
-      f(xs);
-    }
+}
+util.checkUnknownRules = checkUnknownRules;
+function schemaHasRules(schema, rules2) {
+  if (typeof schema == "boolean")
+    return !schema;
+  for (const key in schema)
+    if (rules2[key])
+      return true;
+  return false;
+}
+util.schemaHasRules = schemaHasRules;
+function schemaHasRulesButRef(schema, RULES) {
+  if (typeof schema == "boolean")
+    return !schema;
+  for (const key in schema)
+    if (key !== "$ref" && RULES.all[key])
+      return true;
+  return false;
+}
+util.schemaHasRulesButRef = schemaHasRulesButRef;
+function schemaRefOrVal({ topSchemaRef, schemaPath }, schema, keyword2, $data) {
+  if (!$data) {
+    if (typeof schema == "number" || typeof schema == "boolean")
+      return schema;
+    if (typeof schema == "string")
+      return (0, codegen_1$v._)`${schema}`;
   }
-  exports2.eachItem = eachItem;
-  function makeMergeEvaluated({ mergeNames, mergeToName, mergeValues, resultToName }) {
-    return (gen, from, to, toName) => {
-      const res = to === void 0 ? from : to instanceof codegen_12.Name ? (from instanceof codegen_12.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to) : from instanceof codegen_12.Name ? (mergeToName(gen, to, from), from) : mergeValues(from, to);
-      return toName === codegen_12.Name && !(res instanceof codegen_12.Name) ? resultToName(gen, res) : res;
-    };
+  return (0, codegen_1$v._)`${topSchemaRef}${schemaPath}${(0, codegen_1$v.getProperty)(keyword2)}`;
+}
+util.schemaRefOrVal = schemaRefOrVal;
+function unescapeFragment(str) {
+  return unescapeJsonPointer(decodeURIComponent(str));
+}
+util.unescapeFragment = unescapeFragment;
+function escapeFragment(str) {
+  return encodeURIComponent(escapeJsonPointer(str));
+}
+util.escapeFragment = escapeFragment;
+function escapeJsonPointer(str) {
+  if (typeof str == "number")
+    return `${str}`;
+  return str.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+util.escapeJsonPointer = escapeJsonPointer;
+function unescapeJsonPointer(str) {
+  return str.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+util.unescapeJsonPointer = unescapeJsonPointer;
+function eachItem(xs, f) {
+  if (Array.isArray(xs)) {
+    for (const x of xs)
+      f(x);
+  } else {
+    f(xs);
   }
-  exports2.mergeEvaluated = {
-    props: makeMergeEvaluated({
-      mergeNames: (gen, from, to) => gen.if((0, codegen_12._)`${to} !== true && ${from} !== undefined`, () => {
-        gen.if((0, codegen_12._)`${from} === true`, () => gen.assign(to, true), () => gen.assign(to, (0, codegen_12._)`${to} || {}`).code((0, codegen_12._)`Object.assign(${to}, ${from})`));
-      }),
-      mergeToName: (gen, from, to) => gen.if((0, codegen_12._)`${to} !== true`, () => {
-        if (from === true) {
-          gen.assign(to, true);
-        } else {
-          gen.assign(to, (0, codegen_12._)`${to} || {}`);
-          setEvaluated(gen, to, from);
-        }
-      }),
-      mergeValues: (from, to) => from === true ? true : { ...from, ...to },
-      resultToName: evaluatedPropsToName
-    }),
-    items: makeMergeEvaluated({
-      mergeNames: (gen, from, to) => gen.if((0, codegen_12._)`${to} !== true && ${from} !== undefined`, () => gen.assign(to, (0, codegen_12._)`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)),
-      mergeToName: (gen, from, to) => gen.if((0, codegen_12._)`${to} !== true`, () => gen.assign(to, from === true ? true : (0, codegen_12._)`${to} > ${from} ? ${to} : ${from}`)),
-      mergeValues: (from, to) => from === true ? true : Math.max(from, to),
-      resultToName: (gen, items2) => gen.var("items", items2)
-    })
+}
+util.eachItem = eachItem;
+function makeMergeEvaluated({ mergeNames, mergeToName, mergeValues, resultToName }) {
+  return (gen, from, to, toName) => {
+    const res = to === void 0 ? from : to instanceof codegen_1$v.Name ? (from instanceof codegen_1$v.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to) : from instanceof codegen_1$v.Name ? (mergeToName(gen, to, from), from) : mergeValues(from, to);
+    return toName === codegen_1$v.Name && !(res instanceof codegen_1$v.Name) ? resultToName(gen, res) : res;
   };
-  function evaluatedPropsToName(gen, ps) {
-    if (ps === true)
-      return gen.var("props", true);
-    const props = gen.var("props", (0, codegen_12._)`{}`);
-    if (ps !== void 0)
-      setEvaluated(gen, props, ps);
-    return props;
-  }
-  exports2.evaluatedPropsToName = evaluatedPropsToName;
-  function setEvaluated(gen, props, ps) {
-    Object.keys(ps).forEach((p) => gen.assign((0, codegen_12._)`${props}${(0, codegen_12.getProperty)(p)}`, true));
-  }
-  exports2.setEvaluated = setEvaluated;
-  const snippets = {};
-  function useFunc(gen, f) {
-    return gen.scopeValue("func", {
-      ref: f,
-      code: snippets[f.code] || (snippets[f.code] = new code_12._Code(f.code))
-    });
-  }
-  exports2.useFunc = useFunc;
-  var Type;
-  (function(Type2) {
-    Type2[Type2["Num"] = 0] = "Num";
-    Type2[Type2["Str"] = 1] = "Str";
-  })(Type = exports2.Type || (exports2.Type = {}));
-  function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
-    if (dataProp instanceof codegen_12.Name) {
-      const isNumber = dataPropType === Type.Num;
-      return jsPropertySyntax ? isNumber ? (0, codegen_12._)`"[" + ${dataProp} + "]"` : (0, codegen_12._)`"['" + ${dataProp} + "']"` : isNumber ? (0, codegen_12._)`"/" + ${dataProp}` : (0, codegen_12._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
-    }
-    return jsPropertySyntax ? (0, codegen_12.getProperty)(dataProp).toString() : "/" + escapeJsonPointer(dataProp);
-  }
-  exports2.getErrorPath = getErrorPath;
-  function checkStrictMode(it, msg, mode = it.opts.strictSchema) {
-    if (!mode)
-      return;
-    msg = `strict mode: ${msg}`;
-    if (mode === true)
-      throw new Error(msg);
-    it.self.logger.warn(msg);
-  }
-  exports2.checkStrictMode = checkStrictMode;
-})(util);
+}
+util.mergeEvaluated = {
+  props: makeMergeEvaluated({
+    mergeNames: (gen, from, to) => gen.if((0, codegen_1$v._)`${to} !== true && ${from} !== undefined`, () => {
+      gen.if((0, codegen_1$v._)`${from} === true`, () => gen.assign(to, true), () => gen.assign(to, (0, codegen_1$v._)`${to} || {}`).code((0, codegen_1$v._)`Object.assign(${to}, ${from})`));
+    }),
+    mergeToName: (gen, from, to) => gen.if((0, codegen_1$v._)`${to} !== true`, () => {
+      if (from === true) {
+        gen.assign(to, true);
+      } else {
+        gen.assign(to, (0, codegen_1$v._)`${to} || {}`);
+        setEvaluated(gen, to, from);
+      }
+    }),
+    mergeValues: (from, to) => from === true ? true : { ...from, ...to },
+    resultToName: evaluatedPropsToName
+  }),
+  items: makeMergeEvaluated({
+    mergeNames: (gen, from, to) => gen.if((0, codegen_1$v._)`${to} !== true && ${from} !== undefined`, () => gen.assign(to, (0, codegen_1$v._)`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)),
+    mergeToName: (gen, from, to) => gen.if((0, codegen_1$v._)`${to} !== true`, () => gen.assign(to, from === true ? true : (0, codegen_1$v._)`${to} > ${from} ? ${to} : ${from}`)),
+    mergeValues: (from, to) => from === true ? true : Math.max(from, to),
+    resultToName: (gen, items2) => gen.var("items", items2)
+  })
+};
+function evaluatedPropsToName(gen, ps) {
+  if (ps === true)
+    return gen.var("props", true);
+  const props = gen.var("props", (0, codegen_1$v._)`{}`);
+  if (ps !== void 0)
+    setEvaluated(gen, props, ps);
+  return props;
+}
+util.evaluatedPropsToName = evaluatedPropsToName;
+function setEvaluated(gen, props, ps) {
+  Object.keys(ps).forEach((p) => gen.assign((0, codegen_1$v._)`${props}${(0, codegen_1$v.getProperty)(p)}`, true));
+}
+util.setEvaluated = setEvaluated;
+const snippets = {};
+function useFunc(gen, f) {
+  return gen.scopeValue("func", {
+    ref: f,
+    code: snippets[f.code] || (snippets[f.code] = new code_1$a._Code(f.code))
+  });
+}
+util.useFunc = useFunc;
+var Type;
+(function(Type2) {
+  Type2[Type2["Num"] = 0] = "Num";
+  Type2[Type2["Str"] = 1] = "Str";
+})(Type || (util.Type = Type = {}));
+function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
+  if (dataProp instanceof codegen_1$v.Name) {
+    const isNumber = dataPropType === Type.Num;
+    return jsPropertySyntax ? isNumber ? (0, codegen_1$v._)`"[" + ${dataProp} + "]"` : (0, codegen_1$v._)`"['" + ${dataProp} + "']"` : isNumber ? (0, codegen_1$v._)`"/" + ${dataProp}` : (0, codegen_1$v._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
+  }
+  return jsPropertySyntax ? (0, codegen_1$v.getProperty)(dataProp).toString() : "/" + escapeJsonPointer(dataProp);
+}
+util.getErrorPath = getErrorPath;
+function checkStrictMode(it, msg, mode = it.opts.strictSchema) {
+  if (!mode)
+    return;
+  msg = `strict mode: ${msg}`;
+  if (mode === true)
+    throw new Error(msg);
+  it.self.logger.warn(msg);
+}
+util.checkStrictMode = checkStrictMode;
 var names$1 = {};
 Object.defineProperty(names$1, "__esModule", { value: true });
-const codegen_1$t = codegen;
+const codegen_1$u = codegen;
 const names = {
   // validation function arguments
-  data: new codegen_1$t.Name("data"),
+  data: new codegen_1$u.Name("data"),
+  // data passed to validation function
   // args passed from referencing schema
-  valCxt: new codegen_1$t.Name("valCxt"),
-  instancePath: new codegen_1$t.Name("instancePath"),
-  parentData: new codegen_1$t.Name("parentData"),
-  parentDataProperty: new codegen_1$t.Name("parentDataProperty"),
-  rootData: new codegen_1$t.Name("rootData"),
-  dynamicAnchors: new codegen_1$t.Name("dynamicAnchors"),
+  valCxt: new codegen_1$u.Name("valCxt"),
+  // validation/data context - should not be used directly, it is destructured to the names below
+  instancePath: new codegen_1$u.Name("instancePath"),
+  parentData: new codegen_1$u.Name("parentData"),
+  parentDataProperty: new codegen_1$u.Name("parentDataProperty"),
+  rootData: new codegen_1$u.Name("rootData"),
+  // root data - same as the data passed to the first/top validation function
+  dynamicAnchors: new codegen_1$u.Name("dynamicAnchors"),
+  // used to support recursiveRef and dynamicRef
   // function scoped variables
-  vErrors: new codegen_1$t.Name("vErrors"),
-  errors: new codegen_1$t.Name("errors"),
-  this: new codegen_1$t.Name("this"),
+  vErrors: new codegen_1$u.Name("vErrors"),
+  // null or array of validation errors
+  errors: new codegen_1$u.Name("errors"),
+  // counter of validation errors
+  this: new codegen_1$u.Name("this"),
   // "globals"
-  self: new codegen_1$t.Name("self"),
-  scope: new codegen_1$t.Name("scope"),
+  self: new codegen_1$u.Name("self"),
+  scope: new codegen_1$u.Name("scope"),
   // JTD serialize/parse name for JSON string and position
-  json: new codegen_1$t.Name("json"),
-  jsonPos: new codegen_1$t.Name("jsonPos"),
-  jsonLen: new codegen_1$t.Name("jsonLen"),
-  jsonPart: new codegen_1$t.Name("jsonPart")
+  json: new codegen_1$u.Name("json"),
+  jsonPos: new codegen_1$u.Name("jsonPos"),
+  jsonLen: new codegen_1$u.Name("jsonLen"),
+  jsonPart: new codegen_1$u.Name("jsonPart")
 };
 names$1.default = names;
 (function(exports2) {
@@ -21003,6 +21016,7 @@ names$1.default = names;
   const E = {
     keyword: new codegen_12.Name("keyword"),
     schemaPath: new codegen_12.Name("schemaPath"),
+    // also used in JTD errors
     params: new codegen_12.Name("params"),
     propertyName: new codegen_12.Name("propertyName"),
     message: new codegen_12.Name("message"),
@@ -21051,8 +21065,8 @@ names$1.default = names;
 })(errors);
 Object.defineProperty(boolSchema, "__esModule", { value: true });
 boolSchema.boolOrEmptySchema = boolSchema.topBoolOrEmptySchema = void 0;
-const errors_1$2 = errors;
-const codegen_1$s = codegen;
+const errors_1$3 = errors;
+const codegen_1$t = codegen;
 const names_1$6 = names$1;
 const boolError = {
   message: "boolean schema is false"
@@ -21064,7 +21078,7 @@ function topBoolOrEmptySchema(it) {
   } else if (typeof schema == "object" && schema.$async === true) {
     gen.return(names_1$6.default.data);
   } else {
-    gen.assign((0, codegen_1$s._)`${validateName2}.errors`, null);
+    gen.assign((0, codegen_1$t._)`${validateName2}.errors`, null);
     gen.return(true);
   }
 }
@@ -21091,7 +21105,7 @@ function falseSchemaError(it, overrideAllErrors) {
     params: {},
     it
   };
-  (0, errors_1$2.reportError)(cxt, boolError, void 0, overrideAllErrors);
+  (0, errors_1$3.reportError)(cxt, boolError, void 0, overrideAllErrors);
 }
 var dataType = {};
 var rules = {};
@@ -21136,185 +21150,183 @@ function shouldUseRule(schema, rule) {
   return schema[rule.keyword] !== void 0 || ((_a = rule.definition.implements) === null || _a === void 0 ? void 0 : _a.some((kwd) => schema[kwd] !== void 0));
 }
 applicability.shouldUseRule = shouldUseRule;
-(function(exports2) {
-  Object.defineProperty(exports2, "__esModule", { value: true });
-  exports2.reportTypeError = exports2.checkDataTypes = exports2.checkDataType = exports2.coerceAndCheckDataType = exports2.getJSONTypes = exports2.getSchemaTypes = exports2.DataType = void 0;
-  const rules_1 = rules;
-  const applicability_12 = applicability;
-  const errors_12 = errors;
-  const codegen_12 = codegen;
-  const util_12 = util;
-  var DataType;
-  (function(DataType2) {
-    DataType2[DataType2["Correct"] = 0] = "Correct";
-    DataType2[DataType2["Wrong"] = 1] = "Wrong";
-  })(DataType = exports2.DataType || (exports2.DataType = {}));
-  function getSchemaTypes(schema) {
-    const types2 = getJSONTypes(schema.type);
-    const hasNull = types2.includes("null");
-    if (hasNull) {
-      if (schema.nullable === false)
-        throw new Error("type: null contradicts nullable: false");
-    } else {
-      if (!types2.length && schema.nullable !== void 0) {
-        throw new Error('"nullable" cannot be used without "type"');
-      }
-      if (schema.nullable === true)
-        types2.push("null");
+Object.defineProperty(dataType, "__esModule", { value: true });
+dataType.reportTypeError = dataType.checkDataTypes = dataType.checkDataType = dataType.coerceAndCheckDataType = dataType.getJSONTypes = dataType.getSchemaTypes = dataType.DataType = void 0;
+const rules_1 = rules;
+const applicability_1$1 = applicability;
+const errors_1$2 = errors;
+const codegen_1$s = codegen;
+const util_1$q = util;
+var DataType;
+(function(DataType2) {
+  DataType2[DataType2["Correct"] = 0] = "Correct";
+  DataType2[DataType2["Wrong"] = 1] = "Wrong";
+})(DataType || (dataType.DataType = DataType = {}));
+function getSchemaTypes(schema) {
+  const types2 = getJSONTypes(schema.type);
+  const hasNull = types2.includes("null");
+  if (hasNull) {
+    if (schema.nullable === false)
+      throw new Error("type: null contradicts nullable: false");
+  } else {
+    if (!types2.length && schema.nullable !== void 0) {
+      throw new Error('"nullable" cannot be used without "type"');
     }
-    return types2;
+    if (schema.nullable === true)
+      types2.push("null");
   }
-  exports2.getSchemaTypes = getSchemaTypes;
-  function getJSONTypes(ts) {
-    const types2 = Array.isArray(ts) ? ts : ts ? [ts] : [];
-    if (types2.every(rules_1.isJSONType))
-      return types2;
-    throw new Error("type must be JSONType or JSONType[]: " + types2.join(","));
-  }
-  exports2.getJSONTypes = getJSONTypes;
-  function coerceAndCheckDataType(it, types2) {
-    const { gen, data, opts } = it;
-    const coerceTo = coerceToTypes(types2, opts.coerceTypes);
-    const checkTypes = types2.length > 0 && !(coerceTo.length === 0 && types2.length === 1 && (0, applicability_12.schemaHasRulesForType)(it, types2[0]));
-    if (checkTypes) {
-      const wrongType = checkDataTypes(types2, data, opts.strictNumbers, DataType.Wrong);
-      gen.if(wrongType, () => {
-        if (coerceTo.length)
-          coerceData(it, types2, coerceTo);
-        else
-          reportTypeError(it);
-      });
-    }
-    return checkTypes;
+  return types2;
+}
+dataType.getSchemaTypes = getSchemaTypes;
+function getJSONTypes(ts) {
+  const types2 = Array.isArray(ts) ? ts : ts ? [ts] : [];
+  if (types2.every(rules_1.isJSONType))
+    return types2;
+  throw new Error("type must be JSONType or JSONType[]: " + types2.join(","));
+}
+dataType.getJSONTypes = getJSONTypes;
+function coerceAndCheckDataType(it, types2) {
+  const { gen, data, opts } = it;
+  const coerceTo = coerceToTypes(types2, opts.coerceTypes);
+  const checkTypes = types2.length > 0 && !(coerceTo.length === 0 && types2.length === 1 && (0, applicability_1$1.schemaHasRulesForType)(it, types2[0]));
+  if (checkTypes) {
+    const wrongType = checkDataTypes(types2, data, opts.strictNumbers, DataType.Wrong);
+    gen.if(wrongType, () => {
+      if (coerceTo.length)
+        coerceData(it, types2, coerceTo);
+      else
+        reportTypeError(it);
+    });
   }
-  exports2.coerceAndCheckDataType = coerceAndCheckDataType;
-  const COERCIBLE = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]);
-  function coerceToTypes(types2, coerceTypes) {
-    return coerceTypes ? types2.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
+  return checkTypes;
+}
+dataType.coerceAndCheckDataType = coerceAndCheckDataType;
+const COERCIBLE = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]);
+function coerceToTypes(types2, coerceTypes) {
+  return coerceTypes ? types2.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
+}
+function coerceData(it, types2, coerceTo) {
+  const { gen, data, opts } = it;
+  const dataType2 = gen.let("dataType", (0, codegen_1$s._)`typeof ${data}`);
+  const coerced = gen.let("coerced", (0, codegen_1$s._)`undefined`);
+  if (opts.coerceTypes === "array") {
+    gen.if((0, codegen_1$s._)`${dataType2} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1$s._)`${data}[0]`).assign(dataType2, (0, codegen_1$s._)`typeof ${data}`).if(checkDataTypes(types2, data, opts.strictNumbers), () => gen.assign(coerced, data)));
   }
-  function coerceData(it, types2, coerceTo) {
-    const { gen, data, opts } = it;
-    const dataType2 = gen.let("dataType", (0, codegen_12._)`typeof ${data}`);
-    const coerced = gen.let("coerced", (0, codegen_12._)`undefined`);
-    if (opts.coerceTypes === "array") {
-      gen.if((0, codegen_12._)`${dataType2} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_12._)`${data}[0]`).assign(dataType2, (0, codegen_12._)`typeof ${data}`).if(checkDataTypes(types2, data, opts.strictNumbers), () => gen.assign(coerced, data)));
-    }
-    gen.if((0, codegen_12._)`${coerced} !== undefined`);
-    for (const t of coerceTo) {
-      if (COERCIBLE.has(t) || t === "array" && opts.coerceTypes === "array") {
-        coerceSpecificType(t);
-      }
-    }
-    gen.else();
-    reportTypeError(it);
-    gen.endIf();
-    gen.if((0, codegen_12._)`${coerced} !== undefined`, () => {
-      gen.assign(data, coerced);
-      assignParentData(it, coerced);
-    });
-    function coerceSpecificType(t) {
-      switch (t) {
-        case "string":
-          gen.elseIf((0, codegen_12._)`${dataType2} == "number" || ${dataType2} == "boolean"`).assign(coerced, (0, codegen_12._)`"" + ${data}`).elseIf((0, codegen_12._)`${data} === null`).assign(coerced, (0, codegen_12._)`""`);
-          return;
-        case "number":
-          gen.elseIf((0, codegen_12._)`${dataType2} == "boolean" || ${data} === null
-              || (${dataType2} == "string" && ${data} && ${data} == +${data})`).assign(coerced, (0, codegen_12._)`+${data}`);
-          return;
-        case "integer":
-          gen.elseIf((0, codegen_12._)`${dataType2} === "boolean" || ${data} === null
-              || (${dataType2} === "string" && ${data} && ${data} == +${data} && !(${data} % 1))`).assign(coerced, (0, codegen_12._)`+${data}`);
-          return;
-        case "boolean":
-          gen.elseIf((0, codegen_12._)`${data} === "false" || ${data} === 0 || ${data} === null`).assign(coerced, false).elseIf((0, codegen_12._)`${data} === "true" || ${data} === 1`).assign(coerced, true);
-          return;
-        case "null":
-          gen.elseIf((0, codegen_12._)`${data} === "" || ${data} === 0 || ${data} === false`);
-          gen.assign(coerced, null);
-          return;
-        case "array":
-          gen.elseIf((0, codegen_12._)`${dataType2} === "string" || ${dataType2} === "number"
-              || ${dataType2} === "boolean" || ${data} === null`).assign(coerced, (0, codegen_12._)`[${data}]`);
-      }
+  gen.if((0, codegen_1$s._)`${coerced} !== undefined`);
+  for (const t of coerceTo) {
+    if (COERCIBLE.has(t) || t === "array" && opts.coerceTypes === "array") {
+      coerceSpecificType(t);
     }
   }
-  function assignParentData({ gen, parentData, parentDataProperty }, expr) {
-    gen.if((0, codegen_12._)`${parentData} !== undefined`, () => gen.assign((0, codegen_12._)`${parentData}[${parentDataProperty}]`, expr));
-  }
-  function checkDataType(dataType2, data, strictNums, correct = DataType.Correct) {
-    const EQ = correct === DataType.Correct ? codegen_12.operators.EQ : codegen_12.operators.NEQ;
-    let cond;
-    switch (dataType2) {
+  gen.else();
+  reportTypeError(it);
+  gen.endIf();
+  gen.if((0, codegen_1$s._)`${coerced} !== undefined`, () => {
+    gen.assign(data, coerced);
+    assignParentData(it, coerced);
+  });
+  function coerceSpecificType(t) {
+    switch (t) {
+      case "string":
+        gen.elseIf((0, codegen_1$s._)`${dataType2} == "number" || ${dataType2} == "boolean"`).assign(coerced, (0, codegen_1$s._)`"" + ${data}`).elseIf((0, codegen_1$s._)`${data} === null`).assign(coerced, (0, codegen_1$s._)`""`);
+        return;
+      case "number":
+        gen.elseIf((0, codegen_1$s._)`${dataType2} == "boolean" || ${data} === null
+              || (${dataType2} == "string" && ${data} && ${data} == +${data})`).assign(coerced, (0, codegen_1$s._)`+${data}`);
+        return;
+      case "integer":
+        gen.elseIf((0, codegen_1$s._)`${dataType2} === "boolean" || ${data} === null
+              || (${dataType2} === "string" && ${data} && ${data} == +${data} && !(${data} % 1))`).assign(coerced, (0, codegen_1$s._)`+${data}`);
+        return;
+      case "boolean":
+        gen.elseIf((0, codegen_1$s._)`${data} === "false" || ${data} === 0 || ${data} === null`).assign(coerced, false).elseIf((0, codegen_1$s._)`${data} === "true" || ${data} === 1`).assign(coerced, true);
+        return;
       case "null":
-        return (0, codegen_12._)`${data} ${EQ} null`;
+        gen.elseIf((0, codegen_1$s._)`${data} === "" || ${data} === 0 || ${data} === false`);
+        gen.assign(coerced, null);
+        return;
       case "array":
-        cond = (0, codegen_12._)`Array.isArray(${data})`;
-        break;
-      case "object":
-        cond = (0, codegen_12._)`${data} && typeof ${data} == "object" && !Array.isArray(${data})`;
-        break;
-      case "integer":
-        cond = numCond((0, codegen_12._)`!(${data} % 1) && !isNaN(${data})`);
-        break;
-      case "number":
-        cond = numCond();
-        break;
-      default:
-        return (0, codegen_12._)`typeof ${data} ${EQ} ${dataType2}`;
-    }
-    return correct === DataType.Correct ? cond : (0, codegen_12.not)(cond);
-    function numCond(_cond = codegen_12.nil) {
-      return (0, codegen_12.and)((0, codegen_12._)`typeof ${data} == "number"`, _cond, strictNums ? (0, codegen_12._)`isFinite(${data})` : codegen_12.nil);
-    }
-  }
-  exports2.checkDataType = checkDataType;
-  function checkDataTypes(dataTypes, data, strictNums, correct) {
-    if (dataTypes.length === 1) {
-      return checkDataType(dataTypes[0], data, strictNums, correct);
-    }
-    let cond;
-    const types2 = (0, util_12.toHash)(dataTypes);
-    if (types2.array && types2.object) {
-      const notObj = (0, codegen_12._)`typeof ${data} != "object"`;
-      cond = types2.null ? notObj : (0, codegen_12._)`!${data} || ${notObj}`;
-      delete types2.null;
-      delete types2.array;
-      delete types2.object;
-    } else {
-      cond = codegen_12.nil;
-    }
-    if (types2.number)
-      delete types2.integer;
-    for (const t in types2)
-      cond = (0, codegen_12.and)(cond, checkDataType(t, data, strictNums, correct));
-    return cond;
-  }
-  exports2.checkDataTypes = checkDataTypes;
-  const typeError = {
-    message: ({ schema }) => `must be ${schema}`,
-    params: ({ schema, schemaValue }) => typeof schema == "string" ? (0, codegen_12._)`{type: ${schema}}` : (0, codegen_12._)`{type: ${schemaValue}}`
-  };
-  function reportTypeError(it) {
-    const cxt = getTypeErrorContext(it);
-    (0, errors_12.reportError)(cxt, typeError);
-  }
-  exports2.reportTypeError = reportTypeError;
-  function getTypeErrorContext(it) {
-    const { gen, data, schema } = it;
-    const schemaCode = (0, util_12.schemaRefOrVal)(it, schema, "type");
-    return {
-      gen,
-      keyword: "type",
-      data,
-      schema: schema.type,
-      schemaCode,
-      schemaValue: schemaCode,
-      parentSchema: schema,
-      params: {},
-      it
-    };
+        gen.elseIf((0, codegen_1$s._)`${dataType2} === "string" || ${dataType2} === "number"
+              || ${dataType2} === "boolean" || ${data} === null`).assign(coerced, (0, codegen_1$s._)`[${data}]`);
+    }
   }
-})(dataType);
+}
+function assignParentData({ gen, parentData, parentDataProperty }, expr) {
+  gen.if((0, codegen_1$s._)`${parentData} !== undefined`, () => gen.assign((0, codegen_1$s._)`${parentData}[${parentDataProperty}]`, expr));
+}
+function checkDataType(dataType2, data, strictNums, correct = DataType.Correct) {
+  const EQ = correct === DataType.Correct ? codegen_1$s.operators.EQ : codegen_1$s.operators.NEQ;
+  let cond;
+  switch (dataType2) {
+    case "null":
+      return (0, codegen_1$s._)`${data} ${EQ} null`;
+    case "array":
+      cond = (0, codegen_1$s._)`Array.isArray(${data})`;
+      break;
+    case "object":
+      cond = (0, codegen_1$s._)`${data} && typeof ${data} == "object" && !Array.isArray(${data})`;
+      break;
+    case "integer":
+      cond = numCond((0, codegen_1$s._)`!(${data} % 1) && !isNaN(${data})`);
+      break;
+    case "number":
+      cond = numCond();
+      break;
+    default:
+      return (0, codegen_1$s._)`typeof ${data} ${EQ} ${dataType2}`;
+  }
+  return correct === DataType.Correct ? cond : (0, codegen_1$s.not)(cond);
+  function numCond(_cond = codegen_1$s.nil) {
+    return (0, codegen_1$s.and)((0, codegen_1$s._)`typeof ${data} == "number"`, _cond, strictNums ? (0, codegen_1$s._)`isFinite(${data})` : codegen_1$s.nil);
+  }
+}
+dataType.checkDataType = checkDataType;
+function checkDataTypes(dataTypes, data, strictNums, correct) {
+  if (dataTypes.length === 1) {
+    return checkDataType(dataTypes[0], data, strictNums, correct);
+  }
+  let cond;
+  const types2 = (0, util_1$q.toHash)(dataTypes);
+  if (types2.array && types2.object) {
+    const notObj = (0, codegen_1$s._)`typeof ${data} != "object"`;
+    cond = types2.null ? notObj : (0, codegen_1$s._)`!${data} || ${notObj}`;
+    delete types2.null;
+    delete types2.array;
+    delete types2.object;
+  } else {
+    cond = codegen_1$s.nil;
+  }
+  if (types2.number)
+    delete types2.integer;
+  for (const t in types2)
+    cond = (0, codegen_1$s.and)(cond, checkDataType(t, data, strictNums, correct));
+  return cond;
+}
+dataType.checkDataTypes = checkDataTypes;
+const typeError = {
+  message: ({ schema }) => `must be ${schema}`,
+  params: ({ schema, schemaValue }) => typeof schema == "string" ? (0, codegen_1$s._)`{type: ${schema}}` : (0, codegen_1$s._)`{type: ${schemaValue}}`
+};
+function reportTypeError(it) {
+  const cxt = getTypeErrorContext(it);
+  (0, errors_1$2.reportError)(cxt, typeError);
+}
+dataType.reportTypeError = reportTypeError;
+function getTypeErrorContext(it) {
+  const { gen, data, schema } = it;
+  const schemaCode = (0, util_1$q.schemaRefOrVal)(it, schema, "type");
+  return {
+    gen,
+    keyword: "type",
+    data,
+    schema: schema.type,
+    schemaCode,
+    schemaValue: schemaCode,
+    parentSchema: schema,
+    params: {},
+    it
+  };
+}
 var defaults = {};
 Object.defineProperty(defaults, "__esModule", { value: true });
 defaults.assignDefaults = void 0;
@@ -21701,15 +21713,7 @@ var fastDeepEqual = function equal(a, b) {
   }
   return a !== a && b !== b;
 };
-var jsonSchemaTraverseExports = {};
-var jsonSchemaTraverse = {
-  get exports() {
-    return jsonSchemaTraverseExports;
-  },
-  set exports(v) {
-    jsonSchemaTraverseExports = v;
-  }
-};
+var jsonSchemaTraverse = { exports: {} };
 var traverse$1 = jsonSchemaTraverse.exports = function(schema, opts, cb) {
   if (typeof opts == "function") {
     cb = opts;
@@ -21791,6 +21795,7 @@ function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr,
 function escapeJsonPtr(str) {
   return str.replace(/~/g, "~0").replace(/\//g, "~1");
 }
+var jsonSchemaTraverseExports = jsonSchemaTraverse.exports;
 Object.defineProperty(resolve$1, "__esModule", { value: true });
 resolve$1.getSchemaRefs = resolve$1.resolveUrl = resolve$1.normalizeId = resolve$1._getFullPath = resolve$1.getFullPath = resolve$1.inlineRef = void 0;
 const util_1$m = util;
@@ -21895,15 +21900,15 @@ function getSchemaRefs(schema, baseId) {
     if (parentJsonPtr === void 0)
       return;
     const fullPath = pathPrefix + jsonPtr;
-    let baseId2 = baseIds[parentJsonPtr];
+    let innerBaseId = baseIds[parentJsonPtr];
     if (typeof sch[schemaId] == "string")
-      baseId2 = addRef.call(this, sch[schemaId]);
+      innerBaseId = addRef.call(this, sch[schemaId]);
     addAnchor.call(this, sch.$anchor);
     addAnchor.call(this, sch.$dynamicAnchor);
-    baseIds[jsonPtr] = baseId2;
+    baseIds[jsonPtr] = innerBaseId;
     function addRef(ref2) {
       const _resolve = this.opts.uriResolver.resolve;
-      ref2 = normalizeId(baseId2 ? _resolve(baseId2, ref2) : ref2);
+      ref2 = normalizeId(innerBaseId ? _resolve(innerBaseId, ref2) : ref2);
       if (schemaRefs.has(ref2))
         throw ambiguos(ref2);
       schemaRefs.add(ref2);
@@ -22515,6 +22520,7 @@ function compileSchema(sch) {
     parentDataProperty: names_1$2.default.parentDataProperty,
     dataNames: [names_1$2.default.data],
     dataPathArr: [codegen_1$m.nil],
+    // TODO can its length be used as dataLevel if nil is removed?
     dataLevel: 0,
     dataTypes: [],
     definedProperties: /* @__PURE__ */ new Set(),
@@ -22707,15 +22713,7 @@ const require$$9$1 = {
   additionalProperties: additionalProperties$a
 };
 var uri$1 = {};
-var uri_allExports = {};
-var uri_all = {
-  get exports() {
-    return uri_allExports;
-  },
-  set exports(v) {
-    uri_allExports = v;
-  }
-};
+var uri_all = { exports: {} };
 /** @license URI.js v4.4.1 (c) 2011 Gary Court. License: http://github.com/garycourt/uri-js */
 (function(module2, exports2) {
   (function(global2, factory) {
@@ -23755,7 +23753,8 @@ var uri_all = {
     exports3.unescapeComponent = unescapeComponent;
     Object.defineProperty(exports3, "__esModule", { value: true });
   });
-})(uri_all, uri_allExports);
+})(uri_all, uri_all.exports);
+var uri_allExports = uri_all.exports;
 Object.defineProperty(uri$1, "__esModule", { value: true });
 const uri = uri_allExports;
 uri.code = 'require("ajv/dist/runtime/uri").default';
@@ -23788,7 +23787,7 @@ uri$1.default = uri;
   } });
   const validation_error_12 = validation_error;
   const ref_error_12 = ref_error;
-  const rules_1 = rules;
+  const rules_12 = rules;
   const compile_12 = compile;
   const codegen_2 = codegen;
   const resolve_12 = resolve$1;
@@ -23879,7 +23878,7 @@ uri$1.default = uri;
       this.logger = getLogger(opts.logger);
       const formatOpt = opts.validateFormats;
       opts.validateFormats = false;
-      this.RULES = (0, rules_1.getRules)();
+      this.RULES = (0, rules_12.getRules)();
       checkOptions.call(this, removedOptions, opts, "NOT SUPPORTED");
       checkOptions.call(this, deprecatedOptions, opts, "DEPRECATED", "warn");
       this._metaOpts = getMetaSchemaOptions.call(this);
@@ -24235,9 +24234,9 @@ uri$1.default = uri;
       }
     }
   }
-  exports2.default = Ajv2;
   Ajv2.ValidationError = validation_error_12.default;
   Ajv2.MissingRefError = ref_error_12.default;
+  exports2.default = Ajv2;
   function checkOptions(checkOpts, options2, msg, log = "error") {
     for (const key in checkOpts) {
       const opt = key;
@@ -25831,14 +25830,13 @@ const draft7Vocabularies = [
 draft7.default = draft7Vocabularies;
 var discriminator = {};
 var types = {};
-(function(exports2) {
-  Object.defineProperty(exports2, "__esModule", { value: true });
-  exports2.DiscrError = void 0;
-  (function(DiscrError) {
-    DiscrError["Tag"] = "tag";
-    DiscrError["Mapping"] = "mapping";
-  })(exports2.DiscrError || (exports2.DiscrError = {}));
-})(types);
+Object.defineProperty(types, "__esModule", { value: true });
+types.DiscrError = void 0;
+var DiscrError;
+(function(DiscrError2) {
+  DiscrError2["Tag"] = "tag";
+  DiscrError2["Mapping"] = "mapping";
+})(DiscrError || (types.DiscrError = DiscrError = {}));
 Object.defineProperty(discriminator, "__esModule", { value: true });
 const codegen_1 = codegen;
 const types_1 = types;
@@ -26182,7 +26180,7 @@ const require$$3$2 = {
 };
 (function(module2, exports2) {
   Object.defineProperty(exports2, "__esModule", { value: true });
-  exports2.MissingRefError = exports2.ValidationError = exports2.CodeGen = exports2.Name = exports2.nil = exports2.stringify = exports2.str = exports2._ = exports2.KeywordCxt = void 0;
+  exports2.MissingRefError = exports2.ValidationError = exports2.CodeGen = exports2.Name = exports2.nil = exports2.stringify = exports2.str = exports2._ = exports2.KeywordCxt = exports2.Ajv = void 0;
   const core_12 = core$2;
   const draft7_1 = draft7;
   const discriminator_1 = discriminator;
@@ -26208,7 +26206,9 @@ const require$$3$2 = {
       return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
     }
   }
+  exports2.Ajv = Ajv2;
   module2.exports = exports2 = Ajv2;
+  module2.exports.Ajv = Ajv2;
   Object.defineProperty(exports2, "__esModule", { value: true });
   exports2.default = Ajv2;
   var validate_12 = validate;
@@ -26242,7 +26242,8 @@ const require$$3$2 = {
   Object.defineProperty(exports2, "MissingRefError", { enumerable: true, get: function() {
     return ref_error_12.default;
   } });
-})(ajv, ajvExports);
+})(ajv, ajv.exports);
+var ajvExports = ajv.exports;
 const title$9 = "Root";
 const type$p = "object";
 const description$9 = "Root Element";
@@ -32323,6 +32324,7 @@ function deepCopy(e, t = defaultOpts) {
   return t.detectCircular && s.setAsCopied(e, n), copyObjectContents(e, { destObject: n, srcType: c, watcher: s, options: t }, 0), n;
 }
 var deepCopyAll_min = deepCopy;
+const deepCopy$1 = /* @__PURE__ */ getDefaultExportFromCjs(deepCopyAll_min);
 var _deepCopyAll = _interopRequireDefault$1(deepCopyAll_min);
 function _interopRequireDefault$1(obj) {
   return obj && obj.__esModule ? obj : { default: obj };
@@ -34184,7 +34186,7 @@ const parseUsfm = (str, parser) => {
     parser.parseItem(preTokenObjectForFragment(matches[n], lexingRegexes));
   }
 };
-var sax = {};
+var sax$1 = {};
 var emitterComponent;
 var hasRequiredEmitterComponent;
 function requireEmitterComponent() {
@@ -34338,15 +34340,7 @@ function requireStream() {
   return stream;
 }
 var string_decoder = {};
-var safeBufferExports = {};
-var safeBuffer = {
-  get exports() {
-    return safeBufferExports;
-  },
-  set exports(v) {
-    safeBufferExports = v;
-  }
-};
+var safeBuffer = { exports: {} };
 var buffer = {};
 var ieee754 = {};
 /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
@@ -36141,7 +36135,7 @@ function requireBuffer() {
 var hasRequiredSafeBuffer;
 function requireSafeBuffer() {
   if (hasRequiredSafeBuffer)
-    return safeBufferExports;
+    return safeBuffer.exports;
   hasRequiredSafeBuffer = 1;
   (function(module2, exports2) {
     var buffer2 = requireBuffer();
@@ -36196,8 +36190,8 @@ function requireSafeBuffer() {
       }
       return buffer2.SlowBuffer(size);
     };
-  })(safeBuffer, safeBufferExports);
-  return safeBufferExports;
+  })(safeBuffer, safeBuffer.exports);
+  return safeBuffer.exports;
 }
 var hasRequiredString_decoder;
 function requireString_decoder() {
@@ -36615,6 +36609,9 @@ function requireString_decoder() {
       Stream = function() {
       };
     }
+    if (!Stream)
+      Stream = function() {
+      };
     var streamWraps = sax2.EVENTS.filter(function(ev) {
       return ev !== "error" && ev !== "end";
     });
@@ -37825,9 +37822,16 @@ function requireString_decoder() {
                 break;
             }
             if (c === ";") {
-              parser[buffer2] += parseEntity(parser);
-              parser.entity = "";
-              parser.state = returnState;
+              if (parser.opt.unparsedEntities) {
+                var parsedEntity = parseEntity(parser);
+                parser.entity = "";
+                parser.state = returnState;
+                parser.write(parsedEntity);
+              } else {
+                parser[buffer2] += parseEntity(parser);
+                parser.entity = "";
+                parser.state = returnState;
+              }
             } else if (isMatch(parser.entity.length ? entityBody : entityStart, c)) {
               parser.entity += c;
             } else {
@@ -37837,8 +37841,9 @@ function requireString_decoder() {
               parser.state = returnState;
             }
             continue;
-          default:
+          default: {
             throw new Error(parser, "Unknown state: " + parser.state);
+          }
         }
       }
       if (parser.position >= parser.bufferCheckPosition) {
@@ -37897,7 +37902,8 @@ function requireString_decoder() {
       })();
     }
   })(exports2);
-})(sax);
+})(sax$1);
+const sax = /* @__PURE__ */ getDefaultExportFromCjs(sax$1);
 class UsxLexer {
   constructor() {
     this.sax = sax.parser(true);
@@ -39023,6 +39029,7 @@ const parseNodes = (str, parser, bookCode) => {
   });
 };
 const { labelForScope: labelForScope$2 } = utils.scopeDefs;
+const idTest = new RegExp(/^[A-Z0-9_]+$/);
 const buildSpecLookup = (specs2) => {
   const ret = {};
   for (const spec of specs2) {
@@ -39067,9 +39074,9 @@ const specs = (pt) => [
           onEnd: (parser, label) => {
             parser.headers[label] = parser.current.sequence.plainText();
             if (label === "id") {
-              if (parser.headers[label].length === 3 || parser.headers[label].length > 3 && parser.headers[label].substring(3, 4) === " ") {
-                const bookCode = parser.headers[label].substring(0, 3);
-                parser.headers["bookCode"] = bookCode;
+              const idBits = parser.headers[label].split(" ", 2);
+              if (idBits[0].length >= 3 && idBits[0].length <= 12 && idTest.test(idBits[0])) {
+                parser.headers["bookCode"] = idBits[0];
               }
             }
           }
@@ -41467,7 +41474,7 @@ const pushModifiedBlocks = (oldSequence, newSequence2, blockFilterFunc, itemFilt
   newSequence2.blocks = [];
   for (const [blockN, block2] of oldSequence.blocks.entries()) {
     if (blockFilterFunc(oldSequence, blockN, block2)) {
-      const newBlock2 = blockRewriteFunc(oldSequence, blockN, deepCopyAll_min(block2));
+      const newBlock2 = blockRewriteFunc(oldSequence, blockN, deepCopy$1(block2));
       newBlock2.c.clear();
       modifyBlockItems(
         oldSequence,
@@ -42056,6 +42063,18 @@ const keyValueResolvers = {
   key: (root) => root[0],
   value: (root) => root[1]
 };
+const keyCountSchemaString = `
+"""Key/Count tuple"""
+type KeyCount {
+    """The key"""
+    key: String!
+    """The number of occurrences"""
+    count: Int!
+}`;
+const keyCountResolvers = {
+  key: (root) => root[0],
+  count: (root) => root[1]
+};
 const cvSchemaString = `
 """A chapter-verse reference"""
 type cv {
@@ -44523,6 +44542,13 @@ type Sequence {
     """Whether to coerce the strings (toLower|toUpper|none)"""
     coerceCase: String
   ) : [String!]!
+  """A list of token strings the sequence with counts"""
+  uniqueTokenCounts(
+      """Whether to coerce the strings (toLower|toUpper|none)"""
+    coerceCase: String
+) : [KeyCount!]!
+    """A list of unique characters in the sequence with counts"""
+  uniqueCharacterCounts: [KeyCount!]!
   """Returns true if a main sequence contains the specified tokens"""
   hasChars(
     """Token strings to be matched exactly"""
@@ -44695,6 +44721,43 @@ const sequenceResolvers = {
     }
     return Array.from(tokens2).sort();
   },
+  uniqueCharacterCounts: (root, args, context) => {
+    const characters = {};
+    root.blocks.forEach(
+      (b) => context.docSet.unsuccinctifyItems(b.c, { tokens: true }, null).forEach(
+        (t) => {
+          const chars = t[2].split("");
+          for (const char of chars) {
+            characters[char] ? characters[char] += 1 : characters[char] = 1;
+          }
+        }
+      )
+    );
+    return Object.entries(characters).sort((a, b) => b[1] - a[1]);
+  },
+  uniqueTokenCounts: (root, args, context) => {
+    const wordlikes = {};
+    root.blocks.forEach(
+      (b) => context.docSet.unsuccinctifyItems(b.c, { tokens: true }, null).forEach(
+        (t) => {
+          let wordlike = t[2];
+          if (args.coerceCase && !["toLower", "toUpper", "none"].includes(args.coerceCase)) {
+            throw new Error(
+              `coerceCase, when present, must be 'toLower', 'toUpper' or 'none', not '${args.coerceCase}'`
+            );
+          }
+          if (args.coerceCase === "toLower") {
+            wordlike = wordlike.toLowerCase();
+          }
+          if (args.coerceCase === "toUpper") {
+            wordlike = wordlike.toUpperCase();
+          }
+          wordlikes[wordlike] ? wordlikes[wordlike] += 1 : wordlikes[wordlike] = 1;
+        }
+      )
+    );
+    return Object.entries(wordlikes).sort((a, b) => b[1] - a[1]);
+  },
   hasChars: (root, args, context) => {
     if (root.type !== "main") {
       throw new Error(`Only available for the main sequence, not ${root.type}`);
@@ -49898,6 +49961,7 @@ const typeDefs = `
       ${querySchemaString}
       ${mutationsSchemaString}
       ${keyValueSchemaString}
+      ${keyCountSchemaString}
       ${cvSchemaString}
       ${idPartsSchemaString}
       ${inputAttSpecSchemaString}
@@ -49939,6 +50003,7 @@ const resolvers = {
   Mutation: mutationsResolvers,
   Query: queryResolvers,
   KeyValue: keyValueResolvers,
+  KeyCount: keyCountResolvers,
   cv: cvResolvers,
   idParts: idPartsResolvers,
   Item: itemResolvers,