@terrazzo/parser 2.0.0-alpha.6 → 2.0.0-beta.0

package/src/resolver/load.ts

@@ -1,216 +0,0 @@
-import type * as momoa from '@humanwhocodes/momoa';
-import { type InputSource, type InputSourceWithDocument, maybeRawJSON } from '@terrazzo/json-schema-tools';
-import type { TokenNormalizedSet } from '@terrazzo/token-tools';
-import { merge } from 'merge-anything';
-import type yamlToMomoa from 'yaml-to-momoa';
-import { toMomoa } from '../lib/momoa.js';
-import { makeInputKey } from '../lib/resolver-utils.js';
-import type Logger from '../logger.js';
-import { processTokens } from '../parse/process.js';
-import type { ConfigInit, Resolver, ResolverSourceNormalized } from '../types.js';
-import { normalizeResolver } from './normalize.js';
-import { isLikelyResolver, validateResolver } from './validate.js';
-
-export interface LoadResolverOptions {
-  config: ConfigInit;
-  logger: Logger;
-  req: (url: URL, origin: URL) => Promise<string>;
-  yamlToMomoa?: typeof yamlToMomoa;
-}
-
-/** Quick-parse input sources and find a resolver */
-export async function loadResolver(
-  inputs: InputSource[],
-  { config, logger, req, yamlToMomoa }: LoadResolverOptions,
-): Promise<{ resolver: Resolver | undefined; tokens: TokenNormalizedSet; sources: InputSourceWithDocument[] }> {
-  let resolverDoc: momoa.DocumentNode | undefined;
-  let tokens: TokenNormalizedSet = {};
-  const entry = {
-    group: 'parser',
-    label: 'init',
-  } as const;
-
-  for (const input of inputs) {
-    let document: momoa.DocumentNode | undefined;
-    if (typeof input.src === 'string') {
-      if (maybeRawJSON(input.src)) {
-        document = toMomoa(input.src);
-      } else if (yamlToMomoa) {
-        document = yamlToMomoa(input.src);
-      } else {
-        logger.error({
-          ...entry,
-          message: `Install yaml-to-momoa package to parse YAML, and pass in as option, e.g.:
-
-  import { bundle } from '@terrazzo/json-schema-tools';
-  import yamlToMomoa from 'yaml-to-momoa';
-
-  bundle(yamlString, { yamlToMomoa });`,
-        });
-      }
-    } else if (input.src && typeof input.src === 'object') {
-      document = toMomoa(JSON.stringify(input.src, undefined, 2));
-    } else {
-      logger.error({ ...entry, message: `Could not parse ${input.filename}. Is this valid JSON or YAML?` });
-    }
-    if (!document || !isLikelyResolver(document)) {
-      continue;
-    }
-    if (inputs.length > 1) {
-      logger.error({ ...entry, message: `Resolver must be the only input, found ${inputs.length} sources.` });
-    }
-    resolverDoc = document;
-    break;
-  }
-
-  let resolver: Resolver | undefined;
-  if (resolverDoc) {
-    validateResolver(resolverDoc, { logger, src: inputs[0]!.src });
-    const normalized = await normalizeResolver(resolverDoc, {
-      filename: inputs[0]!.filename!,
-      logger,
-      req,
-      src: inputs[0]!.src,
-      yamlToMomoa,
-    });
-    resolver = createResolver(normalized, { config, logger, sources: [{ ...inputs[0]!, document: resolverDoc }] });
-
-    // If a resolver is present, load a single permutation to get a base token set.
-    const firstInput: Record<string, string> = {};
-    for (const m of resolver.source.resolutionOrder) {
-      if (m.type !== 'modifier') {
-        continue;
-      }
-      firstInput[m.name] = typeof m.default === 'string' ? m.default : Object.keys(m.contexts)[0]!;
-    }
-    tokens = resolver.apply(firstInput);
-  }
-
-  return {
-    resolver,
-    tokens,
-    sources: [{ ...inputs[0]!, document: resolverDoc! }],
-  };
-}
-
-export interface CreateResolverOptions {
-  config: ConfigInit;
-  logger: Logger;
-  sources: InputSourceWithDocument[];
-}
-
-/** Create an interface to resolve permutations */
-export function createResolver(
-  resolverSource: ResolverSourceNormalized,
-  { config, logger, sources }: CreateResolverOptions,
-): Resolver {
-  const inputDefaults: Record<string, string> = {};
-  const validContexts: Record<string, string[]> = {};
-  const allPermutations: Record<string, string>[] = [];
-
-  const resolverCache: Record<string, any> = {};
-
-  for (const m of resolverSource.resolutionOrder) {
-    if (m.type === 'modifier') {
-      if (typeof m.default === 'string') {
-        inputDefaults[m.name] = m.default!;
-      }
-      validContexts[m.name] = Object.keys(m.contexts);
-    }
-  }
-
-  return {
-    apply(inputRaw): TokenNormalizedSet {
-      let tokensRaw: TokenNormalizedSet = {};
-      const input = { ...inputDefaults, ...inputRaw };
-      const inputKey = makeInputKey(input);
-
-      if (resolverCache[inputKey]) {
-        return resolverCache[inputKey];
-      }
-
-      for (const item of resolverSource.resolutionOrder) {
-        switch (item.type) {
-          case 'set': {
-            for (const s of item.sources) {
-              tokensRaw = merge(tokensRaw, s) as TokenNormalizedSet;
-            }
-            break;
-          }
-          case 'modifier': {
-            const context = input[item.name]!;
-            const sources = item.contexts[context];
-            if (!sources) {
-              logger.error({
-                group: 'parser',
-                label: 'resolver',
-                message: `Modifier ${item.name} has no context ${JSON.stringify(context)}.`,
-              });
-            }
-            for (const s of sources ?? []) {
-              tokensRaw = merge(tokensRaw, s) as TokenNormalizedSet;
-            }
-            break;
-          }
-        }
-      }
-
-      const src = JSON.stringify(tokensRaw, undefined, 2);
-      const rootSource = { filename: resolverSource._source.filename!, document: toMomoa(src), src };
-      const tokens = processTokens(rootSource, {
-        config,
-        logger,
-        sourceByFilename: { [resolverSource._source.filename!.href]: rootSource },
-        refMap: {},
-        sources,
-      });
-      resolverCache[inputKey] = tokens;
-      return tokens;
-    },
-    source: resolverSource,
-    listPermutations() {
-      // only do work on first call, then cache subsequent work. this could be thousands of possible values!
-      if (!allPermutations.length) {
-        allPermutations.push(...calculatePermutations(Object.entries(validContexts)));
-      }
-      return allPermutations;
-    },
-    isValidInput(input: Record<string, string>) {
-      if (!input || typeof input !== 'object') {
-        logger.error({ group: 'parser', label: 'resolver', message: `Invalid input: ${JSON.stringify(input)}.` });
-      }
-      if (!Object.keys(input).every((k) => k in validContexts)) {
-        return false; // 1. invalid if unknown modifier name
-      }
-      for (const [name, contexts] of Object.entries(validContexts)) {
-        // Note: empty strings are valid! Don’t check for truthiness.
-        if (name in input) {
-          if (!contexts.includes(input[name]!)) {
-            return false; // 2. invalid if unknown context
-          }
-        } else if (!(name in inputDefaults)) {
-          return false; // 3. invalid if omitted, and no default
-        }
-      }
-      return true;
-    },
-  };
-}
-
-/** Calculate all permutations */
-export function calculatePermutations(options: [string, string[]][]) {
-  const permutationCount = [1];
-  for (const [_name, contexts] of options) {
-    permutationCount.push(contexts.length * (permutationCount.at(-1) || 1));
-  }
-  const permutations: Record<string, string>[] = [];
-  for (let i = 0; i < permutationCount.at(-1)!; i++) {
-    const input: Record<string, string> = {};
-    for (let j = 0; j < options.length; j++) {
-      const [name, contexts] = options[j]!;
-      input[name] = contexts[Math.floor(i / permutationCount[j]!) % contexts.length]!;
-    }
-    permutations.push(input);
-  }
-  return permutations.length ? permutations : [{}];
-}

