/**

 * @typedef {{ path: string, message: string, keyword: string }} ValidationError

 */



function validate(data, schema, path, rootSchema) {

  path = path || '';

  rootSchema = rootSchema || schema;



  if (schema === true) return [];

  if (schema === false) return [{ path, message: 'Schema is false', keyword: 'false schema' }];



  const errors = [];



  // $ref short-circuits all other keywords (Draft-07 spec)

  if (schema.$ref) {

    const resolved = resolveRef(schema.$ref, rootSchema);

    if (resolved) return validate(data, resolved, path, rootSchema);

    return [{ path, message: `Cannot resolve $ref "${schema.$ref}"`, keyword: '$ref' }];

  }



  // Type check first — no point checking string keywords on a number

  if (schema.type !== undefined && !typeMatches(data, schema.type)) {

    const expected = Array.isArray(schema.type) ? schema.type.join(' | ') : schema.type;

    return [{ path, message: `Expected "${expected}" but got "${getType(data)}"`, keyword: 'type' }];

  }



  if (typeof data === 'string') errors.push(...validateString(data, schema, path));

  if (typeof data === 'number') errors.push(...validateNumber(data, schema, path));

  if (Array.isArray(data))     errors.push(...validateArray(data, schema, path, rootSchema));

  if (isPlainObject(data))     errors.push(...validateObject(data, schema, path, rootSchema));



  // Combiners

  if (schema.allOf) schema.allOf.forEach(s => errors.push(...validate(data, s, path, rootSchema)));

  if (schema.anyOf && !schema.anyOf.some(s => validate(data, s, path, rootSchema).length === 0))

    errors.push({ path, message: 'Does not match any schema in "anyOf"', keyword: 'anyOf' });

  // ...oneOf, not, if/then/else similarly



  return errors;

}

function validateNumber(val, schema, path) {

  const errors = [];



  if (typeof schema.minimum === 'number') {

    if (schema.exclusiveMinimum === true) {

      // Draft-04 style

      if (val <= schema.minimum)

        errors.push({ path, message: `${val} must be > ${schema.minimum}`, keyword: 'exclusiveMinimum' });

    } else {

      if (val < schema.minimum)

        errors.push({ path, message: `${val} must be >= ${schema.minimum}`, keyword: 'minimum' });

    }

  }



  // Draft-06/07 style: exclusiveMinimum as a number

  if (typeof schema.exclusiveMinimum === 'number') {

    if (val <= schema.exclusiveMinimum)

      errors.push({ path, message: `${val} must be > ${schema.exclusiveMinimum}`, keyword: 'exclusiveMinimum' });

  }



  // ... same pattern for maximum / exclusiveMaximum



  return errors;

}

function resolveRef(ref, rootSchema) {

  if (!ref.startsWith('#')) return null;  // external refs not supported

  const fragment = ref.slice(1);

  if (fragment === '' || fragment === '/') return rootSchema;  // bare # → root

  const parts = fragment.slice(1)

    .split('/')

    .map(p => p.replace(/~1/g, '/').replace(/~0/g, '~'));  // JSON Pointer unescaping

  let cur = rootSchema;

  for (const part of parts) {

    if (cur === null || typeof cur !== 'object') return null;

    cur = cur[part];

  }

  return cur !== undefined ? cur : null;

}

if (schema.if !== undefined) {

  const ifErrors = validate(data, schema.if, path, rootSchema);

  if (ifErrors.length === 0) {

    // condition passed → apply then

    if (schema.then !== undefined)

      errors.push(...validate(data, schema.then, path, rootSchema));

  } else {

    // condition failed → apply else

    if (schema.else !== undefined)

      errors.push(...validate(data, schema.else, path, rootSchema));

  }

}

const vm = require('vm');

const modObj = { exports: {} };

vm.runInContext(extractedScript, vm.createContext({

  module: modObj, exports: modObj.exports,

  window: { addEventListener: () => {} },

  document: { getElementById: () => ({}), querySelectorAll: () => [], addEventListener: () => {} },

  Date, JSON, RegExp, Number, Math, Array, Object, String, Boolean, console

}));



const { validate, getType, typeMatches, isValidEmail, ... } = modObj.exports;