Woordzoeker maken | Gratis online woordzoeker maker

(function(){
'use strict';
try{
/*
 * Klasklaar Word Search Engine
 * Pure puzzle logic: no DOM dependencies.
 */

const WS = (() => {
  const MIN_GRID_SIZE = 6;
  const MAX_GRID_SIZE = 25;
  const DEFAULT_MAX_NODES = 120000;
  const DEFAULT_ATTEMPTS = 18;

const DIRECTIONS = Object.freeze({
    R:  { key:'R',  dr:0,  dc:1,  family:'H',  label:'→' },
    L:  { key:'L',  dr:0,  dc:-1, family:'H',  label:'←' },
    D:  { key:'D',  dr:1,  dc:0,  family:'V',  label:'↓' },
    U:  { key:'U',  dr:-1, dc:0,  family:'V',  label:'↑' },
    DR: { key:'DR', dr:1,  dc:1,  family:'D1', label:'↘' },
    UL: { key:'UL', dr:-1, dc:-1, family:'D1', label:'↖' },
    DL: { key:'DL', dr:1,  dc:-1, family:'D2', label:'↙' },
    UR: { key:'UR', dr:-1, dc:1,  family:'D2', label:'↗' }
  });

const LEVELS = Object.freeze({
    easy:   ['R','D'],
    normal: ['R','D','DR','DL'],
    hard:   ['R','L','D','U','DR','UL','DL','UR']
  });

const ERROR = Object.freeze({
    NO_WORDS: 'NO_WORDS',
    DUPLICATE_WORD: 'DUPLICATE_WORD',
    SUBSTRING_WORD: 'SUBSTRING_WORD',
    INVALID_CHARACTERS: 'INVALID_CHARACTERS',
    WORD_TOO_LONG: 'WORD_TOO_LONG',
    ANSWER_TOO_LONG: 'ANSWER_TOO_LONG',
    GRID_TOO_SMALL: 'GRID_TOO_SMALL',
    ANSWER_GRID_TOO_LARGE: 'ANSWER_GRID_TOO_LARGE',
    ANSWER_TOO_MANY_CROSSINGS: 'ANSWER_TOO_MANY_CROSSINGS',
    SEARCH_EXHAUSTED: 'SEARCH_EXHAUSTED',
    FINAL_VALIDATION_FAILED: 'FINAL_VALIDATION_FAILED'
  });

function normalizeSpaces(s) {
    return String(s ?? '').normalize('NFC').trim().replace(/\s+/g, ' ');
  }

function graphemes(s) {
    return Array.from(String(s));
  }

function reverseString(s) {
    return graphemes(s).reverse().join('');
  }

function normalizeWord(raw, id) {
    const { display, grid } = normalizeGridText(raw);
    return {
      id,
      raw: String(raw ?? ''),
      displayText: display,
      gridText: grid,
      letters: graphemes(grid),
      length: graphemes(grid).length
    };
  }

function normalizeWords(rawWords) {
    const arr = Array.isArray(rawWords) ? rawWords : String(rawWords ?? '').split(/\r?\n/);
    const out = [];
    for (const raw of arr) {
      const w = normalizeWord(raw, out.length);
      if (w.gridText) out.push(w);
    }
    return out;
  }

function validateInput(rawWords, options={}) {
    const words = normalizeWords(rawWords);
    const answer = normalizeAnswer(options.answer || '');
    const size = Number(options.size || 12);
    const errors = [];
    const warnings = [];

if (!words.length) errors.push({ code:ERROR.NO_WORDS });

// Substring conflict: a shorter target is already physically present inside a longer target.
    for (let i=0;i<words.length;i++) {
      for (let j=i+1;j<words.length;j++) {
        const a = words[i], b = words[j];
        const [shorter,longer] = a.length <= b.length ? [a,b] : [b,a];
        if (shorter.gridText && (longer.gridText.includes(shorter.gridText) || longer.gridText.includes(reverseString(shorter.gridText)))) {
          errors.push({ code:ERROR.SUBSTRING_WORD, word:shorter.displayText, other:longer.displayText });
        }
      }
    }

if (Number.isFinite(size)) {
      for (const w of words) {
        if (w.length > size) errors.push({ code:ERROR.WORD_TOO_LONG, word:w.displayText, length:w.length, size });
      }
    }

return { valid:errors.length===0, errors, warnings, words, answer };
  }

function createRng(seed) {
    let a = (Number(seed) >>> 0) || 0x12345678;
    return function rng() {
      // mulberry32
      a |= 0; a = a + 0x6D2B79F5 | 0;
      let t = Math.imul(a ^ a >>> 15, 1 | a);
      t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
      return ((t ^ t >>> 14) >>> 0) / 4294967296;
    };
  }

function hashSeed(input) {
    let h = 2166136261 >>> 0;
    for (const ch of String(input)) {
      h ^= ch.codePointAt(0);
      h = Math.imul(h, 16777619);
    }
    return h >>> 0;
  }

function indexOfCell(row,col,size) { return row*size + col; }
  function rowOf(index,size) { return Math.floor(index/size); }
  function colOf(index,size) { return index % size; }

function createBoard(size) {
    const n = size*size;
    return {
      size,
      chars: new Array(n).fill(null),
      owner1: new Int32Array(n).fill(-1),
      owner2: new Int32Array(n).fill(-1),
      placed: new Map(),
      occupied: 0,
      crossings: 0,
      directionCounts: {H:0,V:0,D1:0,D2:0},
      rowUsage: new Int16Array(size),
      colUsage: new Int16Array(size),
    };
  }

function placementCells(word, startRow, startCol, dir, size) {
    const cells = [];
    for (let i=0;i<word.length;i++) {
      const r = startRow + dir.dr*i;
      const c = startCol + dir.dc*i;
      if (r<0 || r>=size || c<0 || c>=size) return null;
      cells.push(indexOfCell(r,c,size));
    }
    return cells;
  }

function sharedLetters(a,b) {
    const set = new Set(a.letters);
    const common = new Set();
    for (const ch of b.letters) if (set.has(ch)) common.add(ch);
    return common;
  }

function checkPlacement(board, placement, word, targetCrossings=null, targetOccupied=null) {
    const touchedOwners = new Set();
    let newCrossings = 0;
    let newCells = 0;

for (let i=0;i<placement.cells.length;i++) {
      const idx = placement.cells[i];
      const ch = word.letters[i];
      const existing = board.chars[idx];
      if (existing === null) {
        newCells++;
        continue;
      }
      if (existing !== ch) return { allowed:false, reason:'LETTER_CONFLICT' };
      if (board.owner2[idx] !== -1) return { allowed:false, reason:'THIRD_WORD_IN_CELL' };
      const owner = board.owner1[idx];
      if (owner === -1) return { allowed:false, reason:'CORRUPT_BOARD' };
      const existingPlacement = board.placed.get(owner);
      if (!existingPlacement) return { allowed:false, reason:'CORRUPT_BOARD' };
      if (existingPlacement.family === placement.family) return { allowed:false, reason:'PARALLEL_OVERLAP' };
      if (touchedOwners.has(owner)) return { allowed:false, reason:'MULTI_CELL_OVERLAP' };
      touchedOwners.add(owner);
      newCrossings++;
    }

if (targetCrossings !== null && board.crossings + newCrossings > targetCrossings) {
      return { allowed:false, reason:'TOO_MANY_CROSSINGS' };
    }
    if (targetOccupied !== null && board.occupied + newCells > targetOccupied) {
      return { allowed:false, reason:'TOO_MANY_OCCUPIED' };
    }
    return { allowed:true, newCrossings, newCells, touchedOwners };
  }

function scorePlacement(board, placement, check, rng, answerMode=false, targetCrossings=0) {
    const size = board.size;
    let score = 0;

// Prefer under-used direction families.
    score -= board.directionCounts[placement.family] * 5;

// Prefer cells in less used rows/columns.
    let usagePenalty = 0;
    let edgeTouches = 0;
    let centerDist = 0;
    const center = (size-1)/2;
    for (const idx of placement.cells) {
      const r=rowOf(idx,size), c=colOf(idx,size);
      usagePenalty += board.rowUsage[r] + board.colUsage[c];
      if (r===0||c===0||r===size-1||c===size-1) edgeTouches++;
      centerDist += Math.abs(r-center)+Math.abs(c-center);
    }
    score -= usagePenalty * 0.55;
    score += edgeTouches * 0.7; // some edge use helps spread
    score += centerDist * 0.02;

if (answerMode) {
      const remainingNeed = targetCrossings - board.crossings;
      // Reward crossings when we still need them, otherwise neutral.
      score += Math.min(check.newCrossings, remainingNeed) * 10;
    } else {
      score += check.newCrossings * 2.2;
    }

score += rng()*3;
    return score;
  }

function solveAttempt(words, size, directionKeys, options={}) {
    const seed = options.seed ?? 1;
    const rng = createRng(seed);
    const answer = options.answer || normalizeAnswer('');
    const answerMode = !!(answer && answer.length);
    const feasibility = answerMode ? answerFeasibility(words,answer,size) : normalFeasibility(words,size);
    if (feasibility.status==='IMPOSSIBLE') return {ok:false, type:'PROVEN_IMPOSSIBLE', error:feasibility};

const placementsByWord = {};
    for (const w of words) placementsByWord[w.id] = createPlacements(w,size,directionKeys);
    const compatibilityMatrix = crossingCompatibility(words).matrix;
    const board = createBoard(size);
    const maxNodes = options.maxNodes || DEFAULT_MAX_NODES;
    const targetCrossings = answerMode ? feasibility.C : null;
    const targetOccupied = answerMode ? feasibility.targetOccupied : null;
    let nodes = 0;
    let backtracks = 0;

function recurse(remainingWords) {
      nodes++;
      if (nodes > maxNodes) return false;
      if (remainingWords.length===0) {
        if (answerMode) {
          return board.crossings===targetCrossings && board.occupied===targetOccupied;
        }
        return true;
      }

if (answerMode) {
        if (board.crossings > targetCrossings || board.occupied > targetOccupied) return false;
        const remainingLetters = remainingWords.reduce((s,w)=>s+w.length,0);
        // Maximum unique occupancy if every remaining letter goes into an empty cell.
        if (board.occupied + remainingLetters < targetOccupied) return false;
        // Minimum unique occupancy assuming each remaining word could cross each of its letters is too weak; crossing bound helps.
        const needCross = targetCrossings - board.crossings;
        if (needCross < 0) return false;
        const upperCross = remainingCrossingUpperBound(board,remainingWords,compatibilityMatrix);
        if (needCross > upperCross) return false;
      }

const choice = chooseNextWord(board,remainingWords,placementsByWord,{targetCrossings,targetOccupied},rng);
      if (!choice || choice.legal.length===0) return false;

const scored = choice.legal.map(item=>({
        ...item,
        score:scorePlacement(board,item.p,item.check,rng,answerMode,targetCrossings||0)
      })).sort((a,b)=>b.score-a.score);

const nextRemaining = remainingWords.filter(w=>w.id!==choice.word.id);
      for (const item of scored) {
        const undo = applyPlacement(board,item.p,choice.word,item.check);
        if (recurse(nextRemaining)) return true;
        undoPlacement(board,undo);
        backtracks++;
      }
      return false;
    }

const initial = words.slice().sort((a,b)=>b.length-a.length);
    const ok = recurse(initial);
    if (!ok) return {ok:false,type:'SEARCH_EXHAUSTED',stats:{nodes,backtracks}, feasibility};

return {
      ok:true,
      board,
      stats:{nodes,backtracks},
      feasibility,
      placements:Array.from(board.placed.entries()).sort((a,b)=>a[0]-b[0]).map(([wordId,p])=>({...p,wordId}))
    };
  }

// Dutch-ish letter frequencies. Approximate, enough for natural-looking filler.
  const LETTER_BAG = [
    ['E',19],['N',10],['A',8],['T',7],['I',7],['R',6],['O',6],['D',6],['S',4],['L',4],['G',3],['V',3],['K',3],['M',2.5],['U',2.2],['B',1.7],['P',1.6],['H',1.5],['J',1.4],['Z',1.3],['W',1.2],['F',0.8],['C',0.7],['X',0.1],['Y',0.1],['Q',0.05]
  ];
  const LETTER_TOTAL = LETTER_BAG.reduce((s,[,w])=>s+w,0);

function randomDutchLetter(rng) {
    let x = rng()*LETTER_TOTAL;
    for (const [ch,w] of LETTER_BAG) {
      x -= w;
      if (x<=0) return ch;
    }
    return 'E';
  }

function allDirectionKeys() { return Object.keys(DIRECTIONS); }

function canonicalOccurrence(cells) {
    const a = cells.join(',');
    const b = cells.slice().reverse().join(',');
    return a < b ? a : b;
  }

function fillRandomCells(chars,size,words,rng,maxPasses=40) {
    const empty=[];
    for (let i=0;i<chars.length;i++) if (chars[i]===null) empty.push(i);
    for (const idx of empty) chars[idx]=randomDutchLetter(rng);

// Repair accidental duplicates using only filler cells.
    const fillerSet = new Set(empty);
    for (let pass=0;pass<maxPasses;pass++) {
      let conflict=null;
      for (const w of words) {
        const occ = findOccurrences(chars,size,w.gridText);
        if (occ.length>1) {
          // Intended placement is unknown here; choose any occurrence containing filler as repair target.
          const repairable = occ.find(cells=>cells.some(i=>fillerSet.has(i)));
          if (repairable) { conflict={w,cells:repairable}; break; }
          return {ok:false, reason:'UNREPAIRABLE_EXTRA_OCCURRENCE'};
        }
      }
      if (!conflict) return {ok:true};
      const candidates=conflict.cells.filter(i=>fillerSet.has(i));
      if (!candidates.length) return {ok:false,reason:'UNREPAIRABLE_EXTRA_OCCURRENCE'};
      const idx=candidates[Math.floor(rng()*candidates.length)];
      const old=chars[idx];
      let changed=false;
      for (let tries=0;tries<12;tries++) {
        const ch=randomDutchLetter(rng);
        if (ch===old) continue;
        chars[idx]=ch;
        changed=true;
        break;
      }
      if (!changed) chars[idx]=old==='E'?'A':'E';
    }
    return {ok:false,reason:'REPAIR_LIMIT'};
  }

function samePhysicalOccurrence(a,b) {
    return canonicalOccurrence(a)===canonicalOccurrence(b);
  }

function validateFinalPuzzle(result) {
    const {size,chars,words,placements,answer,answerCells} = result;
    const errors=[];
    if (!Array.isArray(chars) || chars.length!==size*size || chars.some(ch=>!ch)) errors.push('GRID_NOT_FULL');

for (let i=0;i<owners.length;i++) {
      if (owners[i].length>2) errors.push(`TOO_MANY_OWNERS:${i}`);
      if (owners[i].length===2 && owners[i][0].family===owners[i][1].family) errors.push(`PARALLEL_OVERLAP:${i}`);
    }

for (let i=0;i<words.length;i++) {
      for (let j=i+1;j<words.length;j++) {
        let shared=0;
        const pi=placementById.get(words[i].id), pj=placementById.get(words[j].id);
        if (!pi||!pj) continue;
        const set=new Set(pi.cells);
        for (const cell of pj.cells) if (set.has(cell)) shared++;
        if (shared>1) errors.push(`MULTI_CELL_OVERLAP:${words[i].id}:${words[j].id}`);
      }
    }

// Every search word should have exactly one physical occurrence in whole grid.
    for (const w of words) {
      const occ=findOccurrences(chars,size,w.gridText);
      if (occ.length!==1) errors.push(`OCCURRENCE_COUNT:${w.id}:${occ.length}`);
      else {
        const p=placementById.get(w.id);
        if (p && !samePhysicalOccurrence(occ[0],p.cells)) errors.push(`WRONG_OCCURRENCE:${w.id}`);
      }
    }

if (answer && answer.length) {
      const unowned=[];
      for (let i=0;i<owners.length;i++) if (owners[i].length===0) unowned.push(i);
      if (unowned.length!==answer.length) errors.push(`ANSWER_COUNT:${unowned.length}:${answer.length}`);
      const letters=unowned.map(i=>chars[i]).join('');
      if (letters!==answer.gridText) errors.push(`ANSWER_TEXT:${letters}:${answer.gridText}`);
      if (answerCells && answerCells.join(',')!==unowned.join(',')) errors.push('ANSWER_CELLS_ORDER');
    }

return {valid:errors.length===0,errors};
  }

function qualityScore(result) {
    const {size,placements,board,answerCells=[]}=result;
    let score=100;
    const fam={H:0,V:0,D1:0,D2:0};
    for (const p of placements) fam[p.family]++;
    const counts=Object.values(fam);
    const avg=counts.reduce((a,b)=>a+b,0)/counts.length;
    score -= counts.reduce((s,x)=>s+Math.abs(x-avg),0)*1.5;

// Quadrant balance based on word centers.
    const q=[0,0,0,0];
    for (const p of placements) {
      const centerIdx=p.cells[Math.floor((p.cells.length-1)/2)];
      const r=rowOf(centerIdx,size), c=colOf(centerIdx,size);
      const qi=(r>=size/2?2:0)+(c>=size/2?1:0);
      q[qi]++;
    }
    const qavg=placements.length/4;
    score -= q.reduce((s,x)=>s+Math.abs(x-qavg),0)*1.2;

if (answerCells.length) {
      // Encourage answer letters not all clumped: reward bounding box area.
      const rows=answerCells.map(i=>rowOf(i,size)), cols=answerCells.map(i=>colOf(i,size));
      if (rows.length) {
        const area=(Math.max(...rows)-Math.min(...rows)+1)*(Math.max(...cols)-Math.min(...cols)+1);
        score += Math.min(20,area/(size*size)*20);
      }
    }
    score -= (result.stats?.backtracks||0)/5000;
    return score;
  }

const result={
      ok:true,
      size:attempt.board.size,
      chars,
      words,
      placements:attempt.placements,
      answer,
      answerCells,
      seed,
      stats:attempt.stats,
      board:attempt.board,
      feasibility:attempt.feasibility
    };
    const validation=validateFinalPuzzle(result);
    if (!validation.valid) return {ok:false,type:'FINAL_VALIDATION_FAILED',error:validation};
    result.validation=validation;
    result.qualityScore=qualityScore(result);
    return result;
  }

const answerMode=answer.length>0;
    const feas=answerMode?answerFeasibility(words,answer,size):normalFeasibility(words,size);
    if (feas.status==='IMPOSSIBLE') return {ok:false,type:'PROVEN_IMPOSSIBLE',error:feas,validation};

const baseSeed=(options.seed ?? hashSeed(words.map(w=>w.gridText).join('|')+'|'+answer.gridText+'|'+size+'|'+level))>>>0;
    const attempts=Math.max(1,Number(options.attempts||DEFAULT_ATTEMPTS));
    const maxNodes=Number(options.maxNodes||DEFAULT_MAX_NODES);
    let best=null;
    const failures=[];

for (let i=0;i<attempts;i++) {
      const seed=(baseSeed + Math.imul(i+1,0x9E3779B1))>>>0;
      const attempt=solveAttempt(words,size,directionKeys,{answer,seed,maxNodes});
      if (!attempt.ok) { failures.push(attempt); continue; }
      const result=buildResultFromAttempt(attempt,words,answer,seed);
      if (!result.ok) { failures.push(result); continue; }
      if (!best || result.qualityScore>best.qualityScore) best=result;
    }

if (best) return best;
    const proven=failures.find(f=>f.type==='PROVEN_IMPOSSIBLE');
    if (proven) return proven;
    return {ok:false,type:'SEARCH_EXHAUSTED',failures,validation};
  }

return {
    MIN_GRID_SIZE,MAX_GRID_SIZE,DIRECTIONS,LEVELS,ERROR,
    normalizeWord,normalizeWords,normalizeAnswer,validateInput,
    answerFeasibility,normalFeasibility,getFeasibleSizes,pickRecommendedSize,
    createPlacements,createBoard,checkPlacement,applyPlacement,undoPlacement,
    findOccurrences,validateFinalPuzzle,generatePuzzle,userMessageFor,
    createRng,hashSeed,indexOfCell,rowOf,colOf,reverseString
  };
})();

'use strict';
  const root=document.getElementById('kkws-wordsearch-root');
  if(!root || root.dataset.kkwsInitialized==='1') return;
  root.dataset.kkwsInitialized='1';
  const $=id=>root.querySelector('#kkws-'+id);
  const els={
    title:$('titleInput'), words:$('wordsInput'), count:$('wordCount'), size:$('sizeRange'), sizeValue:$('sizeValue'), auto:$('autoSize'),
    status:$('statusBox'), answerEnabled:$('answerEnabled'), answerBox:$('answerBox'), answer:$('answerInput'),
    showName:$('showName'),showDate:$('showDate'),showGroup:$('showGroup'),includeSolution:$('includeSolution'),
    gridLines:$('showGridLines'),lowercase:$('lowercaseLetters'),newVersion:$('newVersionBtn'),print:$('printBtn'),
    stage:$('sheetStage'),meta:$('previewMeta'),directionGrid:$('directionGrid'),printRoot:$('printRoot')
  };

const state={
    level:'normal', seed:(Date.now()>>>0), activeTab:'student', generationId:0, result:null, debounce:null
  };

function slimResult(r){
    if(!r || !r.ok) return r;
    return {
      ok:true,
      size:r.size,
      chars:r.chars,
      words:r.words,
      placements:r.placements,
      answer:r.answer,
      answerCells:r.answerCells,
      seed:r.seed,
      stats:r.stats,
      qualityScore:r.qualityScore,
      feasibility:r.feasibility
    };
  }

function startGeneration(){
    if(!immediateCheck()){
      state.result=null;
      renderPreview();
      return;
    }

const id=++state.generationId;
    const words=currentWords();
    const opt={
      size:Number(els.size.value),
      auto:els.auto.checked,
      level:state.level,
      directionKeys:directionKeys(),
      answer:answerText(),
      seed:state.seed
    };
    const sizes=generationSizes(words,opt);
    const maxSizes=opt.answer?6:5;
    const queue=sizes.slice(0,maxSizes);
    let last=null;
    let pos=0;

if(!queue.length){
      handleResult({ok:false,type:'PROVEN_IMPOSSIBLE',error:{code:'ANSWER_GRID_TOO_LARGE'}});
      return;
    }

function tryNext(){
      if(id!==state.generationId) return;
      if(pos>=queue.length){
        handleResult(last||{ok:false,type:'SEARCH_EXHAUSTED'});
        return;
      }
      const size=queue[pos++];
      setStatus('info','Woordzoeker maken',size+' × '+size+' wordt geprobeerd…',true);

// Give the browser a paint moment before the synchronous solver runs.
      setTimeout(()=>{
        if(id!==state.generationId) return;
        let r;
        try{
          r=WS.generatePuzzle(words,{
            size,
            level:opt.level,
            directionKeys:opt.directionKeys,
            answer:opt.answer,
            seed:opt.seed,
            attempts:opt.answer?3:5,
            maxNodes:opt.answer?18000:22000
          });
        }catch(err){
          r={ok:false,type:'ENGINE_ERROR',message:String(err&&err.message||err)};
        }
        if(id!==state.generationId) return;
        if(r&&r.ok){
          handleResult(slimResult(r));
          return;
        }
        last=r;
        setTimeout(tryNext,0);
      },0);
    }

tryNext();
  }

function scheduleGeneration(ms=340){clearTimeout(state.debounce);state.debounce=setTimeout(startGeneration,ms);}

function renderPrintRoot(){
    if(!state.result){els.printRoot.innerHTML='';return;}
    els.printRoot.innerHTML=sheetHtml(state.result,false)+(els.includeSolution.checked?sheetHtml(state.result,true):'');
  }

function rerenderOnly(){if(state.result){renderPreview();}else renderPrintRoot();}

// Events
  els.title.addEventListener('input',rerenderOnly);
  els.words.addEventListener('input',()=>scheduleGeneration());
  els.answerEnabled.addEventListener('change',()=>{els.answerBox.classList.toggle('show',els.answerEnabled.checked);scheduleGeneration(100)});
  els.answer.addEventListener('input',()=>scheduleGeneration());
  els.auto.addEventListener('change',()=>scheduleGeneration(80));
  els.size.addEventListener('input',()=>{els.auto.checked=false;updateSizeLabel();immediateCheck();clearTimeout(state.debounce)});
  els.size.addEventListener('change',()=>scheduleGeneration(50));
  root.querySelectorAll('.level').forEach(btn=>btn.addEventListener('click',()=>{setLevel(btn.dataset.level);scheduleGeneration(80)}));
  els.directionGrid.addEventListener('change',()=>{state.level='custom';root.querySelectorAll('.level').forEach(b=>b.classList.remove('active'));scheduleGeneration(80)});
  [els.showName,els.showDate,els.showGroup,els.includeSolution,els.gridLines,els.lowercase].forEach(el=>el.addEventListener('change',rerenderOnly));
  els.newVersion.addEventListener('click',()=>{state.seed=(state.seed+0x9E3779B9)>>>0;scheduleGeneration(10)});
  function printWorksheet(){
    renderPrintRoot();
    if(!state.result)return;

// Print in a separate document. This keeps JouwWeb advertisements, page headers
    // and other host-page elements completely outside the print context.
    const sourceStyle=document.getElementById('kkws-wordsearch-style');
    const printWindow=window.open('','_blank','width=900,height=900');
    if(!printWindow){
      alert('De printpagina kon niet worden geopend. Sta pop-ups voor Klasklaar toe en probeer het opnieuw.');
      return;
    }

printWindow.document.open();
    printWindow.document.write('<meta charset="utf-8"><title>Woordzoeker - Klasklaar</title><style>'+printCss+'</style><div id="kkws-print-sandbox" class="kkws-doc"></div>');
    printWindow.document.close();
    printWindow.document.getElementById('kkws-print-sandbox').innerHTML=els.printRoot.innerHTML;

updateCount();updateSizeLabel();els.answerBox.classList.toggle('show',els.answerEnabled.checked);scheduleGeneration(60);
}catch(err){
  const root=document.getElementById('kkws-wordsearch-root');
  const status=root&&root.querySelector('#kkws-statusBox');
  const stage=root&&root.querySelector('#kkws-sheetStage');
  if(status){
    status.className='status error';
    status.innerHTML='<strong>De woordzoekermaker kon niet starten</strong><span>Ververs de pagina. Blijft dit gebeuren, controleer dan of aangepaste JavaScript-code is toegestaan.</span>';
  }
  if(stage){
    stage.innerHTML='<div class="empty-preview"><div><strong>De preview kon niet worden gestart</strong>De puzzelcode is door de pagina geblokkeerd.</div></div>';
  }
  if(typeof console!=='undefined'&&console.error) console.error('Klasklaar woordzoekermaker:',err);
}
})();