package/src/resolver/normalize.ts

@@ -1,106 +0,0 @@
-import * as momoa from '@humanwhocodes/momoa';
-import { bundle, getObjMember, getObjMembers, parseRef } from '@terrazzo/json-schema-tools';
-import type yamlToMomoa from 'yaml-to-momoa';
-import type Logger from '../logger.js';
-import type {
-  ResolverModifierInline,
-  ResolverModifierNormalized,
-  ResolverSetInline,
-  ResolverSetNormalized,
-  ResolverSourceNormalized,
-} from '../types.js';
-import { validateModifier, validateSet } from './validate.js';
-
-export interface NormalizeResolverOptions {
-  logger: Logger;
-  yamlToMomoa?: typeof yamlToMomoa;
-  filename: URL;
-  req: (url: URL, origin: URL) => Promise<string>;
-  src?: any;
-}
-
-/** Normalize resolver (assuming it’s been validated) */
-export async function normalizeResolver(
-  node: momoa.DocumentNode,
-  { filename, req, src, logger, yamlToMomoa }: NormalizeResolverOptions,
-): Promise<ResolverSourceNormalized> {
-  const resolverSource = momoa.evaluate(node) as unknown as ResolverSourceNormalized;
-  const resolutionOrder = getObjMember(node.body as momoa.ObjectNode, 'resolutionOrder') as momoa.ArrayNode;
-
-  return {
-    name: resolverSource.name,
-    version: resolverSource.version,
-    description: resolverSource.description,
-    sets: resolverSource.sets,
-    modifiers: resolverSource.modifiers,
-    resolutionOrder: await Promise.all(
-      resolutionOrder.elements.map(async (element, i) => {
-        const layer = element.value as momoa.ObjectNode;
-        const members = getObjMembers(layer);
-
-        // If this is an inline set or modifier it’s already been validated; we only need
-        // to resolve & validate $refs here which haven’t yet been parsed
-        let item = layer as unknown as ResolverSetInline | ResolverModifierInline;
-
-        // 1. $ref
-        if (members.$ref) {
-          const entry = { group: 'parser', label: 'init', node: members.$ref, src } as const;
-          const { url, subpath } = parseRef((members.$ref as unknown as momoa.StringNode).value);
-          if (url === '.') {
-            // 1a. local $ref: pull from local document
-            if (!subpath?.[0]) {
-              logger.error({ ...entry, message: '$ref can’t refer to the root document.' });
-            } else if (subpath[0] !== 'sets' && subpath[0] !== 'modifiers') {
-              // Note: technically we could allow $defs, but that’s just unnecessary shenanigans here.
-              logger.error({
-                ...entry,
-                message: 'Local $ref in resolutionOrder must point to either #/sets/[set] or #/modifiers/[modifiers].',
-              });
-            } else {
-              const resolvedItem = resolverSource[subpath[0] as 'sets' | 'modifiers']?.[subpath[1]!];
-              if (!resolvedItem) {
-                logger.error({ ...entry, message: 'Invalid $ref' });
-              } else {
-                item = {
-                  type: subpath[0] === 'sets' ? 'set' : 'modifier',
-                  name: subpath[1],
-                  ...(resolvedItem as any), // Note: as long as this exists, this has already been validated to be correct
-                };
-              }
-            }
-          } else {
-            // 1b. remote $ref: load and validate
-            const result = await bundle(
-              [{ filename: new URL(url, filename), src: resolverSource.resolutionOrder[i]! }],
-              {
-                req,
-                yamlToMomoa,
-              },
-            );
-            if (result.document.body.type === 'Object') {
-              const type = getObjMember(result.document.body, 'type');
-              if (type?.type === 'String' && type.value === 'set') {
-                validateSet(result.document.body as momoa.ObjectNode, true, src);
-                item = momoa.evaluate(result.document.body) as unknown as ResolverSetInline;
-              } else if (type?.type === 'String' && type.value === 'modifier') {
-                validateModifier(result.document.body as momoa.ObjectNode, true, src);
-                item = momoa.evaluate(result.document.body) as unknown as ResolverModifierInline;
-              }
-            }
-            logger.error({ ...entry, message: '$ref did not resolve to a valid Set or Modifier.' });
-          }
-        }
-
-        // 2. resolve inline sources & contexts
-        const finalResult = await bundle([{ filename, src: item }], { req, yamlToMomoa });
-        return momoa.evaluate(finalResult.document.body) as unknown as
-          | ResolverSetNormalized
-          | ResolverModifierNormalized;
-      }),
-    ),
-    _source: {
-      filename,
-      node,
-    },
-  };
-}

