adult content

documentation technical

education learning

corporate business

healthcare medical

English

You're looking at domain 'jonathanolson.net' on the network infrastructure generic top-level domain (.net). The core label 'jonathanolson' covers 13 characters containing five vowels alongside 8 consonants. Breaking it apart gives two words: jonathan, olson. Average segment length settles at 6.5 characters. No strong language cues emerged from the frequency lists.

html/a6/04/a60415f5-3d81-4a01-bb47-ab16e1efafc2.html.gz

f284353a7cc4d97f6fe20a5155131bd43587a0f1c98a56eeaf52cff72910f47d

4180559f4d7397b4d7c8993d7e5caf8a23eb3e31970baf225086f7b30232e28d

6d7d1677d55ce3d2293bf57310f3f1420195ef48357cd64c69632d30cb92dc3b

ab3479692e76b2bc97e80362ea66fa7eae3aecc0b659fc9b50627240c9b1e5a6

e02d2d7a98aa7b84dfe81f7b840af8815666d2aec4a2411c45fcacd4c2723411

1f4165ca0f293e4a2c1161be458a8023089489849f2aebc50cbc50d9ca0102e6

aac3c8904bc91cfde6aaccf74dbd7f7454af2a6fd7e541f1e7473d1d9ccbdb59

8094a83728179457792e480efcc8d178d59ec870bcc05e84d2ba66220cd41f8c

68ed3c0671d6edca8170ce1ef1d152a94b1f36dd8431b4d290993b4a5ecc9866

1074b0f11e0b63e5a62e8ca7e62c0c1ad4bbe88a6f3d52ef36c3b191837736ad

efb89787e4fe857b0209ea6a2eb0f1fcf460ba051870a58a1403b00106569e45

491101b641c3a264713b2e3dbfc25aafe80ee347677b10f7106a9ff49fa3326d

cbf5c96bfc23f8df4d1073a8a41bd9b8ed3f5884d5c77e55c5313a9ccaea1615

d17ee51e255a7c18d50ff926b123514458f6e7668435a2d27468eeb8048562a3

efc247e68983e5dfc577ba97805546b9f5a6486e262a16b1cb955b1bda24a401

ef09e392e287aaa41ea20116b4c91944800a4d246e5db08a8e868a1489f96aca

d76c113520742b547ac4e7e44d6e44adf735d0c916816989f565067ce78708e9

b5b629ceb5ff3b6eee132a417ba935baeda1c1bd8a7020e5e535bbe07c0201b4

2b01ec347821cdafd736c9d081c5b55869f21329775716dcbd4d04e2a2ed3583

8bb8c8af3b05599cd5f33fb8bfe09a13dc20862dba16c235512c9b5e31b932f7

e9cd86223b77bd5b6a61cb94e3a489234d223f5645a13f59e4db1e2a4ab872e5

65b4a39b80c1aa7c216eea377c09b856fd3663f317c327a2b31c76ed0b6be17f

viewport

NameCheap, Inc.

JONATHANOLSON.NET

Abuse

Admin

Cloudflare-NOC

Cloudflare, Inc.

CLOUDFLARENET