package/src/resolver/validate.ts

@@ -1,375 +0,0 @@
-import * as momoa from '@humanwhocodes/momoa';
-import { getObjMember, getObjMembers } from '@terrazzo/json-schema-tools';
-import type { LogEntry, default as Logger } from '../logger.js';
-
-/**
- * Determine whether this is likely a resolver
- * We use terms the word “likely” because this occurs before validation. Since
- * we may be dealing with a doc _intended_ to be a resolver, but may be lacking
- * some critical information, how can we determine intent? There’s a bit of
- * guesswork here, but we try and find a reasonable edge case where we sniff out
- * invalid DTCG syntax that a resolver doc would have.
- */
-export function isLikelyResolver(doc: momoa.DocumentNode): boolean {
-  if (doc.body.type !== 'Object') {
-    return false;
-  }
-  // This is a resolver if…
-  for (const member of doc.body.members) {
-    if (member.name.type !== 'String') {
-      continue;
-    }
-    switch (member.name.value) {
-      case 'name':
-      case 'description':
-      case 'version': {
-        // 1. name, description, or version are a string
-        if (member.value.type === 'String') {
-          return true;
-        }
-        break;
-      }
-      case 'sets':
-      case 'modifiers': {
-        if (member.value.type !== 'Object') {
-          continue;
-        }
-        // 2. sets.description or modifiers.description is a string
-        if (getObjMember(member.value, 'description')?.type === 'String') {
-          return true;
-        }
-        // 3. sets.sources is an array
-        if (member.name.value === 'sets' && getObjMember(member.value, 'sources')?.type === 'Array') {
-          return true;
-        } else if (member.name.value === 'modifiers') {
-          const contexts = getObjMember(member.value, 'contexts');
-          if (contexts?.type === 'Object' && contexts.members.some((m) => m.value.type === 'Array')) {
-            // 4. contexts[key] is an array
-            // (note: modifiers.contexts as an object is technically valid token format! We need to check for the array)
-            return true;
-          }
-        }
-        break;
-      }
-      case 'resolutionOrder': {
-        // 4. resolutionOrder is an array
-        if (member.value.type === 'Array') {
-          return true;
-        }
-        break;
-      }
-    }
-  }
-
-  return false;
-}
-
-export interface ValidateResolverOptions {
-  logger: Logger;
-  src: string;
-}
-
-const MESSAGE_EXPECTED = {
-  STRING: 'Expected string.',
-  OBJECT: 'Expected object.',
-  ARRAY: 'Expected array.',
-};
-
-/**
- * Validate a resolver document.
- * There’s a ton of boilerplate here, only to surface detailed code frames. Is there a better abstraction?
- */
-export function validateResolver(node: momoa.DocumentNode, { logger, src }: ValidateResolverOptions) {
-  const entry = { group: 'parser', label: 'resolver', src } as const;
-  if (node.body.type !== 'Object') {
-    logger.error({ ...entry, message: MESSAGE_EXPECTED.OBJECT, node });
-  }
-  const errors: LogEntry[] = [];
-
-  let hasVersion = false;
-  let hasResolutionOrder = false;
-
-  for (const member of (node.body as momoa.ObjectNode).members) {
-    if (member.name.type !== 'String') {
-      continue; // IDK, don’t ask
-    }
-
-    switch (member.name.value) {
-      case 'name':
-      case 'description': {
-        if (member.value.type !== 'String') {
-          errors.push({ ...entry, message: MESSAGE_EXPECTED.STRING });
-        }
-        break;
-      }
-
-      case 'version': {
-        hasVersion = true;
-        if (member.value.type !== 'String' || member.value.value !== '2025.10') {
-          errors.push({ ...entry, message: `Expected "version" to be "2025.10".`, node: member.value });
-        }
-        break;
-      }
-
-      case 'sets':
-      case 'modifiers': {
-        if (member.value.type !== 'Object') {
-          errors.push({ ...entry, message: MESSAGE_EXPECTED.OBJECT, node: member.value });
-        } else {
-          for (const item of member.value.members) {
-            if (item.value.type !== 'Object') {
-              errors.push({ ...entry, message: MESSAGE_EXPECTED.OBJECT, node: item.value });
-            } else {
-              const validator = member.name.value === 'sets' ? validateSet : validateModifier;
-              errors.push(...validator(item.value, false, { logger, src }));
-            }
-          }
-        }
-        break;
-      }
-
-      case 'resolutionOrder': {
-        hasResolutionOrder = true;
-        if (member.value.type !== 'Array') {
-          errors.push({ ...entry, message: MESSAGE_EXPECTED.ARRAY, node: member.value });
-        } else if (member.value.elements.length === 0) {
-          errors.push({ ...entry, message: `"resolutionOrder" can’t be empty array.`, node: member.value });
-        } else {
-          for (const item of member.value.elements) {
-            if (item.value.type !== 'Object') {
-              errors.push({ ...entry, message: MESSAGE_EXPECTED.OBJECT, node: item.value });
-            } else {
-              const itemMembers = getObjMembers(item.value);
-              if (itemMembers.$ref?.type === 'String') {
-                continue; // we can’t validate this just yet, assume it’s correct
-              }
-              // Validate "type"
-              if (itemMembers.type?.type === 'String') {
-                if (itemMembers.type.value === 'set') {
-                  validateSet(item.value, true, { logger, src });
-                } else if (itemMembers.type.value === 'modifier') {
-                  validateModifier(item.value, true, { logger, src });
-                } else {
-                  errors.push({
-                    ...entry,
-                    message: `Unknown type ${JSON.stringify(itemMembers.type.value)}`,
-                    node: itemMembers.type,
-                  });
-                }
-              }
-              // validate sets & modifiers if they’re missing "type"
-              if (itemMembers.sources?.type === 'Array') {
-                validateSet(item.value, true, { logger, src });
-              } else if (itemMembers.contexts?.type === 'Object') {
-                validateModifier(item.value, true, { logger, src });
-              } else if (itemMembers.name?.type === 'String' || itemMembers.description?.type === 'String') {
-                validateSet(item.value, true, { logger, src }); // if this has a "name" or "description", guess set
-              }
-            }
-          }
-        }
-        break;
-      }
-      case '$defs':
-      case '$extensions':
-        if (member.value.type !== 'Object') {
-          errors.push({ ...entry, message: `Expected object`, node: member.value });
-        }
-        break;
-      case '$schema':
-      case '$ref': {
-        if (member.value.type !== 'String') {
-          errors.push({ ...entry, message: `Expected string`, node: member.value });
-        }
-        break;
-      }
-      default: {
-        errors.push({ ...entry, message: `Unknown key ${JSON.stringify(member.name.value)}`, node: member.name, src });
-        break;
-      }
-    }
-  }
-
-  // handle required keys
-  if (!hasVersion) {
-    errors.push({ ...entry, message: `Missing "version".`, node, src });
-  }
-  if (!hasResolutionOrder) {
-    errors.push({ ...entry, message: `Missing "resolutionOrder".`, node, src });
-  }
-
-  if (errors.length) {
-    logger.error(...errors);
-  }
-}
-
-export function validateSet(node: momoa.ObjectNode, isInline = false, { src }: ValidateResolverOptions): LogEntry[] {
-  const entry = { group: 'parser', label: 'resolver', src } as const;
-  const errors: LogEntry[] = [];
-  let hasName = !isInline;
-  let hasType = !isInline;
-  let hasSources = false;
-  for (const member of node.members) {
-    if (member.name.type !== 'String') {
-      continue;
-    }
-    switch (member.name.value) {
-      case 'name': {
-        hasName = true;
-        if (member.value.type !== 'String') {
-          errors.push({ ...entry, message: MESSAGE_EXPECTED.STRING, node: member.value });
-        }
-        break;
-      }
-      case 'description': {
-        if (member.value.type !== 'String') {
-          errors.push({ ...entry, message: MESSAGE_EXPECTED.STRING, node: member.value });
-        }
-        break;
-      }
-      case 'type': {
-        hasType = true;
-        if (member.value.type !== 'String') {
-          errors.push({ ...entry, message: MESSAGE_EXPECTED.STRING, node: member.value });
-        } else if (member.value.value !== 'set') {
-          errors.push({ ...entry, message: '"type" must be "set".' });
-        }
-        break;
-      }
-      case 'sources': {
-        hasSources = true;
-        if (member.value.type !== 'Array') {
-          errors.push({ ...entry, message: MESSAGE_EXPECTED.ARRAY, node: member.value });
-        } else if (member.value.elements.length === 0) {
-          errors.push({ ...entry, message: `"sources" can’t be empty array.`, node: member.value });
-        }
-        break;
-      }
-      case '$defs':
-      case '$extensions':
-        if (member.value.type !== 'Object') {
-          errors.push({ ...entry, message: `Expected object`, node: member.value });
-        }
-        break;
-      case '$ref': {
-        if (member.value.type !== 'String') {
-          errors.push({ ...entry, message: `Expected string`, node: member.value });
-        }
-        break;
-      }
-      default: {
-        errors.push({ ...entry, message: `Unknown key ${JSON.stringify(member.name.value)}`, node: member.name });
-        break;
-      }
-    }
-  }
-
-  // handle required keys
-  if (!hasName) {
-    errors.push({ ...entry, message: `Missing "name".`, node });
-  }
-  if (!hasType) {
-    errors.push({ ...entry, message: `"type": "set" missing.`, node });
-  }
-  if (!hasSources) {
-    errors.push({ ...entry, message: `Missing "sources".`, node });
-  }
-
-  return errors;
-}
-
-export function validateModifier(
-  node: momoa.ObjectNode,
-  isInline = false,
-  { src }: ValidateResolverOptions,
-): LogEntry[] {
-  const errors: LogEntry[] = [];
-  const entry = { group: 'parser', label: 'resolver', src } as const;
-  let hasName = !isInline;
-  let hasType = !isInline;
-  let hasContexts = false;
-  for (const member of node.members) {
-    if (member.name.type !== 'String') {
-      continue;
-    }
-    switch (member.name.value) {
-      case 'name': {
-        hasName = true;
-        if (member.value.type !== 'String') {
-          errors.push({ ...entry, message: MESSAGE_EXPECTED.STRING, node: member.value });
-        }
-        break;
-      }
-      case 'description': {
-        if (member.value.type !== 'String') {
-          errors.push({ ...entry, message: MESSAGE_EXPECTED.STRING, node: member.value });
-        }
-        break;
-      }
-      case 'type': {
-        hasType = true;
-        if (member.value.type !== 'String') {
-          errors.push({ ...entry, message: MESSAGE_EXPECTED.STRING, node: member.value });
-        } else if (member.value.value !== 'modifier') {
-          errors.push({ ...entry, message: '"type" must be "modifier".' });
-        }
-        break;
-      }
-      case 'contexts': {
-        hasContexts = true;
-        if (member.value.type !== 'Object') {
-          errors.push({ ...entry, message: MESSAGE_EXPECTED.OBJECT, node: member.value });
-        } else if (member.value.members.length === 0) {
-          errors.push({ ...entry, message: `"contexts" can’t be empty object.`, node: member.value });
-        } else {
-          for (const context of member.value.members) {
-            if (context.value.type !== 'Array') {
-              errors.push({ ...entry, message: MESSAGE_EXPECTED.ARRAY, node: context.value });
-            }
-          }
-        }
-        break;
-      }
-      case 'default': {
-        if (member.value.type !== 'String') {
-          errors.push({ ...entry, message: `Expected string`, node: member.value });
-        } else {
-          const contexts = getObjMember(node, 'contexts') as momoa.ObjectNode | undefined;
-          if (!contexts || !getObjMember(contexts, member.value.value)) {
-            errors.push({ ...entry, message: 'Invalid default context', node: member.value });
-          }
-        }
-        break;
-      }
-      case '$defs':
-      case '$extensions':
-        if (member.value.type !== 'Object') {
-          errors.push({ ...entry, message: `Expected object`, node: member.value });
-        }
-        break;
-      case '$ref': {
-        if (member.value.type !== 'String') {
-          errors.push({ ...entry, message: `Expected string`, node: member.value });
-        }
-        break;
-      }
-      default: {
-        errors.push({ ...entry, message: `Unknown key ${JSON.stringify(member.name.value)}`, node: member.name });
-        break;
-      }
-    }
-  }
-
-  // handle required keys
-  if (!hasName) {
-    errors.push({ ...entry, message: `Missing "name".`, node });
-  }
-  if (!hasType) {
-    errors.push({ ...entry, message: `"type": "modifier" missing.`, node });
-  }
-  if (!hasContexts) {
-    errors.push({ ...entry, message: `Missing "contexts".`, node });
-  }
-
-  return errors;
-}