// import scenery from '../chipper/dist/js/scenery/js/main.js';
 // import dot from '../chipper/dist/js/dot/js/main.js';
 // import axon from '../chipper/dist/js/axon/js/main.js';
 // import phetCore from '../chipper/dist/js/phet-core/js/main.js';

 import totalTraceTree from './data/trace.tree.total.js';
 import totalSlateTree from './data/slate.tree.total.js';
 import totalCrateTree from './data/crate.tree.total.js';
 import totalCraneTree from './data/crane.tree.total.js';
 import totalReastTree from './data/reast.tree.total.js';
 import totalSaletTree from './data/salet.tree.total.js';
 import minRanceTree from './data/rance.tree.js';
 import minAlterTree from './data/alter.tree.js';
 import minRatedTree from './data/rated.tree.js';
 import minLanceTree from './data/lance.tree.js';
 import minRantsTree from './data/rants.tree.js';
 import minRonteTree from './data/ronte.tree.js';
 import hardSaletTree from './data/salet.tree.hard.js';
 import hardCrampTree from './data/cramp.tree.hard.js';
 import targetWords from './data/targetWords.js';

 const fontFamily = "'Clear Sans', 'Helvetica Neue', Arial, sans-serif";
 const black = new scenery.Color( '#1A1A1B' );
 const gray = new scenery.Color( '#787C7E' );
 const yellow = new scenery.Color( '#C9B458' );
 const green = new scenery.Color( '#6AAA64' );

 const LENGTH = 5;
 const ABSENT = 0;
 const PRESENT = 1;
 const CORRECT = 2;
 const scratchResult = [ ABSENT, ABSENT, ABSENT, ABSENT, ABSENT ];
 const scratchIncorrect = [ true, true, true, true, true ];
 const scratchUnused = [ true, true, true, true, true ];
 const computeScore = ( correctSolution, attempt ) => {
 const result = scratchResult.fill( ABSENT ); // indexed by attempt
 const incorrect = scratchIncorrect.fill( true ); // indexed by correctSolution
 const unused = scratchUnused.fill( true ); // indexed by attempt

 for ( let i = 0; i < LENGTH; i++ ) {
 if ( correctSolution[ i ] === attempt[ i ] ) {
 result[ i ] = CORRECT;
 incorrect[ i ] = false;
 unused[ i ] = false;
 }
 }

 for ( let i = 0; i < LENGTH; i++ ) {
 if ( incorrect[ i ] ) {
 const correctLetter = correctSolution[ i ];
 for ( let k = 0; k < LENGTH; k++ ) {
 if ( unused[ k ] && correctLetter === attempt[ k ] ) {
 result[ k ] = PRESENT;
 unused[ k ] = false;
 break;
 }
 }
 }
 }

 return result.join( '' );
 };

 const computePartition = ( words, guess ) => {
 const map = {};
 for ( let i = 0; i < words.length; i++ ) {
 const word = words[ i ];
 const match = score( word, guess );
 let list = map[ match ];
 if ( !list ) {
 list = map[ match ] = [];
 }
 list.push( word );
 }
 return map;
 };

 const computeAverageGuesses = tree => {
 let averageGuesses = 0;
 let total = 0;
 for ( let i = 0; i < tree.ranking.counts.length; i++ ) {
 total += tree.ranking.counts[ i ];
 averageGuesses += ( i + 1 ) * tree.ranking.counts[ i ];
 }
 averageGuesses /= total;
 return averageGuesses;
 }

 class StaticWordNode extends scenery.FlowBox {
 constructor( word, score, options ) {
 super( phetCore.merge( {
 spacing: 5,
 mouseArea: new dot.Bounds2( 0, 0, 330, 62 ),
 touchArea: new dot.Bounds2( 0, 0, 330, 62 ),
 children: word.split( '' ).map( ( letter, index ) => {
 // TODO: factor out below?
 return new scenery.Rectangle( 0, 0, 62, 62, {
 fill: { 0: gray, 1: yellow, 2: green }[ score[ index ] ],
 children: [
 new scenery.Text( letter.toUpperCase(), { fontSize: 32, fontFamily: fontFamily, fontWeight: '700', fill: 'white', centerX: 32, centerY: 32 } )
 ]
 } )
 } )
 }, options ) );
 }
 }

 class WordOptionsNode extends scenery.Node {
 constructor( tree, words, depth, scoreProperty ) {
 const scores = Object.keys( tree.map ).sort();
 const rows = Math.max( 1, Math.floor( Math.sqrt( scores.length ) - 0.5 ) );
 const xSpacing = 20;
 const ySpacing = 5;

 super();

 const childNode = new scenery.Node( { scale: 0.5 } );
 this.addChild( childNode );

 const highlightAmount = 5;
 const highlightRectangle = new scenery.Rectangle( { stroke: black, lineWidth: highlightAmount / 2 } );

 scores.forEach( ( score, index ) => {
 const row = index % rows;
 const col = Math.floor( index / rows );

 const wordNode = new StaticWordNode( tree.guess, score, { cursor: 'pointer' } );
 wordNode.addInputListener( new scenery.FireListener( {
 fire: () => {
 scoreProperty.value = score;
 }
 } ) );

 wordNode.x = col * ( wordNode.width + xSpacing );
 wordNode.y = row * ( wordNode.height + ySpacing );
 childNode.addChild( wordNode );

 scoreProperty.link( otherScore => {
 wordNode.opacity = otherScore === score ? 1 : 0.6;
 if ( otherScore === score ) {
 highlightRectangle.rectBounds = wordNode.bounds.dilated( highlightAmount );
 }
 } );
 } );

 childNode.localBounds = childNode.localBounds.dilated( 10 );

 childNode.addChild( highlightRectangle );

 // Yes, this is a blatant memory leak, set up disposal
 display.sizeProperty.link( size => {
 this.maxWidth = Math.min( size.width - 20, 700 );
 } );
 }
 }

 class WordNode extends scenery.FlowBox {
 constructor( tree, words, depth, options ) {
 options = phetCore.merge( {
 orientation: 'vertical',
 spacing: 2
 }, options );
 super( options );

 const isLeaf = typeof tree === 'string';

 const guess = isLeaf ? tree : tree.guess;

 const scoreProperty = new axon.Property( isLeaf ? '22222' : '00000' );
 // const scoreProperty = new axon.Property( isLeaf ? '22222' : ( tree.map[ '00000' ] ? '00000' : Object.keys( tree.map )[ 0 ] ) );

 const letterNodes = guess.split( '' ).map( ( letter, index ) => {
 let value = 0;

 const letterNode = new scenery.Rectangle( 0, 0, 62, 62, {
 fill: isLeaf ? green : gray,
 children: [
 new scenery.Text( letter.toUpperCase(), { fontSize: 32, fontFamily: fontFamily, fontWeight: '700', fill: 'white', centerX: 32, centerY: 32 } )
 ],
 cursor: 'pointer'
 } );
 scoreProperty.link( score => {
 letterNode.fill = { 0: gray, 1: yellow, 2: green }[ score[ index ] ]
 } );
 !isLeaf && letterNode.addInputListener( new scenery.FireListener( {
 fire: () => {
 value = ( value + 1 ) % 3;
 scoreProperty.value = scoreProperty.value.slice( 0, index ) + value + scoreProperty.value.slice( index + 1 );
 }
 } ) );
 return letterNode;
 } );

 const letterBox = new scenery.FlowBox( {
 spacing: 5,
 children: letterNodes
 } );

 this.addChild( letterBox );

 if ( !isLeaf ) {
 this.addChild( new scenery.Text( `${computeAverageGuesses( tree ).toFixed( 2 )} ${depth === 1 ? 'total avg. guesses' : 'avg. guesses left'}, ${words.length} words, ${Object.values( tree.map ).length} colorings`, { fontSize: 14, fontFamily: fontFamily, fill: gray } ) );
 }
 else {
 this.addChild( new scenery.Text( `solved`, { fontSize: 14, fontFamily: fontFamily, fill: gray, layoutOptions: { topMargin: 5 } } ) );
 }

 if ( !isLeaf ) {
 this.addChild( new WordOptionsNode( tree, words, depth, scoreProperty ) );
 }

 if ( !isLeaf ) {
 const childNode = new scenery.Node( {
 layoutOptions: {
 topMargin: 15
 }
 } );
 this.addChild( childNode );

 scoreProperty.lazyLink( score => {
 if ( !tree.map[ score ] ) {
 childNode.children = [ new scenery.Text( 'no match found', { fontSize: 14, fontFamily: fontFamily, fill: gray } ) ];
 }
 else if ( score !== '22222' ) {
 childNode.children = [ new WordNode( tree.map[ score ], words.filter( word => computeScore( word, guess ) === score ), depth + 1 ) ];
 }
 else {
 childNode.children = [];
 }
 } );
 }
 }
 }

 const treeProperty = new axon.Property( null );
 window.treeProperty = treeProperty;

 const scene = new scenery.Node();
 const display = new scenery.Display( scene, {
 container: document.getElementById( 'main' ),
 rootRenderer: 'svg',
 // allowSceneOverflow: false,
 // assumeFullWindow: true
 allowCSSHacks: false,
 passiveEvents: true
 } );
 display.domElement.style.position = 'absolute';
 window.display = display;

 const wordNodeContainer = new scenery.Node( {
 layoutOptions: { topMargin: 15 }
 } );
 treeProperty.link( tree => {
 if ( tree === null ) {
 wordNodeContainer.removeAllChildren();
 }
 else {
 wordNodeContainer.children = [ new WordNode( tree, targetWords, 1 ) ];
 }
 } );

 const helpText = new scenery.RichText( 'Click one of the starting guesses, I\'ll give you the rest! Click the letters to change the color to match your result, then you\'ll be given another guess (or click a thumbnail option below). Optimized to minimize the number of total guesses. Best is ~3.42 per win. <a href="{{about}}">Learn More</a>.', {
 lineWrap: 330,
 font: new scenery.Font( { size: 14, family: fontFamily } ),
 layoutOptions: { topMargin: 15 },
 links: { about: 'https://jonathanolson.net/experiments/optimal-wordle-solutions' }
 } );

 const selectionHeaderFont = new scenery.Font( { size: 14, fontFamily: fontFamily } );

 const createTreeButton = tree => {
 const label = new scenery.RichText( `${tree.guess.toUpperCase()}`, {
 font: new scenery.Font( { size: 14, fontFamily: fontFamily, weight: '700' } ),
 cursor: 'pointer',
 fill: 'rgb(27,0,241)'
 } );

 label.addInputListener( new scenery.FireListener( {
 fire: () => {
 treeProperty.value = tree;
 // helpText.visible = false;
 }
 } ) );

 return label;
 };

 const mainBox = new scenery.FlowBox( {
 orientation: 'vertical',
 children: [
 new scenery.RichText( 'WORDLESolver', { font: new scenery.Font( { size: 36, family: fontFamily, weight: '700' } ), fill: black } ),
 helpText,
 new scenery.HBox( {
 layoutOptions: { topMargin: 10 },
 align: 'top',
 spacing: 10,
 children: [
 new scenery.FlowBox( {
 orientation: 'vertical',
 children: [
 new scenery.Text( 'Fastest Average', { font: selectionHeaderFont, fill: gray, layoutOptions: { bottomMargin: 5 } } ),
 createTreeButton( totalSaletTree ),
 createTreeButton( totalReastTree ),
 createTreeButton( totalCrateTree ),
 createTreeButton( totalTraceTree ),
 createTreeButton( totalSlateTree ),
 createTreeButton( totalCraneTree )
 ]
 } ),
 new scenery.FlowBox( {
 orientation: 'vertical',
 children: [
 new scenery.Text( 'Fewest 5+', { font: selectionHeaderFont, fill: gray, layoutOptions: { bottomMargin: 5 } } ),
 createTreeButton( minRanceTree ),
 createTreeButton( minRantsTree ),
 createTreeButton( minRatedTree ),
 createTreeButton( minRonteTree ),
 createTreeButton( minAlterTree ),
 createTreeButton( minLanceTree )
 ]
 } ),
 new scenery.FlowBox( {
 orientation: 'vertical',
 children: [
 new scenery.Text( 'Hard Mode', { font: selectionHeaderFont, fill: gray, layoutOptions: { bottomMargin: 5 } } ),
 createTreeButton( hardSaletTree ),
 createTreeButton( hardCrampTree )
 ]
 } ),
 ]
 } ),
 wordNodeContainer
 ]
 } );
 scene.addChild( mainBox );
 mainBox.localBoundsProperty.link( localBounds => {
 mainBox.centerX = window.innerWidth / 2;
 } );

 display.initializeEvents();

 let resizeDirty = true;
 const resizer = () => {
 resizeDirty = true;
 };
 window.addEventListener( 'resize', resizer );
 scene.boundsProperty.link( resizer );

 display.updateOnRequestAnimationFrame( dt => {
 if ( resizeDirty && scene.bounds.isFinite() ) {
 resizeDirty = false;

 display.setWidthHeight( window.innerWidth, Math.ceil( mainBox.bounds.height + 10 ) );
 }
 } );

Requests	IP Address	Location	AS Autonomous System
23	172.67.154.13	United States	AS13335Cloudflare, Inc.
23	1	-	-

Security Scan Report: jonathanolson.net

Summary

AI Security Verdict

Safe Website

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Detected Technologies8

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History