From 7668e6e54932f17fabddf05358b682c44f474b24 Mon Sep 17 00:00:00 2001 From: NHLOCAL Date: Thu, 17 Sep 2026 02:17:33 +0300 Subject: [PATCH 1/9] Redraw the 16 personality illustrations with a shared vector system --- .github/workflows/rebuild-16-type-artwork.yml | 61 ++++ scripts/redraw_16_type_illustrations.py | 297 ++++++++++++++++++ tests/test_type_illustrations.py | 63 ++++ 3 files changed, 421 insertions(+) create mode 100644 .github/workflows/rebuild-16-type-artwork.yml create mode 100644 scripts/redraw_16_type_illustrations.py create mode 100644 tests/test_type_illustrations.py diff --git a/.github/workflows/rebuild-16-type-artwork.yml b/.github/workflows/rebuild-16-type-artwork.yml new file mode 100644 index 0000000..822cff5 --- /dev/null +++ b/.github/workflows/rebuild-16-type-artwork.yml @@ -0,0 +1,61 @@ +name: Rebuild 16-type artwork (one-off) + +on: + pull_request: + types: [opened, synchronize, reopened] + paths: + - scripts/redraw_16_type_illustrations.py + - .github/workflows/rebuild-16-type-artwork.yml + +permissions: + contents: write + +jobs: + rebuild: + if: >- + github.event.pull_request.head.repo.full_name == 'NHLOCAL/tools' && + github.event.pull_request.head.ref == 'codex/redesign-16-type-illustrations' + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ github.event.pull_request.head.sha }} + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + - uses: actions/setup-node@v4 + with: + node-version: '22' + - name: Install the existing site build dependency + run: python -m pip install -r requirements.txt + - name: Regenerate artwork and its standalone consumers + run: | + python scripts/redraw_16_type_illustrations.py + node resources/the_16_types/build.cjs + python build.py + - name: Validate the artwork and existing site contracts + run: | + python -m unittest discover -s tests -v + node --test resources/the_16_types/scoring.test.cjs + node resources/the_16_types/build.cjs --check + - name: Provide the exact built page for browser inspection + uses: actions/upload-artifact@v4 + with: + name: 16-type-artwork-validation + retention-days: 3 + path: | + tools/the_16_types.html + assets/illustrations/16-types/*.svg + - name: Commit generated assets to this feature branch only + run: | + git config user.name 'github-actions[bot]' + git config user.email '41898282+github-actions[bot]@users.noreply.github.com' + git add assets/illustrations/16-types/*.svg tools/the_16_types.html assets/downloads/the_16_types.js catalog + if ! git diff --quiet; then + echo 'Unexpected changes outside the illustration build outputs:' + git diff --name-only + exit 1 + fi + if git diff --cached --quiet; then exit 0; fi + git commit -m 'Rebuild all 16 SVG illustrations and standalone test outputs' + git push origin HEAD:refs/heads/codex/redesign-16-type-illustrations diff --git a/scripts/redraw_16_type_illustrations.py b/scripts/redraw_16_type_illustrations.py new file mode 100644 index 0000000..2e30b28 --- /dev/null +++ b/scripts/redraw_16_type_illustrations.py @@ -0,0 +1,297 @@ +"""Rebuild the sixteen original, self-contained personality illustrations. + +Run from any directory: python scripts/redraw_16_type_illustrations.py +Uses only Python's standard library and the existing palettes.json. +The SVG files remain the inputs to resources/the_16_types/build.cjs. +""" +from pathlib import Path +from html import escape +import json +import xml.etree.ElementTree as ET + +OUT = Path(__file__).resolve().parents[1] / 'assets' / 'illustrations' / '16-types' +PALETTES = {code: (value['accent'], value['soft']) for code, value in json.loads((OUT / 'palettes.json').read_text(encoding='utf-8')).items()} +ET.register_namespace('', 'http://www.w3.org/2000/svg') +INK='#263D48'; PAPER='#FFF9ED'; GOLD='#E6B65D' +SKINS=[('#EDC2A1','#D89C77'),('#E3AF87','#C98963'),('#BF825B','#965C40'),('#9A6247','#7D4A36')] + +def el(tag, **attrs): + return '<'+tag+''.join(' '+k.replace('_','-')+'="'+str(v)+'"' for k,v in attrs.items())+'/>' +def p(d, fill='none', **attrs): return el('path', d=d, fill=fill, **attrs) +def c(x,y,r,fill,**attrs): return el('circle',cx=x,cy=y,r=r,fill=fill,**attrs) +def rect(x,y,w,h,r,fill,**attrs): return el('rect',x=x,y=y,width=w,height=h,rx=r,fill=fill,**attrs) +def g(content, **attrs): return ''+content+'' +def limb(d, color, width=14): + return p(d,stroke=INK,stroke_width=width+2.6)+p(d,stroke=color,stroke_width=width) +def shoe(x,y,flip=False,color=INK,angle=0): + return g(p('M0 0H14Q18 4 26 5Q30 6 29 11H-1Q-4 8 0 0Z',color)+p('M0 9H27',stroke=PAPER if color==INK else INK,stroke_width=1,opacity='.38'),transform=f'translate({x} {y}) rotate({angle}) scale({-1 if flip else 1} 1)') +def hand(x,y,skin=0,angle=0,kind='grip'): + s,sh=SKINS[skin] + if kind=='open': + art=p('M-4 6-7-1Q-9-5-7-6Q-5-7-3-3L-2-9Q-2-12 0-11L3-4 6-8Q8-9 9-7L7 2Q6 7 2 8Z',s)+p('M-3-2 1 2',stroke=sh,stroke_width=1) + else: + art=p('M-5 3V-4Q-5-7-2-7H3Q7-7 7-3V3Q6 8 1 8Q-3 8-5 3Z',s)+p('M-5 0-1-2Q2-3 3 0L0 3',stroke=sh,stroke_width=1) + return g(art,transform=f'translate({x} {y}) rotate({angle})') + +def head(x,y,skin=0,hair='#594335',style='sweep',beard=False,moustache=False,glasses=False,angle=0,mood='smile'): + s,sh=SKINS[skin] + out=rect(-6,17,12,16,3,s)+p('M-5 21Q0 26 6 22V28Q0 30-5 27Z',sh,stroke='none') + out+=el('ellipse',cx=-16.5,cy=3,rx=3.5,ry=5,fill=s)+el('ellipse',cx=16.5,cy=3,rx=3.5,ry=5,fill=s) + out+=p('M-16-12Q-16-24 0-24Q16-24 16-12V7Q15 21 0 24Q-14 22-16 8Z',s) + hairs={ + 'sweep':'M-16 4Q-23-13-13-21Q-4-30 8-25Q16-25 19-17Q23-14 18-9L14-7Q6-9 0-16Q-5-9-12-9L-12 3Z', + 'curly':'M-16 4Q-23 0-20-7Q-25-14-18-18Q-21-26-11-26Q-5-33 2-28Q10-33 15-26Q24-25 20-17Q25-10 18-5L15 3 12-7Q5-4 0-10Q-5-5-12-7L-12 4Z', + 'short':'M-16 3Q-20-9-16-17Q-12-25 0-25Q14-26 17-16L16 2H13V-12Q0-8-12-12V3Z', + 'wave':'M-16 4Q-22-5-17-12Q-21-22-10-23Q-3-30 5-25Q16-29 18-18Q24-13 17-5L13 2V-9Q3-4-4-13Q-8-7-12-8V4Z', + 'silver':'M-16 4Q-21-14-12-20Q0-29 13-20Q21-16 17 3L13 2 12-11Q-1-7-8-16L-12-10V4Z', + 'bald':'M-16 5Q-21-9-15-16L-10-20V-13L-12-6V5ZM11-20Q21-12 17 5L13 4V-8Z', + 'cap':'M-18-7Q-19-26-1-28Q14-29 18-11L24-7Q27-3 22-2H-12V5H-16Z', + } + out+=p(hairs[style],hair,stroke=hair) + if style=='cap':out+=p('M-16-8Q4-12 20-6M-4-24Q4-22 7-13',stroke=PAPER,stroke_width=1.2,opacity='.48') + if style=='silver':out+=p('M-10-20Q-4-23 2-21',stroke=PAPER,stroke_width=1.4,opacity='.65') + if beard: + out+=p('M-15 6-10 10-5 10 0 8 6 10 11 9 15 5 13 16Q8 24 0 24Q-10 22-14 15Z',hair,stroke=hair) + # Faces deliberately use few, legible marks rather than tiny stacked details. + brow='M-11-2Q-7-4-3-2M4-2Q8-4 12-2' if mood!='thought' else 'M-11-2-4-3M4-3 11-1' + out+=p(brow,stroke=hair,stroke_width=1.4) + out+=c(-7,3,1.15,INK,stroke='none')+c(8,3,1.15,INK,stroke='none') + out+=p('M1 4-1 9 2 10',stroke=sh,stroke_width=1.2) + if glasses == 'sun': + out+=p('M-14-1H-2L-3 6Q-8 9-12 5ZM3-1H15L13 6Q8 9 4 5Z',INK)+p('M-2 0H3M-10 0H-6M7 0H11',stroke=PAPER,stroke_width=1) + elif glasses: + out+=g(c(-7,3,5.8,'none')+c(8,3,5.8,'none')+p('M-1 2H2M-16 1-13 2M14 2 17 1'),stroke_width=1.2) + if moustache: + out+=p('M-9 13Q-4 9 0 12Q5 9 10 13Q7 17 1 14Q-5 17-9 13Z',hair,stroke='none') + out+=p('M-3 19Q1 21 5 18',stroke=INK,stroke_width=1.1) + elif mood=='thought':out+=p('M-4 15 4 14',stroke=PAPER if beard else INK,stroke_width=1.3) + else:out+=p('M-5 14Q0 19 6 14',stroke=PAPER if beard else INK,stroke_width=1.4) + return g(out,transform=f'translate({x} {y}) rotate({angle})') + +def torso(x,color,shade=None,kind='jacket',angle=0): + shade=shade or color + if kind=='sweater': + art=p('M-10 96Q-28 99-28 110L-24 157Q0 164 26 157L25 108Q22 99 10 96Z',color) + art+=p('M-10 97Q0 110 11 97',stroke=PAPER,stroke_width=4) + art+=p('M-21 152Q0 158 23 152',stroke=shade,stroke_width=1.3) + else: + art=p('M-10 96Q-26 97-28 109L-24 158Q0 163 26 156L25 109Q23 99 10 96Z',color) + art+=p('M-9 97 0 104 10 97 12 156-7 159Z',PAPER,stroke='none') + if kind=='vest': + art+=p('M-13 96-1 115 12 96 24 105 22 156 3 161-2 156-23 159-25 105Z',shade) + art+=p('M0 116V151',stroke=PAPER,stroke_width=1,opacity='.45') + art+=c(5,132,1,PAPER,stroke='none')+c(6,143,1,PAPER,stroke='none') + else: + art+=p('M-11 96-2 104-10 122-20 108Z',shade,stroke='none')+p('M11 96 2 104 12 121 21 107Z',shade,stroke='none') + art+=p('M-10 124-11 154M13 125 16 153',stroke=PAPER,stroke_width=1,opacity='.28') + return g(art,transform=f'translate({x} 0) rotate({angle} 0 126)') + +def standing(x=116, pants=INK, shade='#415363', spread=0): + return g(p('M-23 153H1L-4 201H-20Z',pants)+p(f'M1 153H24L{30+spread} 200 {14+spread} 203 4 174Z',shade)+shoe(-22,200,True)+shoe(13+spread,201),transform=f'translate({x} 0)') + +def compact_inherited_styles(svg): + """Remove only redundant inherited presentation attributes, not geometry.""" + keys = ('fill', 'stroke', 'stroke-width', 'stroke-linecap', 'stroke-linejoin') + def visit(node, inherited): + current = inherited.copy() + for key in keys: + if key in node.attrib: + value = node.get(key) + if inherited.get(key) == value: + del node.attrib[key] + current[key] = value + for child in node: + visit(child, current) + root = ET.fromstring(svg) + # Whitespace between shapes is irrelevant and is reapplied consistently below. + for node in root.iter(): + if node.text is not None and not node.text.strip(): node.text = None + node.tail = None + visit(root, {'fill': 'black', 'stroke': 'none', 'stroke-width': '1', + 'stroke-linecap': 'butt', 'stroke-linejoin': 'miter'}) + return ET.tostring(root, encoding='unicode').replace(' />', '/>').replace('><', '>\n<') + '\n' + +def write(code,title,desc,body): + accent,soft=PALETTES[code] + start=f'\n{code}: {escape(title)}\n{escape(desc)}\n' + bg=c(120,122,84,soft)+el('ellipse',cx=120,cy=216,rx=65,ry=3,fill=INK,opacity='.08') + svg=start+bg+'\n'+g(body,fill='none',stroke=INK,stroke_width='1.4',stroke_linecap='round',stroke_linejoin='round')+'\n\n' + # Keep each SVG readable while avoiding redundant attributes and giant path lines. + svg=compact_inherited_styles(svg) + (OUT/f'{code}.svg').write_text(svg, encoding='utf-8', newline='\n') + return svg + +def intj(): + a,s=PALETTES['INTJ']; skin=1 + art=standing(117,INK,'#344B5E') + art+=limb('M94 107Q83 116 77 140',a)+limb('M139 107Q151 119 157 139',a) + art+=torso(117,a,'#364673')+head(117,67,skin,INK,glasses=True,angle=-5,mood='thought') + # An actual folded three-panel plan, gripped at both outside edges. + art+=g(p('M72 135 99 130 127 135 157 128V165L128 172 99 167 72 172Z','#B9CFDE')+p('M99 130 127 135 128 172 99 167Z','#DCE7EF',stroke='none')+p('M99 134V164M127 139V168',stroke=a,opacity='.45')+p('M79 145 91 142V155H85V161M106 159V143L120 146V163M134 159V145L149 141V156',stroke=a,stroke_width=1.5)+p('M108 150 119 152M141 145V157',stroke=a,stroke_width=1),stroke=a) + art+=hand(73,149,skin,-8)+hand(156,146,skin,14) + write('INTJ','The architect with a folded blueprint','A bespectacled male architect in an indigo jacket studies a three-panel architectural plan. His balanced stance and precise drawing convey quiet planning.',art) + +def intp(): + a,s=PALETTES['INTP'];skin=0 + art=rect(67,165,63,7,3,'#B8A28E')+p('M74 173 69 212M122 173 131 212',stroke='#A28A75',stroke_width=4) + art+=p('M97 152Q123 150 139 167L152 191 139 198 120 176 94 175Z','#384954') + art+=p('M79 153H106L100 180 85 196 106 202 102 215 72 207Q64 204 70 193L83 174Z',INK) + art+=shoe(101,207)+shoe(140,194,angle=13) + art+=limb('M82 107Q64 127 78 144L105 146',a) + art+=limb('M128 107 142 126Q146 129 152 123L165 102',a) + art+=torso(106,a,'#9680AA')+limb('M77 141Q86 146 103 146',a,12)+hand(106,145,skin,83) + art+=head(105,68,skin,'#594335','curly',beard=True,glasses=True,angle=8,mood='thought') + art+=p('M166 102V83',stroke=a,stroke_width=2) + art+=g(el('ellipse',cx=174,cy=66,rx=25,ry=9,transform='rotate(-32 174 66)')+el('ellipse',cx=174,cy=66,rx=25,ry=9,transform='rotate(48 174 66)'),stroke=a,stroke_width=1.6) + art+=c(174,66,5.7,GOLD,stroke='none')+c(193,52,3,a,stroke=PAPER,stroke_width=1)+hand(166,103,skin,17) + write('INTP','The thinker with an orbital model','A curly-haired, bearded male thinker in a lavender jacket sits on a wooden stool. He studies a small orbital model held carefully at eye level.',art) + +def entj(): + a,s=PALETTES['ENTJ'];skin=3 + art=p('M139 215V192H166V172H192V150H214V215Z','#E8C8CE',stroke='none')+p('M166 191H191M192 171H212',stroke=a,opacity='.25') + art+=p('M84 152H108L104 202H86Z',INK)+p('M108 151 131 149Q142 150 151 160L154 180H138L136 170 114 174Z','#374A57')+shoe(85,201,True)+shoe(139,181) + art+=limb('M87 107 72 133Q70 143 93 147',a)+limb('M133 107 152 122Q156 123 160 115L177 88',a) + art+=torso(108,a,'#7B3549')+p('M106 106 111 106 115 132 111 138 106 132Z',GOLD,stroke='none') + art+=limb('M73 136Q76 144 91 146',a,12)+hand(95,145,skin,75)+head(108,66,skin,INK,'short',moustache=True,angle=-4) + art+=g(p('M-5 7-6-3Q-7-8-3-8L0-6 2-20Q3-24 5-21L6-5 10-2 9 7Q5 12 0 11Z',SKINS[skin][0])+p('M0-5 4-2',stroke=SKINS[skin][1],stroke_width=1),transform='translate(177 82) rotate(19)') + write('ENTJ','The leader indicating the next step','A confident moustached male leader wears a burgundy suit. One foot is on a low step and one hand points forward and upward along a clear staircase.',art) + +def entp(): + a,s=PALETTES['ENTP'];skin=1 + art=p('M97 153 120 156 109 184 90 207 77 199 94 172Z',INK)+p('M120 155 142 151 143 180 161 201 148 211 126 188Z','#415363')+shoe(81,200,True,angle=-7)+shoe(150,202,angle=12) + art+=limb('M98 107 77 130Q72 135 66 128L49 108',a)+limb('M141 109 158 132Q162 137 169 130L188 105',a) + art+=torso(119,a,'#D17A4D',angle=4)+head(117,66,skin,'#8E5038','wave',angle=8) + art+=hand(46,105,skin,-35,'open')+hand(190,103,skin,38,'open') + art+=g(p('M32 68 48 59 64 68V86L48 95 32 86Z','#6D889E')+p('M32 68 48 77 64 68M48 77V95',stroke=PAPER,stroke_width=1.3),stroke='#476778') + art+=g(p('M179 69 192 48 207 69 193 90Z',GOLD)+p('M192 48 193 90M179 69H207',stroke=PAPER,stroke_width=1.3),stroke=a) + write('ENTP','The inventor comparing two ideas','An expressive male inventor in a rust jacket compares a blue cube and a golden geometric solid. Open palms and an asymmetric stance suggest lively curiosity.',art) + +def infj(): + a,s=PALETTES['INFJ'];skin=2 + art=standing(113,INK,'#354F48',spread=1) + art+=limb('M89 108Q68 132 79 145L103 148',a)+limb('M138 108Q152 121 170 149',a) + art+=torso(113,a,'#50836D')+limb('M78 142Q85 148 103 148',a,12)+hand(106,149,skin,85) + art+=head(113,67,skin,'#364238','sweep',beard=True,angle=-4,mood='thought') + art+=g(el('ellipse',cx=175,cy=162,rx=7,ry=9)+p('M161 174 165 170H185L189 174 185 204H165Z',INK)+p('M165 171 170 166H181L185 171Z',a)+p('M166 177H184L181 199H169Z',GOLD,stroke='none')+p('M175 181Q166 193 175 196Q184 193 175 181Z',PAPER,stroke='none')+p('M164 204H186',stroke_width=3)) + art+=hand(172,151,skin,-21) + write('INFJ','The guide carrying a lantern','A contemplative bearded male guide in a forest-green coat carries a warm lantern by its handle. A quiet stance and a small flame suggest insight and guidance.',art) + +def infp(): + a,s=PALETTES['INFP'];skin=0 + art=rect(67,166,55,43,9,'#D1D8B9',stroke='none')+p('M72 174H117',stroke=a,opacity='.25') + art+=p('M87 155 108 157 103 185 88 204H73L88 177Z','#415340') + art+=p('M106 153Q125 151 143 173Q149 180 143 188L128 204 115 196 129 180 107 177Z',INK)+shoe(77,202,True)+shoe(119,199,angle=20) + art+=limb('M82 108Q67 126 81 145L100 150',a)+limb('M127 108Q146 121 152 140',a) + art+=torso(104,a,'#889A56')+head(103,69,skin,'#624A39','wave',angle=8) + art+=limb('M79 143 100 151',a,12) + art+=g(p('M96 140Q110 137 124 145Q138 135 156 138L153 168Q139 166 126 176Q110 169 97 172Z','#E8D4A8')+p('M99 139Q111 137 124 144Q140 134 153 137L150 164Q137 164 125 172Q112 166 100 168Z',PAPER)+p('M124 145 125 171M105 145 117 148M105 151 117 154M132 147 146 143M132 153 145 149',stroke=a,stroke_width=1.2),stroke=a) + art+=hand(98,156,skin,-9)+hand(154,153,skin,9) + write('INFP','The reader absorbed in a book','A gentle male reader in an olive jacket sits on a small cushion. He leans toward an open book, with both hands resting naturally on the page edges.',art) + +def enfj(): + a,s=PALETTES['ENFJ'];skin=2 + art=standing(118,INK,'#34565A',spread=4) + art+=limb('M95 107 75 137Q71 143 63 138L39 124',a)+limb('M141 107 166 134Q171 140 178 134L200 118',a) + art+=torso(118,a,'#479392')+hand(31,122,skin,-57,'open')+hand(207,113,skin,47,'open') + art+=head(118,66,skin,'#383932','curly',beard=True) + art+=g(p('M169 41H196Q205 41 205 50V65Q205 73 196 73H182L173 81V73H169Q161 73 161 65V50Q161 41 169 41Z',a,stroke='none')+p('M175 54Q178 49 183 54Q189 49 192 54Q194 59 183 66Q172 60 175 54Z',PAPER,stroke='none')) + write('ENFJ','The guide welcoming connection','A smiling bearded male guide in a teal jacket opens both hands in welcome. A small heart in a speech bubble reinforces empathy and connection.',art) + +def enfp(): + a,s=PALETTES['ENFP'];skin=1;coat='#C19435' + art=p('M91 153 113 157 99 181 74 201 61 190 84 169Z',INK)+p('M113 157 136 153 141 180 158 203 144 212 121 187Z','#4E5146')+shoe(65,192,True,angle=14)+shoe(146,204,angle=3) + art+=limb('M88 105Q74 122 61 148',coat)+limb('M132 106 151 107Q158 107 160 98L164 79',coat) + art+=torso(108,coat,a,angle=-5)+head(108,66,skin,'#684D35','wave',angle=-10)+hand(57,155,skin,15) + art+=g(p('M157 47 185 24 209 52 181 80Z',coat)+p('M185 24 181 80 173 48Z',PAPER,stroke='none')+p('M157 47 209 52M185 24 181 80',stroke=a,stroke_width=1.3)+p('M181 80Q168 95 164 79M181 80Q183 99 200 106Q181 114 198 124',stroke=a,stroke_width=1.2)+p('M184 97 193 94 191 103Z',coat)+p('M192 116 201 113 200 122Z',coat),stroke=a) + art+=hand(164,80,skin,8) + write('ENFP','The explorer lifting a kite','An enthusiastic male explorer in a golden jacket moves forward while lifting a diamond-shaped kite. A clearly connected string and a light tail echo his lively pose.',art) + +def istj(): + a,s=PALETTES['ISTJ'];skin=0 + art=standing(119,'#B9A489','#D0BDA0') + art+=limb('M96 107Q83 120 78 152',PAPER)+limb('M141 107Q161 126 150 138L113 152',PAPER) + art+=torso(119,PAPER,a,kind='vest')+p('M116 106 122 106 124 124 119 131 115 124Z','#AE7C4E',stroke='none') + art+=head(118,67,skin,'#4D4840','sweep',moustache=True,angle=-3) + art+=g(rect(61,126,43,60,4,a)+rect(65,131,35,50,2,PAPER,stroke='none')+rect(74,122,18,10,3,'#A3B5BD')+p('M71 143 74 146 79 139M85 143H94M71 156 74 159 79 152M85 156H94M71 169 74 172 79 165M85 169H94',stroke=a,stroke_width=1.6),transform='rotate(-8 84 154)') + art+=hand(65,157,skin,-12) + art+=limb('M149 135 119 149',PAPER,12)+p('M94 165 114 143',stroke=INK,stroke_width=2)+p('M93 169 94 164 97 166Z',GOLD,stroke='none')+hand(111,150,skin,57) + write('ISTJ','The organiser checking a clipboard','A meticulous moustached man in a slate-blue waistcoat checks a three-item clipboard with a pencil. Clear marks, neat sleeves and a steady posture convey care and order.',art) + +def isfj(): + a,s=PALETTES['ISFJ'];skin=1 + art=standing(119,'#43554C',INK) + art+=limb('M94 107Q72 128 84 145L105 161',a)+limb('M143 107Q165 128 154 146L134 161',a) + art+=torso(119,a,'#BA7786')+head(119,67,skin,'#66513F','bald',beard=True,angle=1) + art+=limb('M83 141Q85 153 108 166',a,12)+limb('M155 141Q151 154 132 166',a,12) + art+=g(p('M104 146H135L131 174Q119 178 109 174Z','#BA7C55')+rect(101,142,37,7,2,'#D59A6C')+p('M119 142V113',stroke='#597953',stroke_width=2)+p('M118 131Q97 133 98 114Q117 113 118 131Z','#6A925E',stroke='none')+p('M120 122Q117 102 138 102Q139 122 120 122Z','#8BA976',stroke='none')+p('M104 119 117 131M121 119 133 107',stroke='#C7D9AB',stroke_width=1.2),stroke='#965C40') + art+=g(p('M98 158Q102 155 107 161L109 169 119 171Q122 174 118 177L107 175Q100 174 96 167Z',SKINS[skin][0])+p('M140 157Q136 155 133 161L130 169 122 171Q119 174 122 177L134 175Q141 173 144 166Z',SKINS[skin][0])+p('M107 168 113 172M133 168 128 172',stroke=SKINS[skin][1],stroke_width=1)) + write('ISFJ','The gardener protecting a young plant','A kindly balding, bearded male gardener in a rose cardigan cups a terracotta pot in both hands. Two fresh green leaves are the gentle focal point.',art) + +def estj(): + a,s=PALETTES['ESTJ'];skin=0 + art=standing(101,INK,'#40556D') + art+=limb('M79 108Q66 128 62 152',a)+limb('M124 108 145 133 174 133',a) + art+=torso(101,a,'#274973')+p('M99 106 105 106 108 132 103 138 98 132Z','#CF9555',stroke='none')+hand(60,160,skin,-9) + art+=head(101,67,skin,'#A8ADB0','silver',glasses=True,angle=-3,mood='thought') + art+=rect(150,165,60,7,2,'#AF987D')+p('M158 173 152 211M202 173 209 211',stroke='#A18B76',stroke_width=4) + art+=rect(155,152,14,12,2,'#7798B8',stroke='none')+rect(175,140,14,24,2,a,stroke='none')+rect(195,126,14,38,2,'#C3D4E7',stroke='none')+p('M158 157H165M178 145H185M198 131H205',stroke=PAPER,stroke_width=1.4) + art+=hand(177,134,skin,90) + write('ESTJ','The organiser arranging clear steps','A silver-haired male organiser in a blue suit arranges three ascending blocks on a small wooden table. His glasses and measured gesture emphasise practical structure.',art) + +def esfj(): + a,s=PALETTES['ESFJ'];skin=1 + art=standing(121,'#BCB09A','#D5C6AA') + art+=limb('M96 107 78 140Q75 145 66 141L52 135',PAPER)+limb('M144 107 164 144Q167 149 174 143L191 128',PAPER) + art+=torso(121,PAPER,a,kind='vest')+head(121,67,skin,'#75513F','wave',moustache=True,angle=-3) + art+=hand(198,122,skin,37,'open') + art+=g(p('M40 137Q42 132 50 132L59 134Q61 137 57 139L50 142 43 141Z',SKINS[skin][0])+p('M25 125H81L77 131H29Z',INK)) + art+=g(rect(31,104,15,20,3,PAPER)+p('M46 108H49Q55 108 53 115Q52 119 46 118',stroke=a,stroke_width=2)+rect(60,103,14,21,3,'#EAC28C')+p('M74 107H77Q83 108 81 115Q79 119 74 118',stroke=a,stroke_width=2)+p('M38 97Q33 93 38 87M67 96Q72 92 67 86',stroke=a,stroke_width=1.2),stroke=a) + write('ESFJ','The host offering a warm welcome','A warm moustached male host in a terracotta waistcoat balances a tray with two steaming cups. His free hand opens in a relaxed gesture of welcome.',art) + +def istp(): + a,s=PALETTES['ISTP'];skin=3 + art=p('M83 154 107 160 92 196 110 205 104 216H79Q68 215 73 204Z',INK)+p('M109 154 132 160 154 174Q159 178 157 186L151 207H135L137 186 111 179Z','#355954')+shoe(103,206)+shoe(136,205) + art+=limb('M78 113Q63 136 51 167',a)+limb('M127 114 149 139Q155 143 160 134L171 115',a) + art+=torso(103,a,'#5C9B8B',angle=6)+p('M81 131 92 129 94 140 83 142ZM115 128 126 130 125 141 114 139Z','#276355',stroke='none') + art+=head(101,73,skin,'#33463B','cap',beard=True,angle=7)+hand(47,175,skin,25) + art+=g(p('M-4 29V-8Q-14-13-11-24L-6-16H3L8-24Q14-13 4-8V29Q0 35-4 29Z','#82999B')+p('M0 20V-5',stroke=PAPER,stroke_width=1.2)+c(0,27,1.6,INK,stroke='none'),transform='translate(182 89) rotate(23)') + art+=hand(171,115,skin,24) + write('ISTP','The maker kneeling with a wrench','A bearded male maker in a green work shirt and cap kneels with a steel open-ended wrench. Rolled sleeves, two pockets and a grounded pose keep the scene practical.',art) + +def isfp(): + a,s=PALETTES['ISFP'];skin=0 + art=rect(69,166,60,7,3,'#BCA383')+p('M76 174 67 213M122 174 131 213',stroke='#A88C70',stroke_width=4) + art+=p('M81 156 105 159 100 181 84 203 69 198 85 176Z','#D9CBAE')+p('M103 154 126 159 141 175 137 203H120L124 182 104 176Z','#C8B99C')+shoe(75,201,True)+shoe(121,202) + art+=limb('M78 109 62 134Q59 141 65 149',a)+limb('M124 112 138 136Q142 141 151 137L158 132',a) + art+=torso(101,a,'#B498CC',kind='sweater')+head(99,69,skin,'#6B4E3D','sweep',beard=True,angle=7) + art+=g(p('M156 212 177 82 181 82 203 212',stroke='#A78B70',stroke_width=4)+p('M163 202H196',stroke='#A78B70',stroke_width=2)+rect(161,94,47,68,2,'#B99C7D')+rect(165,98,39,59,1,PAPER,stroke='none')+c(193,111,5.5,GOLD,stroke='none')+p('M166 140 178 122 192 141 203 130V156H166Z','#A4B990',stroke='none')+p('M166 150 177 139 190 154 181 157H166Z',a,stroke='none')+p('M157 165H211',stroke='#9C8069',stroke_width=4)) + art+=g(p('M42 162Q43 147 61 147Q76 148 77 158Q78 165 69 165L62 163Q57 163 60 169Q56 175 48 171Q42 169 42 162Z','#E8D4A8')+c(50,157,3,a,stroke='none')+c(58,152,2.6,GOLD,stroke='none')+c(69,156,2.7,'#6A925E',stroke='none'))+hand(65,150,skin,15) + art+=p('M156 136 183 125',stroke=INK,stroke_width=2)+p('M182 123Q188 120 191 123L184 128Z',a,stroke='none')+hand(158,134,skin,67) + write('ISFP','The artist painting at an easel','A bearded male artist in a lilac sweater sits at a wooden easel. He holds a small palette and touches a brush to a quiet mountain-and-sun landscape.',art) + +def estp(): + a,s=PALETTES['ESTP'];skin=2;coat='#B56B25' + art=p('M134 214 143 195 161 190 183 195 202 214Z','#C7C5B1',stroke='none')+p('M143 195 160 198 168 207M161 190 174 201',stroke='#9C9C8C',stroke_width=1.2) + art+=p('M86 153H110L105 203H88Z',INK)+p('M108 152 132 149Q149 149 157 160L155 179H139L137 168 114 174Z','#4D565A')+shoe(88,201,True)+shoe(140,181) + art+=limb('M87 108Q70 127 64 148',coat)+limb('M133 108Q152 120 151 145',coat) + art+=torso(110,coat,'#D5914B')+hand(61,155,skin,-10)+head(110,67,skin,'#403D35','short',glasses='sun',angle=-6) + art+=p('M101 105 118 140M130 105 136 141',stroke=INK,stroke_width=2.5) + art+=g(rect(111,138,34,24,4,INK)+rect(119,134,13,7,2,INK)+c(129,150,8,'#6D8790',stroke='none')+c(129,150,4.8,PAPER,stroke='none')+c(130,149,2.2,'#6D8790',stroke='none')+c(116,143,1.5,GOLD,stroke='none')) + art+=hand(149,151,skin,16)+rect(144,138,15,5,2,a)+rect(149,137,6,7,2,PAPER) + write('ESTP','The adventurer stepping onto a rock','A confident male adventurer in an ochre jacket rests one foot on a rock. Sunglasses, a wristwatch and a camera on a connected neck strap convey readiness to explore.',art) + +def esfp(): + a,s=PALETTES['ESFP'];skin=3 + art=p('M96 153 119 159 109 184 84 206 72 196 96 175Z',INK)+p('M119 155 140 149 159 171 182 182 176 199 148 186 125 175Z','#4F435A')+shoe(78,202,True,color=PAPER,angle=-7)+shoe(180,186,color=PAPER,angle=58) + art+=p('M42 111Q25 135 31 167Q35 190 64 195',stroke='#71868E',stroke_width=1.4) + art+=limb('M91 107 70 139Q66 144 61 135L43 113',a)+limb('M136 107 157 114Q161 115 166 108L182 88',a) + art+=torso(113,a,'#C570A0',angle=-6)+p('M91 148 110 157 96 176 80 163Z','#C570A0',stroke='none')+head(113,65,skin,'#342F38','wave',moustache=True,angle=-10) + art+=hand(187,81,skin,34,'open') + art+=g(rect(-4,-3,8,28,4,INK)+el('ellipse',cx=0,cy=-10,rx=8,ry=11,fill='#70838B')+p('M-5-16 6-12M-6-11 6-7M-5-6 4-3',stroke=PAPER,stroke_width=1)+rect(-2,7,4,3,1,GOLD,stroke='none'),transform='translate(39 94) rotate(-26)') + art+=hand(45,108,skin,-26)+p('M63 209 76 208M181 198 185 205',stroke=a,stroke_width=1.4) + write('ESFP','The performer dancing with a microphone','An expressive moustached male performer in a magenta jacket dances in light sneakers. A clearly held microphone, a loose cable and an open raised hand complete the movement.',art) + +if __name__=='__main__': + for draw in (intj, intp, entj, entp, infj, infp, enfj, enfp, istj, isfj, estj, esfj, istp, isfp, estp, esfp): + draw() + print(f'Rebuilt 16 SVG illustrations in {OUT}') diff --git a/tests/test_type_illustrations.py b/tests/test_type_illustrations.py new file mode 100644 index 0000000..595a7cf --- /dev/null +++ b/tests/test_type_illustrations.py @@ -0,0 +1,63 @@ +"""Dependency-free contracts for the sixteen standalone SVG illustrations. + +Run: python -m unittest discover -s tests -p 'test_type_illustrations.py' -v +The visual review is separate: these tests do not grade illustration quality. +""" +import pathlib +import unittest +import xml.etree.ElementTree as ET + +ROOT = pathlib.Path(__file__).resolve().parents[1] +ART = ROOT / 'assets' / 'illustrations' / '16-types' +PALETTES = { + 'INTJ': ('#43558B', '#EBEDF7'), 'INTP': ('#745F8B', '#F0EBF5'), + 'ENTJ': ('#933F56', '#F7E9ED'), 'ENTP': ('#A4502B', '#F9ECDF'), + 'INFJ': ('#3B6C59', '#E7F1EB'), 'INFP': ('#5E7034', '#EFF2E2'), + 'ENFJ': ('#267376', '#E4F2EF'), 'ENFP': ('#89641B', '#FBF2D8'), + 'ISTJ': ('#476778', '#E8EFF3'), 'ISFJ': ('#9A5263', '#F7EAEE'), + 'ESTJ': ('#345A8B', '#E7EEF7'), 'ESFJ': ('#A1503E', '#FAEAE3'), + 'ISTP': ('#317469', '#E4F2EE'), 'ISFP': ('#795B98', '#F2EAF9'), + 'ESTP': ('#9B5B20', '#FFF0DE'), 'ESFP': ('#A3477A', '#F9E9F2'), +} +NS = '{http://www.w3.org/2000/svg}' + +class TypeIllustrations(unittest.TestCase): + def test_complete_set(self): + self.assertEqual({p.stem for p in ART.glob('*.svg')}, set(PALETTES)) + + def test_accessible_standalone_vectors_and_palettes(self): + for code, colors in PALETTES.items(): + with self.subTest(code=code): + source = (ART / f'{code}.svg').read_text(encoding='utf-8') + svg = ET.fromstring(source) + self.assertEqual(svg.tag, NS + 'svg') + self.assertEqual(svg.get('viewBox'), '0 0 240 240') + self.assertEqual(svg.get('role'), 'img') + title = svg.find(NS + 'title') + description = svg.find(NS + 'desc') + self.assertIsNotNone(title) + self.assertIsNotNone(description, 'A meaningful standalone description is required') + self.assertTrue(title.text.startswith(code + ':')) + self.assertGreater(len(description.text.strip()), 30) + self.assertEqual(svg.get('aria-labelledby'), title.get('id')) + self.assertEqual(svg.get('aria-describedby'), description.get('id')) + ids = [node.get('id') for node in svg.iter() if node.get('id')] + self.assertEqual(len(ids), len(set(ids))) + self.assertTrue(all(i.startswith(code.lower() + '-') for i in ids)) + for color in colors: + self.assertIn(color, source) + self.assertLess(len(source.encode()), 7000) + for node in svg.iter(): + self.assertNotIn(node.tag.removeprefix(NS), { + 'script', 'image', 'foreignObject', 'filter', 'text', 'animate', 'style'}) + for name, value in node.attrib.items(): + self.assertFalse(name.lower().startswith('on')) + self.assertFalse(name.endswith('href')) + self.assertNotIn('url(', value) + self.assertNotRegex(source, r'(?i) Date: Thu, 17 Sep 2026 02:19:21 +0300 Subject: [PATCH 2/9] Account for pre-existing stale generated metadata before the artwork rebuild --- .github/workflows/rebuild-16-type-artwork.yml | 38 ++++++++++++++++--- 1 file changed, 32 insertions(+), 6 deletions(-) diff --git a/.github/workflows/rebuild-16-type-artwork.yml b/.github/workflows/rebuild-16-type-artwork.yml index 822cff5..a951013 100644 --- a/.github/workflows/rebuild-16-type-artwork.yml +++ b/.github/workflows/rebuild-16-type-artwork.yml @@ -28,6 +28,26 @@ jobs: node-version: '22' - name: Install the existing site build dependency run: python -m pip install -r requirements.txt + - name: Identify already-stale generated outputs before changing artwork + run: | + python build.py + python - <<'PY' + import difflib, hashlib, json, pathlib, subprocess + changed = subprocess.check_output(['git', 'diff', '--name-only'], text=True).splitlines() + baseline = {} + for name in changed: + data = pathlib.Path(name).read_bytes() + baseline[name] = hashlib.sha256(data).hexdigest() + print('Pre-existing generated difference:', name) + if name.startswith('tools/') and name.endswith('.html'): + before = subprocess.check_output(['git', 'show', 'HEAD:' + name]).decode() + after = data.decode() + assert before.partition('')[2] == after.partition('')[2], name + ': body changed unexpectedly' + for line in difflib.unified_diff(before.splitlines(), after.splitlines(), n=2): + print(line[:300]) + pathlib.Path('/tmp/preexisting-generated.json').write_text(json.dumps(baseline)) + PY + git restore . - name: Regenerate artwork and its standalone consumers run: | python scripts/redraw_16_type_illustrations.py @@ -51,11 +71,17 @@ jobs: git config user.name 'github-actions[bot]' git config user.email '41898282+github-actions[bot]@users.noreply.github.com' git add assets/illustrations/16-types/*.svg tools/the_16_types.html assets/downloads/the_16_types.js catalog - if ! git diff --quiet; then - echo 'Unexpected changes outside the illustration build outputs:' - git diff --name-only - exit 1 - fi + python - <<'PY' + import hashlib, json, pathlib, subprocess + baseline = json.loads(pathlib.Path('/tmp/preexisting-generated.json').read_text()) + remaining = subprocess.check_output(['git', 'diff', '--name-only'], text=True).splitlines() + for name in remaining: + actual = hashlib.sha256(pathlib.Path(name).read_bytes()).hexdigest() + assert baseline.get(name) == actual, 'Unexpected non-artwork change: ' + name + print('Synchronizing unchanged pre-existing generated output:', name) + subprocess.run(['git', 'add', '--', name], check=True) + PY + if ! git diff --quiet; then exit 1; fi if git diff --cached --quiet; then exit 0; fi - git commit -m 'Rebuild all 16 SVG illustrations and standalone test outputs' + git commit -m 'Rebuild all 16 SVG illustrations and synchronize generated outputs' git push origin HEAD:refs/heads/codex/redesign-16-type-illustrations From 0e115915ee5cc26c8bd3f8fe0cfb3c5ac0b1ff91 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 16 Sep 2026 23:19:41 +0000 Subject: [PATCH 3/9] Rebuild all 16 SVG illustrations and synchronize generated outputs --- assets/downloads/the_16_types.js | 2 +- assets/downloads/the_enneagram.js | 2 +- assets/illustrations/16-types/ENFJ.svg | 58 ++++++++++++++++++++- assets/illustrations/16-types/ENFP.svg | 59 +++++++++++++++++++++- assets/illustrations/16-types/ENTJ.svg | 57 ++++++++++++++++++++- assets/illustrations/16-types/ENTP.svg | 59 +++++++++++++++++++++- assets/illustrations/16-types/ESFJ.svg | 62 ++++++++++++++++++++++- assets/illustrations/16-types/ESFP.svg | 61 +++++++++++++++++++++- assets/illustrations/16-types/ESTJ.svg | 66 +++++++++++++++++++++++- assets/illustrations/16-types/ESTP.svg | 66 +++++++++++++++++++++++- assets/illustrations/16-types/INFJ.svg | 64 ++++++++++++++++++++++- assets/illustrations/16-types/INFP.svg | 60 +++++++++++++++++++++- assets/illustrations/16-types/INTJ.svg | 65 +++++++++++++++++++++++- assets/illustrations/16-types/INTP.svg | 68 ++++++++++++++++++++++++- assets/illustrations/16-types/ISFJ.svg | 63 ++++++++++++++++++++++- assets/illustrations/16-types/ISFP.svg | 70 +++++++++++++++++++++++++- assets/illustrations/16-types/ISTJ.svg | 66 +++++++++++++++++++++++- assets/illustrations/16-types/ISTP.svg | 59 +++++++++++++++++++++- catalog/web.html | 4 +- index.html | 4 +- tools/the_16_types.html | 8 +-- tools/the_enneagram.html | 25 +++++---- 22 files changed, 995 insertions(+), 53 deletions(-) diff --git a/assets/downloads/the_16_types.js b/assets/downloads/the_16_types.js index 59ca4cf..7106663 100644 --- a/assets/downloads/the_16_types.js +++ b/assets/downloads/the_16_types.js @@ -1,3 +1,3 @@ /* Generated by build.py; loaded only for local-file downloads. */ window.NHLocalDownloads = window.NHLocalDownloads || Object.create(null); -window.NHLocalDownloads["the_16_types"] = "<!DOCTYPE html>
<html lang="he" dir="rtl">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <meta id="theme-color" name="theme-color" content="#fcf7f1">
  <script>
    (() => {
      let saved;
      try { saved = localStorage.getItem("nhlocal.16-types.theme"); } catch {}
      const dark = saved === "dark" || (saved !== "light" && matchMedia("(prefers-color-scheme: dark)").matches);
      document.documentElement.dataset.theme = dark ? "dark" : "light";
      document.getElementById("theme-color").content = dark ? "#171d28" : "#fcf7f1";
    })();
  </script>
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 64 64'%3E%3Crect width='64' height='64' rx='18' fill='%23e9eef5'/%3E%3Ctext x='32' y='45' font-family='Arial' font-size='36' font-weight='700' text-anchor='middle' fill='%23526b91'%3E16%3C/text%3E%3C/svg%3E">
  <style>/* Embedded Assistant font license:
Copyright 2020 The Assistant Project Authors (https://github.com/hafontia/Assistant).
Copyright 2010 The Source Sans Pro Authors (https://github.com/adobe-fonts/source-sans-pro), with Reserved Font Name 'Source'.
Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries.

This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at:
http://scripts.sil.org/OFL


-----------------------------------------------------------
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------

PREAMBLE
The goals of the Open Font License (OFL) are to stimulate worldwide
development of collaborative font projects, to support the font creation
efforts of academic and linguistic communities, and to provide a free and
open framework in which fonts may be shared and improved in partnership
with others.

The OFL allows the licensed fonts to be used, studied, modified and
redistributed freely as long as they are not sold by themselves. The
fonts, including any derivative works, can be bundled, embedded,
redistributed and/or sold with any software provided that any reserved
names are not used by derivative works. The fonts and derivatives,
however, cannot be released under any other type of license. The
requirement for fonts to remain under this license does not apply
to any document created using the fonts or their derivatives.

DEFINITIONS
"Font Software" refers to the set of files released by the Copyright
Holder(s) under this license and clearly marked as such. This may
include source files, build scripts and documentation.

"Reserved Font Name" refers to any names specified as such after the
copyright statement(s).

"Original Version" refers to the collection of Font Software components as
distributed by the Copyright Holder(s).

"Modified Version" refers to any derivative made by adding to, deleting,
or substituting -- in part or in whole -- any of the components of the
Original Version, by changing formats or by porting the Font Software to a
new environment.

"Author" refers to any designer, engineer, programmer, technical
writer or other person who contributed to the Font Software.

PERMISSION & CONDITIONS
Permission is hereby granted, free of charge, to any person obtaining
a copy of the Font Software, to use, study, copy, merge, embed, modify,
redistribute, and sell modified and unmodified copies of the Font
Software, subject to the following conditions:

1) Neither the Font Software nor any of its individual components,
in Original or Modified Versions, may be sold by itself.

2) Original or Modified Versions of the Font Software may be bundled,
redistributed and/or sold with any software, provided that each copy
contains the above copyright notice and this license. These can be
included either as stand-alone text files, human-readable headers or
in the appropriate machine-readable metadata fields within text or
binary files as long as those fields can be easily viewed by the user.

3) No Modified Version of the Font Software may use the Reserved Font
Name(s) unless explicit written permission is granted by the corresponding
Copyright Holder. This restriction only applies to the primary font name as
presented to the users.

4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
Software shall not be used to promote, endorse or advertise any
Modified Version, except to acknowledge the contribution(s) of the
Copyright Holder(s) and the Author(s) or with their explicit written
permission.

5) The Font Software, modified or unmodified, in part or in whole,
must be distributed entirely under this license, and must not be
distributed under any other license. The requirement for fonts to
remain under this license does not apply to any document created
using the Font Software.

TERMINATION
This license becomes null and void if any of the above conditions are
not met.

DISCLAIMER
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
OTHER DEALINGS IN THE FONT SOFTWARE.

*/
@font-face{font-family:Assistant;src:url(data:font/ttf;base64,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) format('truetype');font-weight:200 800;font-display:swap}
:root {
  color-scheme: light;
  --on-accent: #fff;
  --surface-warm: #f6f1ea;
  --surface-cool: #f0f3f7;
  --sheet-border: #ffffffad;
  --sheet-shadow: 10px 12px 0 #efe2d565, 0 18px 40px #687a9610;
  --sheet-row: #fffdf9;
  --sheet-row-alt: #f9f2eb;
  --notice-bg: #f6ecdc;
  --notice-line: #e7d4b4;
  --track: #dce1e8;
  --paper: #fcf7f1;
  --white: #fffdfa;
  --ink: #3b414e;
  --muted: #686772;
  --accent: #526b91;
  --accent-hover: #435b80;
  --clay: #9b634f;
  --blue-soft: #e9eef5;
  --peach-soft: #f5e6dc;
  --line: #e4dfd9;
  --green: #526b91;
  --error: #aa3b37;
  --ease: 180ms ease;
  --soft-shadow: 0 12px 35px #63564c08;
}
:root[data-theme="dark"] {
  color-scheme: dark;
  --paper: #171d28;
  --white: #222c3a;
  --ink: #edf1f7;
  --muted: #b6c1d1;
  --accent: #a5c1eb;
  --accent-hover: #bed2f0;
  --on-accent: #18263b;
  --clay: #e4b298;
  --blue-soft: #293b52;
  --peach-soft: #3a302e;
  --line: #415065;
  --surface-warm: #2b3039;
  --surface-cool: #263241;
  --sheet-border: #35465b;
  --sheet-shadow: 10px 12px 0 #111722, 0 18px 40px #0002;
  --sheet-row: #222e3e;
  --sheet-row-alt: #32333b;
  --notice-bg: #3a3229;
  --notice-line: #64553f;
  --track: #445066;
  --green: #a5c1eb;
  --error: #ffaba5;
  --soft-shadow: 0 10px 30px #0002;
}
* { box-sizing: border-box; }
body { margin: 0; background: var(--paper); color: var(--ink); font-family: Assistant, "Segoe UI", Arial, sans-serif; font-size: 18px; line-height: 1.7; }
button, input, select { font: inherit; }
button, a, summary, select { touch-action: manipulation; }
button { cursor: pointer; color: inherit; }
a { color: inherit; }
button:disabled { cursor: default; opacity: .4; }
[hidden] { display: none !important; }
::selection { background: #d6e1f0; color: var(--ink); }
:focus-visible { outline: 3px solid var(--accent); outline-offset: 5px; }
h1, h2, h3, p { margin-top: 0; }
h1, h2, h3 { line-height: 1.3; font-weight: 700; letter-spacing: 0; }
h2 { font-size: clamp(1.8rem, 3.4vw, 2.7rem); }
h3 { font-size: 1.3rem; }
p { margin-bottom: 1em; }
.shell { max-width: 1170px; padding-inline: 40px; margin-inline: auto; }
.site-header { min-height: 108px; display: flex; justify-content: space-between; align-items: center; gap: 20px; }
.brand { display: flex; align-items: center; gap: 11px; font-size: 1.28rem; font-weight: 550; text-decoration: none; }
.brand-mark { display: grid; place-items: center; flex: 0 0 auto; width: 52px; height: 52px; border-radius: 18px; background: var(--blue-soft); color: var(--accent); font-size: 1.5rem; font-weight: 750; line-height: 1; letter-spacing: 0; direction: ltr; }
.back-link { font-size: .9rem; text-decoration: none; color: var(--muted); padding: 8px 13px; border-radius: 20px; }
.header-actions { display: flex; align-items: center; gap: 16px; }
.theme-toggle { display: grid; place-items: center; width: 44px; height: 44px; flex-shrink: 0; padding: 0; border: 1px solid var(--line); border-radius: 50%; background: var(--white); color: var(--accent); }
.theme-toggle:hover { background: var(--blue-soft); }
.theme-toggle .icon { width: 21px; height: 21px; }
.theme-toggle .theme-sun, [data-theme="dark"] .theme-toggle .theme-moon { display: none; }
[data-theme="dark"] .theme-toggle .theme-sun { display: block; }
.back-link:hover { color: var(--accent); background: var(--blue-soft); }
.back-link { display: inline-flex; align-items: center; gap: 7px; }
.icon { display: block; width: 1.1em; height: 1.1em; flex: 0 0 auto; fill: none; stroke: currentColor; stroke-width: 1.8; stroke-linecap: round; stroke-linejoin: round; }
.screen { animation: arrive .28s ease both; }
.hero { display: grid; grid-template-columns: 1.2fr 1fr; gap: 78px; align-items: center; padding-block: 43px 58px; }
.hero h1 { font-size: clamp(3rem, 5.3vw, 4.7rem); font-weight: 800; line-height: 1.2; letter-spacing: -.015em; margin: 0 0 27px; }
.hero h1 em { font-style: normal; color: var(--clay); font-weight: 800; }
.lead { color: var(--muted); font-size: 1.06rem; line-height: 1.95; max-width: 550px; }
.hero .lead { margin-bottom: 28px; }
.button { display: inline-flex; align-items: center; justify-content: center; gap: 12px; min-height: 48px; max-width: 100%; padding: 11px 22px; border: 1px solid transparent; border-radius: 14px; font-size: 1.125rem; line-height: 1.3; font-weight: 700; text-align: center; text-decoration: none; transition: background var(--ease), transform var(--ease), box-shadow var(--ease); }
.hero-copy > .button { min-height: 52px; padding: 12px 24px; font-size: 1.25rem; gap: 18px; }
.primary { color: var(--on-accent); background: var(--accent); box-shadow: 0 3px 8px #526b9118; }
.primary:not(:disabled):hover { background: var(--accent-hover); transform: translateY(-1px); box-shadow: 0 4px 10px #526b9126; }
.primary:not(:disabled):active { transform: translateY(0); box-shadow: none; }
.secondary { color: var(--ink); background: var(--white); border-color: var(--line); }
.secondary:hover { background: var(--blue-soft); border-color: var(--line); }
.text-button { border: 0; background: transparent; color: var(--muted); padding: 10px 3px; border-radius: 8px; font-size: .85rem; text-decoration: underline; text-decoration-color: transparent; text-underline-offset: 5px; }
.text-button:hover { color: var(--accent); text-decoration-color: currentColor; }
.micro { font-size: .81rem; color: var(--muted); line-height: 1.8; margin-block: 15px 0; }
.type-sheet { position: relative; padding: 20px 27px 30px; background: var(--blue-soft); border: 7px solid var(--sheet-border); border-radius: 43% 43% 37px 37px; transform: rotate(-3deg); box-shadow: var(--sheet-shadow); }
.sheet-number { font-size: 9.2rem; font-weight: 650; line-height: 1.5; letter-spacing: -.11em; text-align: center; direction: ltr; padding-inline-end: .08em; color: var(--accent); }
.sheet-axes { display: grid; gap: 9px; }
.sheet-axes > div { display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 8px; align-items: center; padding: 10px 18px; background: var(--sheet-row); border-radius: 24px; font-size: .91rem; box-shadow: 0 2px 0 #c7d2df44; }
.sheet-axes > div:nth-child(even) { background: var(--sheet-row-alt); }
.sheet-axes > div > span:last-child { text-align: left; }
.sheet-axes bdi { text-align: center; font-size: .8rem; letter-spacing: .06em; color: var(--accent); }
.intro-details { margin: 17px auto 44px; display: grid; grid-template-columns: 1fr 1fr; gap: 16px; align-items: start; }
details { padding: 21px 22px; border: 1px solid var(--line); background: var(--white); border-radius: 23px; box-shadow: 0 4px 14px #60564e03; }
summary { cursor: pointer; font-weight: 600; list-style-position: outside; margin-inline-start: 16px; padding-inline-start: 7px; }
summary::marker { color: #7c8ba1; font-size: .8em; }
details > p, details > div { margin-top: 18px; color: var(--muted); font-size: .93rem; }
.eyebrow { display: inline-flex; align-items: center; gap: 9px; font-size: .83rem; font-weight: 450; color: var(--muted); }
.quiz-wrap { max-width: 850px; margin: 26px auto 55px; }
.quiz-top, .progress-heading { display: flex; justify-content: space-between; align-items: center; gap: 16px; }
.quiz-top { margin-bottom: 15px; }
.progress-heading { font-size: .84rem; margin-bottom: 10px; color: var(--muted); }
progress { display: block; border: 0; background: var(--track); width: 100%; height: 7px; border-radius: 10px; overflow: hidden; accent-color: var(--accent); }
progress::-webkit-progress-bar { background: var(--track); border-radius: 10px; }
progress::-webkit-progress-value { background: var(--accent); border-radius: 10px; transition: width .2s ease; }
progress::-moz-progress-bar { background: var(--accent); border-radius: 10px; }
.question-card { margin-top: 27px; padding: 36px 37px 32px; background: var(--white); border: 1px solid var(--line); border-radius: 32px; box-shadow: var(--soft-shadow); }
.question-card h2 { font-size: clamp(1.4rem, 2.6vw, 1.9rem); font-weight: 700; line-height: 1.55; margin: 0 0 25px; min-height: 3.1em; letter-spacing: 0; }
.situation-options { display: grid; grid-template-columns: 1fr 1fr; gap: 15px; margin-bottom: 25px; }
.situation { padding: 20px; background: var(--surface-warm); border-radius: 22px; }
.situation > span { display: grid; place-items: center; width: 34px; height: 34px; border-radius: 13px; background: var(--blue-soft); color: var(--accent); font-weight: 500; font-size: 1.05rem; margin-bottom: 12px; }
.situation p { margin: 0; font-size: 1.125rem; line-height: 1.7; }
fieldset { border: 0; padding: 0; margin: 0; min-width: 0; }
legend { font-size: 1rem; text-align: center; margin: 0 auto 16px; padding: 0; color: var(--muted); }
.answer-options { display: grid; grid-template-columns: repeat(5, minmax(0, 1fr)); gap: 9px; }
.answer-choice { position: relative; cursor: pointer; }
.answer-choice input { position: absolute; opacity: 0; width: 1px; height: 1px; }
.answer-choice > span { display: flex; align-items: center; justify-content: center; flex-direction: column; gap: 12px; padding: 15px 3px; min-height: 98px; font-size: 1rem; font-weight: 600; line-height: 1.35; text-align: center; border: 1px solid var(--line); border-radius: 18px; background: var(--white); transition: background var(--ease), border-color var(--ease), box-shadow var(--ease); }
.answer-choice i { display: block; width: 19px; height: 19px; border: 1.5px solid var(--muted); border-radius: 50%; position: relative; }
.answer-choice:nth-child(1) i, .answer-choice:nth-child(5) i { width: 24px; height: 24px; }
.answer-choice:nth-child(3) i { width: 14px; height: 14px; }
.answer-choice:hover > span { background: var(--surface-cool); border-color: var(--accent); }
.answer-choice input:checked + span { background: var(--accent); color: var(--on-accent); border-color: var(--accent); box-shadow: 0 2px 7px #526b9118; }
.answer-choice input:checked + span i { border-color: var(--on-accent); background: var(--on-accent); }
.answer-choice input:checked + span i:after { content: ""; position: absolute; inset: 4px; border-radius: 50%; background: var(--accent); }
.answer-choice input:focus-visible + span { outline: 3px solid var(--accent); outline-offset: 4px; }
.quiz-nav { display: flex; justify-content: space-between; gap: 16px; margin-top: 25px; }
.quiz-nav .button { min-width: 112px; }
.quiz-bottom { display: flex; justify-content: flex-end; margin-top: 18px; }
.error { color: var(--error); font-size: .9rem; margin: 18px 0 0; }
.reading-width { max-width: 850px; margin: 38px auto 60px; }
.reading-width h2 { margin-top: 12px; }
.review-group { margin-top: 28px; }
.review-question { display: block; width: 100%; text-align: start; border: 1px solid var(--line); background: var(--white); border-radius: 18px; padding: 17px 20px; margin-bottom: 10px; font-size: .97rem; }
.review-question:hover { background: var(--surface-cool); }
.review-question small { display: block; color: var(--muted); margin-top: 7px; font-size: .85rem; }
.action-row { display: flex; gap: 12px; align-items: center; flex-wrap: wrap; margin-top: 25px; }
.result-intro { margin: 35px 0 29px; }
.result-intro h2 { margin: 15px 0; }
.result-intro .lead { max-width: 750px; }
main.shell:has(#results:not([hidden])) { max-width: 1400px; }
.result-layout { display: grid; grid-template-columns: minmax(0, 1.75fr) minmax(320px, 1fr); gap: 27px; align-items: start; }
#results, .type-profile, .type-chip { --type-accent: var(--type-light-accent, var(--accent)); --type-soft: var(--type-light-soft, var(--blue-soft)); }
[data-theme="dark"] #results, [data-theme="dark"] .type-profile, [data-theme="dark"] .type-chip { --type-accent: var(--type-dark-accent, var(--accent)); --type-soft: var(--type-dark-soft, var(--blue-soft)); }
#results .profile-card { border-color: color-mix(in srgb, var(--type-accent) 30%, var(--line)); }
/* Keep the illustration backdrop distinct from its surrounding surface. */
.type-profile, .type-chip { --type-art-surface: color-mix(in srgb, var(--type-soft) 40%, var(--white)); }
.type-profile .profile-top { background: var(--type-art-surface); }
.type-profile .type-code, .profile-card .type-profile h4, .preview-card.type-profile h4 { color: var(--type-accent); }
.type-profile .experiment { background: var(--type-soft); }
#results .axis-pole.is-dominant { border-color: var(--type-accent); color: var(--type-accent); }
#results .axis-bar i.is-dominant { background: var(--type-accent); }
.profile-card { background: var(--white); padding: 30px; border: 1px solid var(--line); border-radius: 30px; box-shadow: var(--soft-shadow); }
.profile-top { display: flex; align-items: center; justify-content: space-between; gap: 14px; padding: 16px 21px; margin-bottom: 24px; border-radius: 22px; background: var(--blue-soft); }
.profile-codes { display: flex; flex-wrap: wrap; align-items: baseline; gap: 8px 12px; }
.profile-codes .he-code { margin: 0; }
.profile-identity { min-width: 0; }
.profile-identity .profile-name { margin: 12px 0 8px; }
.profile-identity p { margin: 0; font-size: .98rem; color: var(--muted); }
.profile-character { display: block; width: clamp(120px, 16vw, 210px); height: auto; flex: 0 0 auto; }
.type-character { display: block; width: 96px; height: 96px; align-self: center; }
.type-code { font-size: 2.8rem; letter-spacing: .02em; font-weight: 600; line-height: 1.15; color: var(--accent); }
.he-code { font-size: 1.2rem; margin-inline-start: 12px; color: var(--muted); }
.profile-name { font-size: 1.7rem; margin-bottom: 15px; }
.profile-card p { font-size: 1.0625rem; line-height: 1.8; }
.profile-card h4 { font-size: 1.02rem; margin: 25px 0 9px; color: var(--clay); font-weight: 500; }
.profile-card ul { padding-inline-start: 20px; font-size: 1.05rem; }
.profile-card li { margin-bottom: 7px; }
.experiment { padding: 18px 20px; border-radius: 20px; background: var(--peach-soft); margin-top: 25px; }
.experiment h4 { margin-top: 0; }
.experiment p { margin-bottom: 0; }
.axis-panel { container: preferences / inline-size; padding: 28px 25px; background: var(--surface-cool); border: 1px solid var(--line); border-radius: 30px; }
.axis-row { margin: 26px 0; padding-bottom: 24px; border-bottom: 1px solid var(--line); }
.axis-row:last-child { margin-bottom: 0; padding-bottom: 0; border-bottom: 0; }
.axis-title { font-size: 1rem; margin-bottom: 12px; }
.axis-title b { font-weight: 650; }
.axis-labels { display: grid; grid-template-columns: 1fr 1fr; gap: 8px; }
.axis-pole { display: flex; flex-direction: row; align-items: center; justify-content: space-between; gap: 8px; white-space: nowrap; padding: 10px 12px; border: 2px solid transparent; border-radius: 14px; color: var(--muted); }
.axis-pole strong { font-weight: 500; }
.axis-pole.is-dominant { border-color: var(--accent); background: var(--white); color: var(--accent); }
.axis-pole.is-dominant strong { font-weight: 800; }
.axis-pole bdi { font-size: .95rem; font-weight: 650; }
.axis-bar { display: flex; height: 10px; border-radius: 20px; background: var(--track); margin: 12px 0; overflow: hidden; direction: rtl; }
.axis-bar i { display: block; height: 100%; background: var(--track); }
.axis-bar i.is-dominant { background: var(--accent); }
.axis-bar i + i { border-inline-start: 2px solid var(--white); }
.axis-explain { font-size: .96rem; color: var(--muted); line-height: 1.7; margin: 0; }
.axis-explain strong { color: var(--ink); }
.axis-note { font-size: .93rem; color: var(--muted); line-height: 1.7; }
.notice { border: 1px solid var(--notice-line); background: var(--notice-bg); border-radius: 20px; padding: 18px 23px; font-size: .96rem; margin: 25px 0; }
.notice p:last-child { margin-bottom: 0; }
.nearby { margin-top: 27px; padding: 24px; background: var(--surface-warm); border-radius: 25px; }
.nearby p { font-size: .95rem; color: var(--muted); }
.type-chips, .type-picker { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 12px; }
.type-chip { display: flex; flex-direction: column; align-items: stretch; gap: 8px; min-width: 0; border: 1px solid var(--line); border-radius: 18px; background: var(--white); color: var(--ink); padding: 16px; text-align: start; cursor: pointer; transition: background var(--ease), border-color var(--ease); }
.type-chip { border-block-start: 3px solid var(--type-accent); }
.type-chip:hover { background: var(--type-art-surface); border-color: var(--type-accent); }
.type-chip[aria-pressed="true"] { background: var(--type-art-surface); border-color: var(--type-accent); box-shadow: inset 0 0 0 1px var(--type-accent); }
.type-chip-codes { display: flex; align-items: baseline; justify-content: space-between; gap: 8px; }
.type-chip-codes bdi { font-size: 1.3rem; font-weight: 750; color: var(--type-accent); letter-spacing: .04em; }
.type-chip-codes > span { color: var(--muted); font-size: .95rem; }
.type-chip-name { font-size: 1.05rem; font-weight: 650; line-height: 1.4; }
.result-disclaimer { max-width: 930px; }
.explore { margin: 27px 0 40px; }
.explore summary { font-size: 1.2rem; font-weight: 650; }
#type-preview { scroll-margin-top: 24px; }
.preview-card { background: var(--white); padding: 15px; max-width: 820px; color: var(--ink); }
.preview-card p { font-size: .97rem; }
.preview-card h4 { margin-bottom: 8px; }
.preview-card ul { padding-inline-start: 22px; }
.site-footer { display: flex; flex-wrap: wrap; align-items: center; gap: 12px; padding-block: 10px 30px; font-size: .83rem; color: var(--muted); }
.site-footer > div { display: flex; gap: 24px; }
.site-footer .text-button { font-size: .82rem; }
.site-footer section { flex-basis: 100%; max-width: 850px; font-size: .97rem; margin-top: 20px; }
.site-footer section h2 { font-size: 1.6rem; }
.site-footer li { margin-block: 8px; }
.storage-status { background: var(--notice-bg); padding: 14px 19px; border-radius: 16px; font-size: .91rem; }
.toast { position: fixed; bottom: 24px; inset-inline: 20px; max-width: 500px; margin: auto; background: var(--accent-hover); color: var(--on-accent); padding: 14px 22px; border-radius: 20px; z-index: 10; text-align: center; box-shadow: 0 6px 22px #526b9130; font-size: .93rem; }
dialog { border: 1px solid var(--line); border-radius: 28px; padding: 30px; background: var(--paper); color: var(--ink); max-width: 540px; width: calc(100% - 32px); box-shadow: 0 25px 80px #3b414e30; }
dialog h2 { font-size: 1.8rem; }
dialog::backdrop { background: #41495c80; backdrop-filter: blur(4px); }
.sr-only { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0,0,0,0); white-space: nowrap; }
.skip-link { position: fixed; top: -100px; right: 20px; padding: 12px; background: var(--white); z-index: 99; }
.skip-link:focus { top: 15px; }
@keyframes arrive { from { opacity: 0; transform: translateY(5px); } to { opacity: 1; transform: translateY(0); } }
@media (min-width: 1450px) { .hero { padding-block: 62px 65px; } }
@media (max-width: 900px) {
  .shell { padding-inline: 28px; }
  .hero { gap: 35px; padding-block: 35px 40px; }
  .hero h1 { font-size: 3.8rem; }
  .type-sheet { padding: 17px 18px 24px; border-width: 5px; }
  .sheet-number { font-size: 8rem; }
  .sheet-axes > div { font-size: .8rem; padding: 9px 12px; gap: 4px; }
  .sheet-axes bdi { font-size: .75rem; }
  .result-layout { grid-template-columns: 1fr; gap: 20px; }
  .type-chips, .type-picker { grid-template-columns: repeat(2, minmax(0, 1fr)); }
  .profile-card { padding: 25px; }
  .axis-panel { padding: 24px 20px; }
  .axis-title { flex-wrap: wrap; gap: 3px 10px; }
}
@media (max-width: 620px) {
  .header-actions { gap: 9px; }
  .brand { flex-shrink: 0; }
  .shell { padding-inline: 20px; }
  .site-header { min-height: 88px; }
  .brand { font-size: 1.08rem; gap: 9px; }
  .brand-mark { width: 44px; height: 44px; font-size: 1.3rem; border-radius: 17px; }
  .back-link { font-size: .78rem; padding-inline: 4px; }
  .hero { grid-template-columns: 1fr; padding-block: 24px 34px; gap: 35px; }
  .hero h1 { font-size: clamp(2.9rem, 12vw, 3.8rem); margin-bottom: 19px; line-height: 1.23; }
  .lead { font-size: 1rem; line-height: 1.95; }
  .hero .lead { margin-bottom: 23px; }
  .hero-copy > .button { width: auto; }
  .type-sheet { transform: rotate(-2deg); padding: 19px 18px 20px; border-radius: 50px 50px 30px 30px; display: grid; grid-template-columns: .8fr 1.7fr; gap: 12px; margin-inline: 5px; border-width: 4px; box-shadow: var(--sheet-shadow); }
  .sheet-number { font-size: 4.8rem; line-height: 1; align-self: center; }
  .sheet-axes { gap: 7px; }
  .sheet-axes > div { font-size: .75rem; padding: 7px 10px; gap: 3px; border-radius: 15px; }
  .sheet-axes bdi { font-size: .62rem; letter-spacing: 0; }
  .intro-details { grid-template-columns: 1fr; gap: 11px; margin-block: 12px 22px; }
  details { padding: 19px 17px; border-radius: 21px; }
  summary { font-size: .92rem; padding-inline-start: 3px; }
  .quiz-wrap { margin-top: 16px; }
  .quiz-top { gap: 9px; margin-bottom: 10px; }
  .quiz-top .eyebrow, .quiz-top .text-button { font-size: .75rem; }
  .progress-heading { font-size: .77rem; }
  .question-card { padding: 25px 15px; border-radius: 25px; margin-top: 23px; }
  .question-card h2 { font-size: 1.3rem; min-height: 0; line-height: 1.6; margin-bottom: 22px; }
  .situation-options { gap: 10px; margin-bottom: 23px; }
  .situation { padding: 14px 12px 16px; border-radius: 17px; }
  .situation p { font-size: 1rem; line-height: 1.9; }
  .situation > span { width: 29px; height: 29px; border-radius: 10px; font-size: .95rem; margin-bottom: 11px; }
  .situation-options { grid-template-columns: 1fr; }
  .situation { display: grid; grid-template-columns: 29px 1fr; gap: 12px; align-items: start; }
  .situation > span { margin: 0; }
  legend { font-size: .9375rem; }
  .answer-options { grid-template-columns: 1fr; gap: 8px; }
  .answer-choice > span { flex-direction: row; justify-content: flex-start; font-size: 1.0625rem; min-height: 49px; padding: 11px 16px; border-radius: 13px; gap: 13px; text-align: start; }
  .answer-choice i { width: 17px; height: 17px; }
  .answer-choice:nth-child(1) i, .answer-choice:nth-child(5) i { width: 21px; height: 21px; }
  .quiz-nav .button { padding-inline: 18px; min-height: 48px; font-size: 1.125rem; }
  .quiz-nav { gap: 12px; }
  .quiz-bottom .text-button { font-size: .8rem; }
  .reading-width { margin-block: 28px; }
  .result-intro { margin-top: 25px; }
  .type-chip { padding: 12px; }
  .type-chip-codes { flex-wrap: wrap; gap: 4px 8px; }
  .result-layout { grid-template-columns: 1fr; gap: 22px; }
  .profile-card { padding: 24px 20px; border-radius: 25px; }
  .profile-top { padding: 17px; border-radius: 18px; }
  .axis-panel { padding: 25px 20px; border-radius: 25px; }
  .result-actions { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
  .result-actions .primary { grid-column: 1 / -1; justify-self: start; }
  .result-actions .button { font-size: 1.0625rem; padding-inline: 16px; }
  .result-actions .text-button { font-size: .81rem; }
  .site-footer { display: block; padding-bottom: 20px; }
  .site-footer > div { margin-top: 8px; justify-content: space-between; gap: 8px; flex-wrap: wrap; }
  .site-footer .text-button { font-size: .72rem; }
  .notice { font-size: .9rem; padding: 17px; }
  .profile-character { width: 108px; }
  .profile-top { gap: 8px; padding: 12px; }
  .profile-identity .profile-name { font-size: 1.35rem; }
  .profile-identity p { font-size: .85rem; }
  .type-code { font-size: 2.2rem; }
  .profile-name { font-size: 1.6rem; }
  .axis-title { font-size: .9rem; }
  .axis-title span { font-size: .76rem; }
  .axis-labels { font-size: .86rem; }
}
@container preferences (max-width: 350px) {
  .axis-labels { grid-template-columns: 1fr; gap: 6px; }
  .axis-pole { padding: 9px 12px; }
}
@media (max-width: 360px) {
  .shell { padding-inline: 15px; }
  .hero h1 { font-size: 2.9rem; }
  .type-sheet { padding-inline: 12px; gap: 8px; }
  .sheet-number { font-size: 4rem; }
  .sheet-axes > div { font-size: .68rem; padding-inline: 8px; }
  .question-card { padding-inline: 12px; }
  .answer-options { gap: 4px; }
  .answer-choice > span { font-size: 1.0625rem; }
  .quiz-top .eyebrow, .quiz-top .text-button { font-size: .7rem; }
}
@media (prefers-reduced-motion: reduce) { *, *:before, *:after { animation: none !important; transition: none !important; scroll-behavior: auto !important; } }
@media print {
  :root, :root[data-theme="dark"] { color-scheme: light; --paper: #fff; --white: #fff; --ink: #303640; --muted: #525b68; --accent: #526b91; --on-accent: #fff; --clay: #815340; --blue-soft: #eef2f7; --peach-soft: #f7eee7; --line: #ccc; --surface-warm: #faf7f2; --surface-cool: #f4f6f8; --notice-bg: #faf5ed; --notice-line: #ddd; --track: #dce1e8; }
  body { background: white; color: #303640; font-size: 11pt; }
  #results, .type-profile { --type-accent: var(--type-light-accent, #526b91) !important; --type-soft: var(--type-light-soft, #eef2f7) !important; }
  .site-header, .site-footer, .result-actions, .explore, .toast, .storage-status, .skip-link, .screen:not(#results) { display: none !important; }
  .shell { max-width: none; padding: 0; }
  .result-layout { display: block; }
  .profile-card { background: white !important; color: #303640; border: 1px solid #aaa; box-shadow: none; }
  .profile-card p, .profile-card h4 { color: #303640; }
  .axis-panel { margin-top: 20px; break-inside: avoid; }
  .axis-bar { print-color-adjust: exact; -webkit-print-color-adjust: exact; }
  .nearby { break-inside: avoid; }
  .type-chips button { color: #303640; background: white; }
  .result-intro { margin-top: 0; }
  #results[hidden] { display: none !important; }
  dialog { display: none; }
}

/* Clear question choices in dark mode and a separate restart action. */
#fresh { display: block; width: fit-content; margin-top: 8px; }
@media screen {
  :root[data-theme="dark"] .question-card legend { color: var(--ink); font-size: 1.125rem; font-weight: 650; line-height: 1.5; }
  :root[data-theme="dark"] .situation { background: #303f53; border: 1px solid #52667e; }
  :root[data-theme="dark"] .situation p { color: #f5f7fb; font-size: 1.125rem; font-weight: 550; line-height: 1.7; }
  :root[data-theme="dark"] .situation > span { background: #3c5270; color: #f3f7ff; font-weight: 700; }
}

#reset-dialog .action-row { justify-content: flex-end; }
</style>
<!-- catalog metadata:start -->
<title>מבחן 16 הטיפוסים | ארגז הכלים של NH Local</title>
    <meta name="description" content="שאלון עצמאי בעברית בהשראת MBTI, עם 64 שאלות, שמירת התקדמות ותוצאה מפורטת. פועל גם ללא חיבור לרשת.">
    <link rel="canonical" href="https://tools.ze-kal.top/tools/the_16_types.html">
    <meta property="og:type" content="website">
    <meta property="og:locale" content="he_IL">
    <meta property="og:site_name" content="ארגז הכלים של NH Local">
    <meta property="og:title" content="מבחן 16 הטיפוסים | ארגז הכלים של NH Local">
    <meta property="og:description" content="שאלון עצמאי בעברית בהשראת MBTI, עם 64 שאלות, שמירת התקדמות ותוצאה מפורטת. פועל גם ללא חיבור לרשת.">
    <meta property="og:url" content="https://tools.ze-kal.top/tools/the_16_types.html">
    <meta property="og:image" content="https://tools.ze-kal.top/assets/social-card.png">
    <meta property="og:image:width" content="1200"><meta property="og:image:height" content="630">
    <meta property="og:image:alt" content="ארגז הכלים של NH Local: סקילים, כלי דפדפן, סקריפטים ותוספי כרום">
    <meta name="twitter:card" content="summary_large_image">
    <script type="application/ld+json">{"@context": "https://schema.org", "@graph": [{"@type": "WebSite", "@id": "https://tools.ze-kal.top/#website", "url": "https://tools.ze-kal.top/", "name": "ארגז הכלים של NH Local", "inLanguage": "he"}, {"@type": "WebPage", "@id": "https://tools.ze-kal.top/tools/the_16_types.html", "url": "https://tools.ze-kal.top/tools/the_16_types.html", "name": "מבחן 16 הטיפוסים | ארגז הכלים של NH Local", "description": "שאלון עצמאי בעברית בהשראת MBTI, עם 64 שאלות, שמירת התקדמות ותוצאה מפורטת. פועל גם ללא חיבור לרשת.", "inLanguage": "he", "isPartOf": {"@id": "https://tools.ze-kal.top/#website"}}]}</script>
<!-- catalog metadata:end -->
</head>
<body>
<a class="skip-link" href="#main">דילוג לתוכן</a>
<header class="site-header shell">
  <a class="brand" href="the_16_types.html" aria-label="16 הטיפוסים, דף הפתיחה"><span class="brand-mark" aria-hidden="true">16</span><span>הטיפוסים</span></a>
  <div class="header-actions">
    <a class="back-link" href="../index.html">לארגז הכלים <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M7 17 17 7M7 7h10v10"/></svg></a>
    <button id="theme-toggle" class="theme-toggle" type="button" aria-label="מצב אפל" aria-pressed="false" title="מעבר למצב אפל">
      <svg class="icon theme-moon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M20.5 13A8.5 8.5 0 0 1 11 3.5 8.5 8.5 0 1 0 20.5 13Z"/></svg>
      <svg class="icon theme-sun" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><circle cx="12" cy="12" r="4"/><path d="M12 2v2m0 16v2M2 12h2m16 0h2M5 5l1.5 1.5m11 11L19 19M5 19l1.5-1.5m11-11L19 5"/></svg>
    </button>
  </div>
</header>
<main id="main" class="shell" tabindex="-1">
  <section id="welcome" class="screen">
    <div class="hero">
      <div class="hero-copy">
        <h1>מה בדרך כלל<br><em>טבעי לך?</em></h1>
        <p class="lead">לחשוב בקול או לעבד בשקט? לתכנן מראש או להחליט בדרך?<br>56 שאלות על ההעדפות שלך ביומיום, ובסופן פרופיל לפי מודל 16 הטיפוסים.</p>
        <button id="start" class="button primary">להתחלת השאלון <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M19 12H5m7-7-7 7 7 7"/></svg></button>
        <button id="resume" class="button primary" hidden><span>להמשיך מאיפה שעצרתי</span> <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M19 12H5m7-7-7 7 7 7"/></svg></button>
        <button id="fresh" class="text-button" hidden>להתחיל מחדש ולמחוק את ההתקדמות</button>
      </div>
      <aside class="type-sheet" aria-label="ארבעת צירי השאלון">
        <div class="sheet-number" aria-hidden="true">16</div>
        <div class="sheet-axes"><div><span>מוחצן</span><bdi>E / I</bdi><span>מופנם</span></div><div><span>קונקרטי</span><bdi>S / N</bdi><span>עיוני</span></div><div><span>שכלתני</span><bdi>T / F</bdi><span>רגשי</span></div><div><span>גבולני</span><bdi>J / P</bdi><span>פתוח</span></div></div>
      </aside>
    </div>
    <div class="intro-details">
      <details><summary>רגע לפני: איך כדאי לענות?</summary><p>כדאי לחשוב על ההעדפות הרגילות שלך בחודשים האחרונים, כשיש לך חופש לבחור, ולא רק על יום עמוס במיוחד או על תפקיד בעבודה. בכל מצב יש שתי אפשרויות טובות. בוחרים למה נוטים יותר, ובאיזו מידה. כששתיהן מתאימות באותה מידה, אפשר לבחור באמצע.</p><p>אפשר לחזור ולשנות כל תשובה. ההתקדמות נשמרת במכשיר הזה, כל עוד הדפדפן מאפשר זאת. אין צורך לענות מהר.</p></details>
      <details><summary>מה זה MBTI, ומה המבחן הזה מציע?</summary><p>מודל 16 הטיפוסים מחבר ארבעה זוגות של העדפות: מוחצן או מופנם, קונקרטי או עיוני, שכלתני או רגשי, גבולני או פתוח. הצירוף של ארבע הבחירות יוצר אחד מ-16 טיפוסים אפשריים.</p><p>המינוחים בעברית וכינויי הטיפוסים כאן תואמים לטבלה שסופקה לפרויקט. <b>גבולני</b> הוא הכינוי כאן להעדפה למסגרת ולסגירת קצוות (J), ללא משמעות קלינית. <b>רגשי</b> מתאר מתן משקל לערכים ולאנשים, ולא חוסר היגיון. <b>עיוני</b> מתייחס לדפוסים ולאפשרויות, ולא לרמת השכלה.</p><p>זהו שאלון עצמאי בהשראת ארבעת צירי MBTI, ולא מבחן MBTI רשמי או שאלון של 16Personalities. הוא נועד להיכרות עצמית, אינו אבחון ולא עבר תיקוף פסיכומטרי. טיפוס אינו מדד ליכולת או לערך אישי.</p></details>
    </div>
  </section>
  <section id="quiz" class="screen quiz-wrap" hidden aria-labelledby="question-heading">
    <div class="quiz-top"><span id="chapter-label" class="eyebrow"></span><button id="pause" class="text-button">שמירה ויציאה</button></div>
    <div class="progress-heading"><span id="question-counter"></span><span id="progress-text"></span></div>
    <progress id="progress" max="56" value="0" aria-label="שאלות שנענו"></progress>
    <form id="quiz-form" novalidate>
      <div class="question-card">
        <h2 id="question-heading" tabindex="-1"></h2>
        <div class="situation-options"><div class="situation option-a"><span aria-hidden="true">א'</span><p id="option-a"></p></div><div class="situation option-b"><span aria-hidden="true">ב'</span><p id="option-b"></p></div></div>
        <fieldset><legend>מה מרגיש לך יותר טבעי?</legend><div id="answer-options" class="answer-options"></div></fieldset>
        <p id="answer-error" class="error" role="alert" hidden>צריך לבחור תשובה כדי להמשיך. אפשר לבחור גם באמצע</p>
      </div>
      <div class="quiz-nav"><button id="previous" type="button" class="button secondary"><svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M5 12h14m-7-7 7 7-7 7"/></svg> <span>הקודם</span></button><button id="next" type="submit" class="button primary"><span>הבא</span> <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M19 12H5m7-7-7 7 7 7"/></svg></button></div>
    </form>
    <div class="quiz-bottom"><button id="review-link" class="text-button">כל התשובות שלי</button></div>
  </section>
  <section id="review" class="screen reading-width" hidden aria-labelledby="review-heading">
    <span class="eyebrow">בדיקה ועריכה</span><h2 id="review-heading" tabindex="-1">התשובות שלך</h2><p>לחיצה על שאלה מאפשרת לעדכן את התשובה. אין צורך לענות מחדש על הכול.</p><p id="review-count"></p><div id="review-list"></div><div class="action-row"><button id="review-finish" class="button primary"><span>לתוצאות</span> <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M19 12H5m7-7-7 7 7 7"/></svg></button><button id="review-back" class="button secondary">חזרה לשאלון</button></div>
  </section>
  <section id="results" class="screen" hidden aria-labelledby="result-heading">
    <div class="result-intro"><h2 id="result-heading" tabindex="-1"></h2><p id="result-subtitle" class="lead"></p></div>
    <div id="result-notice" class="notice" hidden></div>
    <div class="result-layout"><div id="profile-card" class="profile-card"></div><div class="axis-panel"><h3>ההעדפות שלך בארבעת התחומים</h3><div id="axis-results"></div><p class="axis-note">האחוזים מתארים נטייה בתשובות, ולא סבירות לטיפוס</p></div></div>
    <div id="nearby" class="nearby" hidden><h3>טיפוסים נוספים להשוואה</h3><p id="nearby-explanation"></p><div id="nearby-types" class="type-chips"></div></div>
    <div class="result-actions action-row"><button id="download" class="button primary"><span>לשמור את התוצאה</span> <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M12 3v12m-5-5 5 5 5-5M5 16v5h14v-5"/></svg></button><button id="copy" class="button secondary">העתקת סיכום</button><button id="print" class="button secondary">הדפסה</button><button id="edit" class="text-button">לעבור על התשובות</button><button id="restart" class="text-button">להתחיל מחדש</button></div>
    <p class="micro result-disclaimer">שאלון עצמאי להיכרות עצמית, ללא תיקוף פסיכומטרי. התוצאה אינה אבחון</p>
    <details class="explore"><summary>כל 16 הטיפוסים</summary><p>אפשר לעיין בכל התיאורים. הבחירה כאן אינה משנה את התוצאה שלך.</p><div id="type-picker" class="type-picker" role="group" aria-label="בחירת טיפוס לעיון"></div><div id="type-preview" tabindex="-1"></div></details>
  </section>
  <p id="storage-status" class="storage-status" role="status" hidden></p>
  <noscript><div class="notice">כדי למלא את השאלון נדרש להפעיל JavaScript בדפדפן. אין צורך בחיבור לרשת</div></noscript>
</main>
<footer class="shell site-footer"><div><button id="about-toggle" class="text-button" aria-expanded="false" aria-controls="method">מקורות ושיטת החישוב</button><button id="erase" class="text-button">מחיקת התשובות מהמכשיר</button></div>
<section id="method" hidden><h2>על מה מבוסס השאלון?</h2><p>56 השאלות נכתבו במיוחד לשאלון זה. בכל ציר 14 שאלות במשקל שווה, במחציתן כל צד מופיע ראשון. השאלות עוסקות באנרגיה ועיבוד, קליטת מידע, שיקולי החלטה וגישה למסגרת. הן אינן העתק של שאלון מסחרי.</p><p>כל תשובה מקבלת ערך בין 2- ל-2 בהתאם לכיוון ולמידת ההעדפה. סכום של 14 התשובות בציר מומר לסולם 0 עד 100, עם אמצע ב-50. בשוויון מוצג X ולא נבחר צד שרירותי. כשציון הצד המוביל אינו עולה על 62.5, מוצעים גם צירופים קרובים להשוואה. זהו סף תצוגה שנבחר לשאלון, לא גבול מחקרי או רווח סמך.</p><p>המודל של 16Personalities מוסיף ממד חמישי משלו; הוא אינו נמדד כאן. תיאורי הטיפוסים הם הצעות להתבוננות שנכתבו לשאלון, ולא ניבוי של הצלחה בעבודה או בקשרים. סימולציות עם סוכני שפה שימשו לאיתור בעיות ניסוח וניקוד, ואינן תיקוף על בני אדם.</p><ul><li><a href="https://www.myersbriggs.org/my-mbti-personality-type/the-mbti-preferences/" target="_blank" rel="noopener noreferrer">Myers &amp; Briggs Foundation: ארבעת זוגות ההעדפות</a></li><li><a href="https://www.myersbriggs.org/my-mbti-personality-type/my-mbti-results/" target="_blank" rel="noopener noreferrer">Myers &amp; Briggs Foundation: פרשנות התוצאה והתאמה אישית</a></li><li><a href="https://www.16personalities.com/articles/our-theory" target="_blank" rel="noopener noreferrer">16Personalities: ההבדל בין המודל שלהם ל-MBTI</a></li><li><a href="https://pubmed.ncbi.nlm.nih.gov/2709300/" target="_blank" rel="noopener noreferrer">McCrae &amp; Costa (1989): בחינה ביקורתית של החלוקה לטיפוסים</a></li><li><a href="https://pubmed.ncbi.nlm.nih.gov/16367525/" target="_blank" rel="noopener noreferrer">Tzeng ואחרים (1984): תוקף פריטים וסוגיות בבניית שאלות</a></li></ul></section></footer>
<div id="announcement" class="sr-only" aria-live="polite"></div><div id="toast" class="toast" role="status" hidden></div>
<dialog id="reset-dialog"><h2 id="reset-title">למחוק את התשובות?</h2><p>התשובות והתוצאה השמורות בדפדפן הזה יימחקו. אפשר לבטל ולהמשיך מהמצב הקיים.</p><div class="action-row"><button id="cancel-reset" class="button secondary" autofocus>ביטול</button><button id="confirm-reset" class="button primary">למחוק ולהתחיל מחדש</button></div></dialog>
<script>const MBTI_DATA = {"version":"1.1.0","chapters":["ברגעים הקטנים","אנשים סביבנו","משהו חדש מתחיל","בין רעיון למעשה","כשצריך לבחור","יוצאים מהשגרה","התמונה השלמה"],"questions":[{"id":1,"axis":"EI","aPole":"I","facet":"recharge","text":"התפנה לך ערב אחרי יום עמוס. מה בדרך כלל ממלא אותך מחדש?","a":"זמן שקט לעצמי, בלי צורך לדבר","b":"מפגש או שיחה עם אנשים שנעים לי איתם","sourceId":1},{"id":2,"axis":"SN","aPole":"S","facet":"learning","text":"התחלת ללמוד משחק חדש. איזו פתיחה נוחה לך יותר?","a":"הדגמה של תור אחד, צעד אחר צעד","b":"הסבר של הרעיון שמאחורי המשחק והאפשרויות שבו","sourceId":2},{"id":3,"axis":"TF","aPole":"F","facet":"decisions","text":"בוחרים מקום לבילוי עם חברים. מה נוטה להכריע אצלך כשאין אפשרות שמתאימה להכול?","a":"הרצונות האישיים של מי שיוצאים איתי","b":"השוואה של המחיר, המרחק ומה שיש בכל מקום","sourceId":3},{"id":4,"axis":"JP","aPole":"J","facet":"planning","text":"לקראת יום חופשי, מה מרגיש לך נעים יותר?","a":"להחליט מראש מה עושים ומתי","b":"להשאיר את היום פתוח ולבחור תוך כדי","sourceId":4},{"id":5,"axis":"SN","aPole":"N","facet":"attention","text":"אחרי ביקור במקום מעניין, על מה המחשבות שלך נוטות להתעכב?","a":"על הרעיונות והקשרים שהמקום עורר בי","b":"על המראות והפרטים המסוימים שראיתי","sourceId":5},{"id":6,"axis":"EI","aPole":"E","facet":"processing","text":"רעיון מתחיל להתגבש לך בראש. מה בדרך כלל עוזר להבהיר אותו?","a":"לספר עליו למישהו ולחשוב בקול תוך כדי","b":"לעבד אותו בשקט לפני שמשתפים","sourceId":6},{"id":7,"axis":"JP","aPole":"P","facet":"closure","text":"מצאת אפשרות טובה לבילוי, ואפשר להזמין גם מחר. מה טבעי לך?","a":"להשאיר עוד קצת מקום לאפשרויות נוספות","b":"לסגור את הבחירה ולהתפנות לדברים אחרים","sourceId":7},{"id":8,"axis":"TF","aPole":"T","facet":"fairness","text":"צריך לחלק תורנויות בבית. מה נראה לך הוגן יותר?","a":"לקבוע כלל אחיד שלפיו כולם מתחלקים בתורנויות","b":"להתאים את החלוקה למצב האישי של כל אחד","sourceId":8},{"id":9,"axis":"EI","aPole":"E","facet":"breadth","text":"במפגש נעים שבו אפשר לנוע בין שיחות, למה יש לך יותר חשק?","a":"לפגוש כמה אנשים ולהצטרף למעגלי שיחה שונים","b":"להישאר לשיחה ממושכת עם אדם אחד או שניים","sourceId":9},{"id":10,"axis":"TF","aPole":"T","facet":"feedback","text":"חבר מבקש את דעתך על סיפור שכתב. במה יתמקד המשוב שלך קודם?","a":"עד כמה העלילה מובנת והאירועים מתחברים זה לזה","b":"איך הסיפור השפיע עליי ומה הרגשתי כלפי הדמויות","sourceId":10},{"id":11,"axis":"SN","aPole":"N","facet":"patterns","text":"מישהו מספר על כמה אירועים שקרו לו. למה תשומת הלב שלך נמשכת?","a":"לחוט המקשר ולמשמעות שמסתתרת ביניהם","b":"למה שקרה בכל אירוע ולפרטים שמבדילים ביניהם","sourceId":11},{"id":12,"axis":"JP","aPole":"P","facet":"structure","text":"קבוצה קובעת איך להעביר מפגש חברתי. איזו מסגרת נוחה לך?","a":"כיוון כללי, עם מקום לשנות לפי האווירה","b":"תוכנית מוסכמת, כך שברור מה עומד לקרות","sourceId":12},{"id":13,"axis":"TF","aPole":"F","facet":"conflict","text":"שני חברים חלוקים בדעתם ומבקשים לשמוע את דעתך. מאיפה טבעי לך להתחיל?","a":"ממה שחשוב לכל אחד מהם ומאיך ההחלטה תשפיע עליו","b":"מהטענות של כל אחד מהם ומאיזו מהן מבוססת יותר","sourceId":13},{"id":14,"axis":"JP","aPole":"J","facet":"planning","text":"מתכננים ארוחה משותפת בעוד שבוע. מה עדיף לך?","a":"לקבוע כבר עכשיו מי מביא מה","b":"להחליט קרוב למועד לפי מה שיתאים אז","sourceId":14},{"id":15,"axis":"EI","aPole":"I","facet":"processing","text":"צריך להסביר דעה בנושא מורכב, ויש אפשרות לבחור איך. מה נוח לך יותר?","a":"לנסח אותה בכתב לפני שמשוחחים עליה","b":"לפתח אותה בשיחה שבה אפשר לשאול ולהגיב","sourceId":15},{"id":16,"axis":"SN","aPole":"S","facet":"learning","text":"כשמסבירים לך רעיון מורכב, מה הכי עוזר לך לעקוב?","a":"דוגמה ממשית שממחישה בדיוק למה הכוונה","b":"דימוי או עיקרון רחב שמחבר את החלקים","sourceId":16},{"id":17,"axis":"JP","aPole":"J","facet":"sequence","text":"החלטת ללמוד משהו חדש בזמן הפנוי. איך נוח לך להתקדם?","a":"לחלק את הלמידה לשלבים וללכת לפי הסדר","b":"לבחור בכל פעם במה להעמיק לפי מה שמעניין אותי","sourceId":17},{"id":18,"axis":"SN","aPole":"S","facet":"experience","text":"קראת על דרך חיים שונה מאוד משלך. מה היית רוצה להכיר יותר מקרוב?","a":"איך נראים חיי היומיום: האוכל, הבתים והמנהגים","b":"אילו רעיונות ותפיסות עולם עומדים מאחורי דרך החיים","sourceId":18},{"id":19,"axis":"EI","aPole":"I","facet":"initiation","text":"נכנסת לקבוצה חדשה שמקבלת אותך בחום. מה מרגיש טבעי יותר?","a":"להכיר בהדרגה דרך כמה שיחות אישיות","b":"להיכנס מהר לשיחה הקבוצתית ולהכיר תוך כדי","sourceId":19},{"id":20,"axis":"TF","aPole":"F","facet":"values","text":"שתי אפשרויות מתאימות לך באותה מידה מבחינה מעשית. מה יעזור לך לבחור?","a":"לחשוב איזו מהן קרובה יותר למה שחשוב לי אישית","b":"להשוות את הנימוקים בעד ונגד כל אחת","sourceId":20},{"id":21,"axis":"SN","aPole":"N","facet":"possibilities","text":"קיבלת כלי חדש שאפשר להשתמש בו בדרכים שונות. מה מסקרן אותך קודם?","a":"אילו שימושים חדשים ולא צפויים אפשר להמציא לו","b":"מה הוא יודע לעשות בפועל ואיך משתמשים בו היטב","sourceId":21},{"id":22,"axis":"JP","aPole":"P","facet":"adaptability","text":"באמצע עיסוק בשעות הפנאי עולה רעיון למשהו אחר, ויש זמן לשניהם. מה טבעי לך?","a":"לעצור ולנסות את הרעיון החדש","b":"לסיים את מה שהתחלתי ואז לנסות את הרעיון החדש","sourceId":22},{"id":23,"axis":"TF","aPole":"T","facet":"decisions","text":"קיבלת החלטה שמשפיעה גם על אנשים קרובים. מה נותן לך יותר ביטחון בה?","a":"שיש לי נימוקים ברורים לבחירה שעשיתי","b":"שהבחירה מתאימה למה שחשוב לי ולאנשים הקרובים אליי","sourceId":23},{"id":24,"axis":"EI","aPole":"E","facet":"initiation","text":"במפגש הושיבו אותך ליד אדם שנראה נעים, ועדיין לא דיברתם. מה טבעי לך יותר?","a":"לפתוח בשיחה ולהתחיל להכיר","b":"לתת לשיחה להיפתח בהדרגה, בלי ליזום מיד","sourceId":24},{"id":25,"axis":"TF","aPole":"T","facet":"perspective","text":"כדי לפתור מחלוקת מתמשכת, מה יעזור לך יותר בהתחלה?","a":"להפריד בין הטענות ולבדוק מה מבוסס בכל אחת","b":"להבין מה חשוב לכל צד ומה עומד מאחורי עמדתו","sourceId":25},{"id":26,"axis":"EI","aPole":"E","facet":"recharge","text":"אחרי כמה שעות טובות של עיסוק לבד, מה לרוב מתחשק לך?","a":"לצאת קצת החוצה ולפגוש או לדבר עם אנשים","b":"להמשיך עוד זמן במרחב האישי הנעים שלי","sourceId":26},{"id":27,"axis":"JP","aPole":"P","facet":"sequence","text":"יש כמה דברים לעשות בבית, ואין סדר מחייב. איך נוח לך לגשת אליהם?","a":"לעבור מדבר לדבר לפי מה שמתחשק לי באותו רגע","b":"לבחור סדר ולסיים דבר אחד לפני שמתחילים את הבא","sourceId":27},{"id":28,"axis":"SN","aPole":"S","facet":"attention","text":"כשצריך לתאר חדר שהיה לך נעים בו, במה יתמקד התיאור שלך?","a":"באור, בצבעים, ברהיטים ובמה שהיה בחדר","b":"באווירה, באסוציאציות ובמה שהחדר הזכיר לי","sourceId":31},{"id":29,"axis":"EI","aPole":"I","facet":"privacy","text":"קרה לך משהו אישי ומשמח. מה בדרך כלל מתאים לך?","a":"לשמור אותו לעצמי בהתחלה ולשתף רק מעטים","b":"לשתף כמה אנשים קרובים די מהר","sourceId":29},{"id":30,"axis":"TF","aPole":"F","facet":"appreciation","text":"מישהו מודה לך על עזרה. איזה חלק בדבריו משמעותי לך יותר?","a":"שהרגיש שראיתי אותו והבנתי מה הוא צריך","b":"שהעזרה שלי פתרה את הבעיה בצורה טובה","sourceId":30},{"id":31,"axis":"SN","aPole":"S","facet":"interpretation","text":"בסרט מופיע רגע שאפשר להבין בכמה דרכים. מה מעניין אותך יותר?","a":"מה קרה בפועל ומה הדמויות אמרו ועשו","b":"איזו משמעות נוספת או סמל עשויים להיות ברגע הזה","sourceId":33},{"id":32,"axis":"JP","aPole":"J","facet":"preparation","text":"עומדים לצאת לכמה שעות מהבית. מה נוח לך יותר?","a":"להכין מראש את כל מה שצריך לקחת","b":"לאסוף את הדברים כשמגיע הזמן לצאת","sourceId":32},{"id":33,"axis":"EI","aPole":"I","facet":"stimulation","text":"אפשר לבלות שעה נעימה בבית קפה תוסס או בפינה שקטה. מה מושך אותך יותר?","a":"הפינה השקטה, שבה פחות קורה סביבי","b":"בית הקפה התוסס, שבו מרגישים את האנשים מסביב","sourceId":36},{"id":34,"axis":"SN","aPole":"N","facet":"possibilities","text":"כשעולה רעיון לשיפור מקום מוכר, מה מעסיק אותך קודם?","a":"איך המקום יכול להיראות בעתיד אם נחשוב אחרת","b":"מה פועל בו עכשיו ואיזה שינוי ממשי יועיל","sourceId":38},{"id":35,"axis":"TF","aPole":"F","facet":"support","text":"חבר מספר על יום קשה. מה התגובה הראשונה שטבעית לך?","a":"להקשיב ולתת מקום למה שהוא מרגיש","b":"לברר מה קרה ולחשוב איתו מה עשוי לעזור","sourceId":35},{"id":36,"axis":"JP","aPole":"J","facet":"pace","text":"יש לך שבוע להכין משהו למפגש חברים. איזה קצב מתאים לך יותר?","a":"להתחיל מוקדם ולהתקדם קצת בכל יום","b":"לרכז את ההכנה סמוך למפגש, כשכבר נכנסים לאווירה","sourceId":34},{"id":37,"axis":"SN","aPole":"N","facet":"communication","text":"חבר מבקש לשמוע על חוויה שלך. באיזו דרך טבעי לך לספר?","a":"לספר לו מה החוויה גרמה לי לחשוב ומה היא מזכירה לי","b":"לספר לו מה קרה, לפי הסדר, עם פרטים ותיאורים","sourceId":44},{"id":38,"axis":"EI","aPole":"E","facet":"expression","text":"בחבורה קרובה מבקשים ממך לספר סיפור שכולם יקשיבו לו. איך זה מרגיש לך?","a":"נעים לי להיות במרכז השיחה ולשתף את כולם","b":"נעים לי יותר לספר לאדם אחד מאשר לכל החבורה","sourceId":39},{"id":39,"axis":"JP","aPole":"P","facet":"routine","text":"קבעת לעשות משהו בשעות הפנאי, ובאותו יום מתחשק לך משהו אחר. מה טבעי לך?","a":"לשנות את התוכנית לפי מה שמתאים לי עכשיו","b":"להישאר עם התוכנית שבחרתי מראש","sourceId":37},{"id":40,"axis":"TF","aPole":"T","facet":"support","text":"מישהו מציע לך לשנות הרגל. איזה הסבר עשוי לשכנע אותך יותר?","a":"הסבר שמראה איך השינוי יעבוד ומה התועלת שלו","b":"הסבר שמחבר את השינוי לדברים שחשובים לי בחיים","sourceId":40},{"id":41,"axis":"EI","aPole":"E","facet":"stimulation","text":"יום פנוי עבר כמעט בלי קשר עם אחרים. מה בדרך כלל חסר לך בסופו?","a":"קצת נוכחות של אנשים והתרחשות סביבי","b":"לא בהכרח חסר לי משהו, השקט נעים לי","sourceId":43},{"id":42,"axis":"TF","aPole":"F","facet":"fairness","text":"יש כלל קבוע במפגש חברים, ומישהו מבקש לחרוג ממנו. מה השיקול הראשון שלך?","a":"למה החריגה חשובה לו ומה המשמעות שלה עבורו","b":"האם יש סיבה שאפשר להחיל גם על מקרים דומים","sourceId":45},{"id":43,"axis":"SN","aPole":"S","facet":"experience","text":"משהו קטן בבית לא פועל כרגיל. איך טבעי לך להתחיל לבדוק מה קרה?","a":"לבדוק אחד אחד את הפרטים שאפשר לראות ולנסות","b":"לחשוב על הסבר שיכול לחבר בין כל הסימנים","sourceId":46},{"id":44,"axis":"JP","aPole":"J","facet":"routine","text":"בשגרה שיש לך חופש לקבוע, מה מרגיש לך נוח יותר?","a":"לעשות דברים מסוימים בשעות קבועות","b":"לשנות את סדר היום לפי מה שמתאים בכל פעם","sourceId":47},{"id":45,"axis":"TF","aPole":"F","facet":"feedback","text":"חבר מבקש חוות דעת על בחירה שחשובה לו. איך טבעי לך לנסח הסתייגות?","a":"להסביר קודם שאני מבין מה חשוב לו, ואז לומר מה מטריד אותי","b":"לומר קודם מה הבעיה שאני רואה, ואז להסביר את הסיבה","sourceId":51},{"id":46,"axis":"JP","aPole":"J","facet":"closure","text":"סיימת משהו שיצרת להנאתך, והוא מוצלח בעיניך. מה נעים לך יותר?","a":"להחליט שהוא גמור ולעבור לדבר הבא","b":"להשאיר אותו פתוח לעוד שינויים שיעלו בהמשך","sourceId":52},{"id":47,"axis":"EI","aPole":"I","facet":"company","text":"יש לך תחביב שאפשר ליהנות ממנו לבד או יחד. מה בדרך כלל עדיף לך?","a":"לעסוק בו לבד, בקצב ובמרחב שלי","b":"לעסוק בו עם אחרים ולהחליף חוויות תוך כדי","sourceId":49},{"id":48,"axis":"SN","aPole":"N","facet":"interpretation","text":"בקריאת סיפור, מה נוטה לתפוס אותך יותר?","a":"הרעיונות, הסמלים והאפשרויות לפרשנות","b":"הפרטים החיים והתחושה של להיות בתוך ההתרחשות","sourceId":53},{"id":49,"axis":"JP","aPole":"P","facet":"preparation","text":"יוצאים למקום מוכר ולא חסר שם ציוד. איך נוח לך להתכונן?","a":"לקחת את הדברים הבסיסיים ולהחליט במקום מה עוד צריך","b":"לחשוב מראש על מה שאולי ארצה ולהכין בהתאם","sourceId":55},{"id":50,"axis":"SN","aPole":"N","facet":"application","text":"אפשר לקרוא על שימוש מעשי בתגלית או על מה שעוד עשוי להתאפשר בזכותה. מה מושך אותך יותר?","a":"לחשוב על האפשרויות העתידיות שהיא פותחת","b":"להבין איך אפשר להשתמש בה כבר היום","sourceId":59},{"id":51,"axis":"EI","aPole":"E","facet":"company","text":"בזמן עיסוק נינוח, מכר נעים מתחיל איתך שיחה לא דחופה. מה ההרגשה הראשונית שלך?","a":"נחמד לי שנוצרה הזדמנות לשיחה תוך כדי","b":"הייתי מעדיף להמשיך בעיסוק שלי בלי שיחה כרגע","sourceId":56},{"id":52,"axis":"TF","aPole":"T","facet":"conflict","text":"בני הבית לא מסכימים מה עדיף לעשות. איזה תפקיד טבעי לך לקחת בשיחה?","a":"לחדד את ההבדלים בין ההצעות כדי שיהיה קל להכריע","b":"למצוא מה משותף להצעות כדי שיהיה קל להגיע להסכמה","sourceId":54},{"id":53,"axis":"SN","aPole":"S","facet":"application","text":"בתחום שמעניין אותך, מה מושך אותך יותר?","a":"לשפר משהו קיים כך שיעבוד טוב יותר","b":"לחשוב על משהו חדש שעדיין לא ניסו","sourceId":64},{"id":54,"axis":"JP","aPole":"P","facet":"structure","text":"למשחק חברתי חדש מציעים לקבוע כללים יחד. מה מתאים לך יותר?","a":"להתחיל עם כמה כללים ולהוסיף לפי מה שיתעורר","b":"להסכים מראש על הכללים לפני שמתחילים לשחק","sourceId":58},{"id":55,"axis":"TF","aPole":"T","facet":"values","text":"שמעת הצעה שנשמעת טובה בהתחלה. מה טבעי לך לבדוק קודם?","a":"אילו חסרונות או קשיים אולי לא הביאו בחשבון","b":"מה יש בה שכדאי לתמוך בו ולעודד","sourceId":57},{"id":56,"axis":"EI","aPole":"I","facet":"privacy","text":"הצטרפת לחבורה נחמדה והאווירה פתוחה. כמה מעצמך טבעי לך לשתף בהתחלה?","a":"בעיקר דברים כלליים, ואת האישי לשמור להמשך ההיכרות","b":"גם מחשבות וחוויות אישיות, אם השיחה מזמינה זאת","sourceId":63}],"revision":"1.1.0-f21b74663d17"};
const MBTI_PROFILES = {"ISTJ":{"he":"מקשג","name":"המפקח / הלוגיסטיקן","description":"הצירוף הזה מציע העדפה לעבודה שקולה, לפרטים ממשיים ולהתקדמות בתוך מסגרת ברורה. ייתכן שנוח לך לברר מה נדרש, לבנות דרך מסודרת ולדאוג שגם הפרטים הקטנים יקבלו מענה.","strengths":["מעקב אחר פרטים והתחייבויות","תרגום ניסיון לשיטה שימושית","קבלת החלטות לפי קריטריונים עקביים"],"stretch":"כששיטה מוכרת עובדת, קל לפסול חלופה לפני שנותנים לה הזדמנות. כדאי לברר מתי הניסיון מועיל ומתי התנאים כבר השתנו.","relationships":"אכפתיות יכולה להתבטא אצלך בעשייה ובנוכחות עקבית. לפעמים כדאי לומר במילים את מה שמבחינתך כבר ברור מהמעשים.","work":"מטרה מוגדרת, אחריות ברורה וזמן להכנה עשויים לעזור לך להביא את המיטב.","experiment":"לבחור הרגל קטן ולנסות לו חלופה אחת, בלי להתחייב לאמץ אותה."},"ISFJ":{"he":"מקרג","name":"המגן","description":"כאן נפגשות תשומת לב לפרטים, התחשבות אישית וחיבה למסגרת. ייתכן שחשוב לך לזכור מה מועיל לאנשים סביבך וליצור עבורם תחושה של רציפות וביטחון, גם בלי לעמוד במרכז.","strengths":["זיכרון לפרטים אישיים שימושיים","תמיכה מעשית שמתאימה לאדם","התמדה בטיפוח קשרים ומסגרות"],"stretch":"הרצון לשמור על מה שטוב לאחרים עלול לדחוק את ההעדפות שלך. הבעת צורך אישי אינה מבטלת את ההתחשבות.","relationships":"מחוות קטנות עשויות להיות שפה טבעית עבורך. שיחה מפורשת על ציפיות יכולה לחסוך הנחות שאינן משותפות לשני הצדדים.","work":"סביבה מכבדת, משימות מוחשיות וציפיות ידועות עשויות להתאים לקצב שלך.","experiment":"לנסח בקשה אישית אחת באופן ברור, לפני שמציעים שוב עזרה."},"INFJ":{"he":"מערג","name":"הסנגור","description":"השילוב הזה נוטה לחבר התבוננות פנימית, חיפוש משמעות והתחשבות באנשים עם רצון להתקדם לכיוון ברור. ייתכן שחשוב לך להבין לא רק מה קורה, אלא גם מה עומד מאחוריו ולאן הוא מוביל.","strengths":["חיבור בין רעיונות לערכים","הקשבה למשמעויות שמאחורי הדברים","התמקדות בכיוון בעל משמעות אישית"],"stretch":"תמונה פנימית משכנעת אינה תמיד התמונה של האחר. כדאי לבדוק פרשנויות במקום להניח שהבנת בדיוק למה התכוונו.","relationships":"ייתכן שחשובות לך שיחות עומק וזמן לעיבוד. אפשר לבקש את שניהם במפורש, גם בלי לצפות שאחרים ינחשו.","work":"מרחב ריכוז, מטרה משמעותית ויכולת לתכנן את הדרך עשויים לתמוך בך.","experiment":"לבדוק פרשנות אחת באמצעות שאלה פשוטה: האם לזה התכוונת?"},"INTJ":{"he":"מעשג","name":"האדריכל","description":"התשובות בכיוון הזה מחברות חשיבה עצמאית, זיהוי דפוסים ובחינה עניינית עם רצון במבנה ובהכרעה. ייתכן שנוח לך לבנות תמונה רחבה ואז לחפש את הדרך ההגיונית שתהפוך אותה למציאות.","strengths":["בניית תמונה אסטרטגית","בחינת הנחות ומבנים","מיקוד מאמץ בכיוון ארוך טווח"],"stretch":"תוכנית בהירה בראש אינה בהכרח ברורה לאחרים. שיתוף בהנחות ובשיקולים יכול להיות חלק מהביצוע עצמו.","relationships":"עצמאות וישירות עשויות להיות חשובות לך. כדאי להשאיר מקום גם למה שאנשים מרגישים לפני שמציעים שיפור.","work":"בעיה מורכבת, חופש לחשוב ומטרות ברורות עשויים להיות שילוב נוח עבורך.","experiment":"להציג רעיון לפני שהוא מושלם ולבקש מאדם אחר לזהות הנחה חסרה."},"ISTP":{"he":"מקשפ","name":"האומן / הווירטואוז","description":"זהו שילוב של מרחב אישי, תשומת לב למה שקורה בפועל, בחינה הגיונית וגמישות. ייתכן שנוח לך להבין בעיה דרך התנסות ולבחור פתרון לפי המצב, בלי להעמיס עליו מסגרת מיותרת.","strengths":["איתור תקלות באופן ענייני","למידה דרך התנסות ישירה","התאמת פתרונות לתנאים בשטח"],"stretch":"פתרון שעובד ברגע זה אינו תמיד מסביר לאחרים מה יקרה בהמשך. מעט תיאום מראש יכול להגן על החופש שלך.","relationships":"ייתכן שנוח לך להראות אכפתיות דרך עזרה מעשית וזמן משותף. לפעמים הצד השני צריך גם לשמוע מה עובר עליך.","work":"עצמאות, בעיות מוחשיות ומרחב לשנות את דרך הפעולה עשויים להתאים לך.","experiment":"לשתף מישהו בצעד הבא שלך עוד לפני שהוא שואל."},"ISFP":{"he":"מקרפ","name":"ההרפתקן","description":"כאן נפגשים עיבוד פנימי, חוויה מוחשית, ערכים אישיים וגמישות. ייתכן שנוח לך להרגיש את הדברים מקרוב ולבחור בקצב שלך מה מתאים לך, בלי להפוך כל חוויה לתוכנית מסודרת.","strengths":["רגישות לפרטים בחוויה המיידית","נאמנות למה שחשוב לך","התחשבות אישית שאינה מחייבת במה"],"stretch":"שמירת האפשרויות פתוחות עשויה להקשות על אחרים להבין למה לצפות. אפשר לקבוע עוגן קטן בלי לוותר על גמישות.","relationships":"ייתכן שמעשים וחוויות משותפות קרובים לליבך. הבעת העדפות במילים נותנת לאחרים הזדמנות לכבד אותן.","work":"מרחב אישי, עשייה מוחשית וחופש בדרך הביצוע עשויים לעזור לך.","experiment":"לבחור התחייבות קטנה אחת לשבוע ולתת לה זמן מוגדר."},"INFP":{"he":"מערפ","name":"המתווך","description":"הצירוף הזה מחבר התבוננות פנימית, דמיון וערכים אישיים עם פתיחות לאפשרויות. ייתכן שחשוב לך למצוא דרך שנאמנה למה שיקר לך, ולראות מעבר למצב הקיים גם את מה שהוא יכול להיות.","strengths":["התבוננות מזוויות אפשריות שונות","חיבור בין רעיונות לערכים אישיים","מתן מקום לחוויה של אדם אחר"],"stretch":"כשיש הרבה אפשרויות משמעותיות, הבחירה באחת עלולה להרגיש כמו ויתור. צעד קטן אינו מחייב החלטה לכל החיים.","relationships":"ייתכן שחשובים לך כנות, עומק ומרחב להיות עצמך. שיתוף בצרכים קונקרטיים יכול לקרב יותר מרמזים.","work":"משמעות אישית, זמן לחשיבה וגמישות מסוימת בדרך עשויים לעזור לך להתמיד.","experiment":"להפוך רעיון יקר לך לפעולה שאפשר להשלים בעשרים דקות."},"INTP":{"he":"מעשפ","name":"הלוגיקאי / הפילוסוף","description":"זהו שילוב של מחשבה עצמאית, עניין בדפוסים, בחינה הגיונית ופתיחות. ייתכן שהסקרנות שלך מתעוררת כשאפשר לפרק הנחות, לבדוק הסברים ולגלות אפשרות שלא נראתה בהתחלה.","strengths":["בחינה של עקביות פנימית","יצירת הסברים וחיבורים חדשים","נכונות לעדכן רעיון כשמוצאים בו פער"],"stretch":"תמיד אפשר לחדד עוד, אבל לפעמים ערכו של רעיון מתברר רק כשמנסים אותו. כדאי להגדיר מה מספיק לניסוי ראשון.","relationships":"שיחה על רעיונות עשויה להיות דרך לחיבור. שווה לבדוק אם כרגע מבקשים ממך ניתוח, הקשבה או עזרה מעשית.","work":"שאלות מורכבות, זמן ללא הפרעות וחופש לבדוק חלופות עשויים להתאים לך.","experiment":"להגדיר שעת עצירה למחקר ולהוציא גרסה קטנה שאפשר לבחון."},"ESTP":{"he":"חקשפ","name":"היזם","description":"כאן נפגשים קשר עם הסביבה, התמקדות במציאות, שיקולים ענייניים וגמישות. ייתכן שנוח לך לפגוש מצב כפי שהוא, לנסות משהו ולתקן בהתאם למשוב שמגיע מהשטח.","strengths":["זיהוי אפשרויות מעשיות ברגע נתון","למידה מהירה דרך עשייה","שיחה ישירה שמקדמת פעולה"],"stretch":"הצעד הזמין ביותר אינו תמיד המתאים ביותר לטווח ארוך. עצירה קצרה יכולה לחשוף מחיר שלא רואים מיד.","relationships":"עשייה משותפת ושיחה חיה עשויות להיות טבעיות לך. כדאי לתת מקום גם לקצב עיבוד איטי משלך.","work":"מגע עם אנשים, משוב מיידי ומרחב לאלתור עשויים לעזור לך להתקדם.","experiment":"לפני פעולה חדשה, לרשום תוצאה אפשרית אחת להיום ואחת לעוד חודש."},"ESFP":{"he":"חקרפ","name":"הבדרן","description":"השילוב הזה מציע עניין באנשים, חוויה מוחשית, התחשבות וגמישות. ייתכן שקל לך להתחבר למה שקורה עכשיו ולשים לב כיצד אפשר להפוך את הרגע לנעים ומשמעותי יותר עבור המשתתפים.","strengths":["יצירת קשר דרך חוויה משותפת","תשומת לב לתגובות של אנשים בזמן אמת","התאמה גמישה למה שקורה סביבך"],"stretch":"מה שנעים ברגע זה עלול להשאיר משימה חשובה למועד לא נוח. עוגנים קטנים יכולים לפנות מקום להנאה בהמשך.","relationships":"ייתכן שחום, נוכחות ועשייה משותפת חשובים לך. שיחות שקטות יכולות לחשוף צרכים שאינם בולטים על פני השטח.","work":"סביבה אנושית, משימות מוחשיות ומגוון עשויים להיטיב איתך.","experiment":"לסיים משימה קטנה שקבעת מראש לפני שעוברים להזדמנות המפתה הבאה."},"ENFP":{"he":"חערפ","name":"הפעיל / האקטיביסט","description":"כאן מתחברים עיבוד דרך קשר עם אחרים, חיפוש אפשרויות, ערכים אישיים וגמישות. ייתכן ששיחה טובה מעוררת אצלך כיוונים חדשים, במיוחד כשהם מתחברים לאנשים או למשהו שחשוב לך.","strengths":["חיבור בין רעיונות ואנשים","זיהוי פוטנציאל שעדיין לא התממש","התלהבות שמזמינה השתתפות"],"stretch":"ריבוי כיוונים יכול לפזר את האנרגיה גם כשכולם טובים. בחירת כיוון זמני יכולה לעזור לרעיון אחד לקבל חיים.","relationships":"סקרנות וחילופי מחשבות עשויים להיות דרך טבעית לקרבה. כדאי לבדוק גם אילו התחייבויות קטנות הצד השני צריך.","work":"גיוון, משמעות ומרחב להציע דרכים חדשות עשויים להתאים לך.","experiment":"לבחור רעיון אחד לשבוע הקרוב ולהגדיר לו תוצר קטן ומועד."},"ENTP":{"he":"חעשפ","name":"הפולמוסן / המתווכח","description":"השילוב הזה מחבר חשיבה בקול, עניין באפשרויות, בדיקה עניינית ופתיחות. ייתכן ששיחה היא עבורך מעבדה לרעיונות: מציעים, מערערים ומשנים כדי למצוא זווית טובה יותר.","strengths":["יצירת חלופות לא שגרתיות","זיהוי הנחות שאפשר לאתגר","פיתוח רעיון באמצעות שיחה וביקורת"],"stretch":"בחינת טיעון לשם הסקרנות עלולה להיחוות כביקורת אישית. כדאי להבהיר את הכוונה ולברר אם הצד השני רוצה דיון כזה עכשיו.","relationships":"ייתכן שהחלפת רעיונות נותנת לך אנרגיה. הקשבה בלי להציע מיד זווית נגדית יכולה לפתוח סוג אחר של קרבה.","work":"שאלות פתוחות, שותפים לחשיבה וחופש לנסות חלופות עשויים להיטיב איתך.","experiment":"לבחור חלופה אחת ולבדוק אותה בפועל לפני שמציעים שלוש נוספות."},"ESTJ":{"he":"חקשג","name":"המנהל","description":"זהו חיבור בין מעורבות בסביבה, תשומת לב לעובדות, הכרעה עניינית ומסגרת. ייתכן שנוח לך להבהיר את המטרה, לסכם מה צריך לקרות וליצור סדר שמאפשר לאנשים להתקדם יחד.","strengths":["הפיכת מטרות למשימות מוגדרות","תיאום אחריות וציפיות","בחינת התקדמות לפי נתונים ברורים"],"stretch":"קצב החלטה מהיר עלול להקדים מידע או הסתייגות שעדיין לא נאמרו. הזמנה מפורשת להשמיע קושי יכולה לשפר את התוכנית.","relationships":"נאמנות ועזרה מעשית עשויות להיות חשובות לך. לא כל קושי שמספרים לך עליו דורש ארגון מחדש.","work":"יעדים ברורים, תיאום ומרחב לקדם ביצוע עשויים להתאים לך.","experiment":"לפני סיכום החלטה, לבקש מכל משתתף לציין דבר אחד שעוד לא נשקל."},"ESFJ":{"he":"חקרג","name":"היועץ","description":"כאן נפגשים קשר פעיל עם אנשים, תשומת לב לפרטים, התחשבות ומסגרת. ייתכן שחשוב לך שהציפיות יהיו ברורות ושהאנשים המעורבים ירגישו שיש מי שרואה אותם ודואג למפגש מוצלח.","strengths":["תיאום צרכים מעשיים של אנשים","יצירת תחושת שותפות","מעקב אחר פרטים שמקלים על אחרים"],"stretch":"ניסיון לדאוג לכולם עלול להפוך להסכמה אוטומטית. גבול ברור עוזר לשמור גם על הקשר וגם על הכוחות שלך.","relationships":"שיתוף, מחוות והדדיות עשויים להיות חשובים לך. כדאי לבדוק אם לאחרים יש דרך שונה להביע אכפתיות.","work":"שיתוף פעולה, תפקידים ידועים ומשוב אנושי עשויים לסייע לך.","experiment":"להחליף הסכמה מיידית אחת במשפט: אבדוק מה מתאים לי ואחזור עם תשובה."},"ENFJ":{"he":"חערג","name":"הגיבור","description":"הצירוף הזה מחבר מעורבות חברתית, ראיית אפשרויות, ערכים ורצון בכיוון ברור. ייתכן שנוח לך לחשוב יחד עם אחרים על מה שיכול לצמוח, ולעזור לרעיון משותף להפוך למחויבות מעשית.","strengths":["ניסוח כיוון שאנשים יכולים להתחבר אליו","זיהוי שאיפות וצרכים בשיחה","ארגון מאמץ סביב מטרה משותפת"],"stretch":"ראיית פוטנציאל באדם אינה אומרת שזה הכיוון שהוא רוצה. אפשר להציע תמיכה ולהשאיר את הבחירה בידיו.","relationships":"ייתכן שחשוב לך לדבר על משמעות ועל צמיחה משותפת. לפעמים קשר צריך פשוט מקום להיות, בלי יעד לשיפור.","work":"מטרה בעלת משמעות, קשר עם אנשים ותוכנית ברורה עשויים להתאים לך.","experiment":"לשאול אדם קרוב איזה סוג תמיכה הוא רוצה, ולפעול לפי תשובתו."},"ENTJ":{"he":"חעשג","name":"המפקד","description":"כאן מתחברים חשיבה דרך מעורבות, תמונה רחבה, הכרעה עניינית והעדפה למסגרת. ייתכן שנוח לך לזהות כיוון, להציב סדרי עדיפויות ולהניע שיחה שמסתיימת בהחלטה ובצעד הבא.","strengths":["חיבור בין אסטרטגיה להחלטות","תעדוף של מאמץ ומשאבים","הבהרת מטרות והנעת התקדמות"],"stretch":"כשברור לך מה צריך לקרות, קל להניח שגם לאחרים ברור ומוסכם. בדיקת ההבנה וההשפעה האנושית יכולה לחזק את הביצוע.","relationships":"ישירות ומחויבות עשויות להיות חשובות לך. אפשר להראות אכפתיות גם בהקשבה שאין בסופה פתרון.","work":"אתגר מורכב, אחריות ברורה ואפשרות לקדם כיוון עשויים לעזור לך.","experiment":"בדיון הבא, לשמוע את ההצעות של האחרים לפני שמציגים את ההכרעה שלך."}};
const MBTI_ILLUSTRATIONS = {"ISTJ":"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNDAgMjQwIiByb2xlPSJpbWciIGFyaWEtbGFiZWxsZWRieT0idGl0bGUtaXN0aiI+PHRpdGxlIGlkPSJ0aXRsZS1pc3RqIj5JU1RKOiBhIG1ldGljdWxvdXMgbW91c3RhY2hlZCBtYW4gY2hlY2tpbmcgYSBjbGlwYm9hcmQ8L3RpdGxlPgo8ZWxsaXBzZSBjeD0iMTIxIiBjeT0iMjE4IiByeD0iNzkiIHJ5PSI1IiBmaWxsPSIjMjYzRDQ4IiBvcGFjaXR5PSIuMDgiLz48Y2lyY2xlIGN4PSIxMjIiIGN5PSIxMjMiIHI9IjgzIiBmaWxsPSIjRThFRkYzIi8+PHBhdGggZD0iTTk4IDE0OSAxMjMgMTUxIDExNiAyMDYgOTkgMjA2WiIgZmlsbD0iI0I5QTQ4OSIvPjxwYXRoIGQ9Ik0xMjIgMTUxIDE0MiAxNDggMTUxIDIwNiAxMzQgMjA4IDEyMSAxNzZaIiBmaWxsPSIjRDBCREEwIi8+PHBhdGggZD0iTTk5IDIwMiAxMTYgMjAyIDExOCAyMTVIODZRODAgMjExIDk5IDIwMloiIGZpbGw9IiMyNjNENDgiLz48cGF0aCBkPSJNMTM0IDIwNCAxNTEgMjAyIDE2NCAyMTFRMTY2IDIxNyAxNTMgMjE3SDEzNFoiIGZpbGw9IiMyNjNENDgiLz48cGF0aCBkPSJNOTEgOTcgMTEwIDg4IDEyNyA4OSAxNDggMTAwIDE0MyAxNTEgOTUgMTU1WiIgZmlsbD0iI0ZGRjlFRCIvPjxwYXRoIGQ9Ik0xMDQgOTMgMTE4IDEwNCAxMzIgOTMgMTQzIDE1MSAxMjQgMTYwIDExNSAxNTEgOTUgMTU5IDkzIDEwNFoiIGZpbGw9IiM0NzY3NzgiLz48cGF0aCBkPSJNMTA5IDkxIDExNyA5OCAxMjMgOTEgMTI3IDEwMSAxMTcgMTEwIDEwNiAxMDBaIiBmaWxsPSIjRkZGOUVEIi8+PHBhdGggZD0iTTExNyAxMDEgMTIyIDEwNCAxMjAgMTMzIDExNCAxMzkgMTEyIDEzMloiIGZpbGw9IiNBRTdDNEUiLz48cGF0aCBkPSJNOTQgOTdRODIgOTYgNzkgMTE0TDY4IDE0NSA4MSAxNTMgOTcgMTI1IDEwNCAxMDZaIiBmaWxsPSIjRkZGOUVEIi8+PHBhdGggZD0iTTcxIDE0MCA4MyAxNDcgNzggMTU5IDY2IDE1M1oiIGZpbGw9IiNDRkQ3RDciLz48ZyB0cmFuc2Zvcm09InRyYW5zbGF0ZSg3NSAxNTcpIHJvdGF0ZSgtMTUpIj48cGF0aCBkPSJNLTUtNlEtNS0xMC0xLTEwTDQtOSA3LTUgNyA0UTYgOSAxIDlMLTQgNS04LTFRLTEwLTUtNy02TC00LTNaIiBmaWxsPSIjRURDMkExIi8+PHBhdGggZD0iTS0zLTIgMCAyIiBmaWxsPSJub25lIiBzdHJva2U9IiNEODlDNzciIHN0cm9rZS13aWR0aD0iMS4xIiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiLz48L2c+PHBhdGggZD0iTTE0MyA5OFExNTYgMTAxIDE2MyAxMjNRMTY3IDEzNyAxNTMgMTQyTDExNyAxNTcgMTEwIDE0NSAxNDIgMTI4IDEzMiAxMTBaIiBmaWxsPSIjRkZGOUVEIi8+PHBhdGggZD0iTTExOSAxNDEgMTI0IDE1NCAxMTQgMTU4IDEwOCAxNDZaIiBmaWxsPSIjQ0ZEN0Q3Ii8+PGcgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoOTkgNDIpIj48cmVjdCB4PSIxNCIgeT0iMzciIHdpZHRoPSIxNCIgaGVpZ2h0PSIxNyIgcng9IjIiIGZpbGw9IiNFREMyQTEiLz48cGF0aCBkPSJNMTQgNDBIMjhWNDZMMTQgNDlaIiBmaWxsPSIjRDg5Qzc3Ii8+PC9nPjxnIHRyYW5zZm9ybT0idHJhbnNsYXRlKDk5IDQyKSByb3RhdGUoMCAyMCAyNSkiPjxlbGxpcHNlIGN4PSI1IiBjeT0iMjciIHJ4PSI0LjUiIHJ5PSI2IiBmaWxsPSIjRURDMkExIi8+PGVsbGlwc2UgY3g9IjM2IiBjeT0iMjciIHJ4PSI0IiByeT0iNS41IiBmaWxsPSIjRURDMkExIi8+PHBhdGggZD0iTTQgMTZRNiAzIDIwIDRRMzUgNCAzNiAxOEwzNSAzNCAyOCA0NCAxNCA0NCA2IDM2WiIgZmlsbD0iI0VEQzJBMSIvPjxwYXRoIGQ9Ik00IDI1IDIgMTRRMSAzIDEyIDBMMjUgMFEzNyAyIDM4IDE0TDM1IDI1IDMxIDIyVjE0TDIwIDkgOSAxNSA4IDI1WiIgZmlsbD0iIzRENDg0MCIvPjxwYXRoIGQ9Ik0xMCAyMyAxNiAyMk0yNSAyMiAzMCAyMyIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjMjYzRDQ4IiBzdHJva2Utd2lkdGg9IjEuOCIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIi8+PGNpcmNsZSBjeD0iMTMuNSIgY3k9IjI3IiByPSIxLjQ1IiBmaWxsPSIjMjYzRDQ4Ii8+PGNpcmNsZSBjeD0iMjcuNSIgY3k9IjI3IiByPSIxLjQ1IiBmaWxsPSIjMjYzRDQ4Ii8+PHBhdGggZD0iTTIxIDI2IDE5IDMzIDIzIDMzIiBmaWxsPSJub25lIiBzdHJva2U9IiNEODlDNzciIHN0cm9rZS13aWR0aD0iMS41IiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiLz48cGF0aCBkPSJNMTIgMzVRMTYgMzEgMjEgMzRRMjYgMzEgMzAgMzVMMjggMzggMjEgMzYgMTUgMzhaIiBmaWxsPSIjNEQ0ODQwIi8+PHBhdGggZD0iTTE4IDQxSDI1IiBmaWxsPSJub25lIiBzdHJva2U9IiMyNjNENDgiIHN0cm9rZS13aWR0aD0iMS40IiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiLz48L2c+PGcgdHJhbnNmb3JtPSJyb3RhdGUoLTkgODkgMTU5KSI+PHJlY3QgeD0iNjgiIHk9IjEyOSIgd2lkdGg9IjQyIiBoZWlnaHQ9IjU5IiByeD0iNCIgZmlsbD0iIzQ3Njc3OCIvPjxyZWN0IHg9IjcyIiB5PSIxMzQiIHdpZHRoPSIzNCIgaGVpZ2h0PSI1MCIgcng9IjIiIGZpbGw9IiNGRkY5RUQiLz48cmVjdCB4PSI4MCIgeT0iMTI1IiB3aWR0aD0iMTgiIGhlaWdodD0iMTAiIHJ4PSIzIiBmaWxsPSIjQTNCNUJEIi8+PHBhdGggZD0iTTc4IDE0NSA4MSAxNDggODYgMTQxTTkxIDE0NUgxMDBNNzggMTU5IDgxIDE2MiA4NiAxNTVNOTEgMTU5SDEwME03OCAxNzMgODEgMTc2IDg2IDE2OU05MSAxNzNIMTAwIiBmaWxsPSJub25lIiBzdHJva2U9IiM0NzY3NzgiIHN0cm9rZS13aWR0aD0iMS44IiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiLz48L2c+PHBhdGggZD0iTTEwOSAxNDYgOTQgMTY0IiBmaWxsPSJub25lIiBzdHJva2U9IiMyNjNENDgiIHN0cm9rZS13aWR0aD0iMiIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIi8+PHBhdGggZD0iTTk2IDE2MSA5MyAxNjYgOTcgMTY0WiIgZmlsbD0iI0U2QjY1RCIvPjxnIHRyYW5zZm9ybT0idHJhbnNsYXRlKDEwMiAxNTUpIHJvdGF0ZSg5MCkiPjxwYXRoIGQ9Ik0tNS02US01LTEwLTEtMTBMNC05IDctNSA3IDRRNiA5IDEgOUwtNCA1LTgtMVEtMTAtNS03LTZMLTQtM1oiIGZpbGw9IiNFREMyQTEiLz48cGF0aCBkPSJNLTMtMiAwIDIiIGZpbGw9Im5vbmUiIHN0cm9rZT0iI0Q4OUM3NyIgc3Ryb2tlLXdpZHRoPSIxLjEiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIvPjwvZz4KPC9zdmc+Cg==","ISFJ":"data:image/svg+xml;base64,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","INFJ":"data:image/svg+xml;base64,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","INTJ":"data:image/svg+xml;base64,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","ISTP":"data:image/svg+xml;base64,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","ISFP":"data:image/svg+xml;base64,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","INFP":"data:image/svg+xml;base64,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","INTP":"data:image/svg+xml;base64,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","ESTP":"data:image/svg+xml;base64,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","ESFP":"data:image/svg+xml;base64,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","ENFP":"data:image/svg+xml;base64,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","ENTP":"data:image/svg+xml;base64,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","ESTJ":"data:image/svg+xml;base64,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","ESFJ":"data:image/svg+xml;base64,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","ENFJ":"data:image/svg+xml;base64,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","ENTJ":"data:image/svg+xml;base64,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"};
const MBTI_PALETTES = {"INTJ":{"accent":"#43558B","soft":"#EBEDF7","darkAccent":"#AFBAF4","darkSoft":"#252D49"},"INTP":{"accent":"#745F8B","soft":"#F0EBF5","darkAccent":"#CEB4E6","darkSoft":"#362A43"},"ENTJ":{"accent":"#933F56","soft":"#F7E9ED","darkAccent":"#F2A9BA","darkSoft":"#482935"},"ENTP":{"accent":"#A4502B","soft":"#F9ECDF","darkAccent":"#F5B48C","darkSoft":"#493124"},"INFJ":{"accent":"#3B6C59","soft":"#E7F1EB","darkAccent":"#9ED4B7","darkSoft":"#263D33"},"INFP":{"accent":"#5E7034","soft":"#EFF2E2","darkAccent":"#C6D598","darkSoft":"#363D25"},"ENFJ":{"accent":"#267376","soft":"#E4F2EF","darkAccent":"#98DADB","darkSoft":"#203D40"},"ENFP":{"accent":"#89641B","soft":"#FBF2D8","darkAccent":"#EAC66F","darkSoft":"#443921"},"ISTJ":{"accent":"#476778","soft":"#E8EFF3","darkAccent":"#ABCADB","darkSoft":"#293942"},"ISFJ":{"accent":"#9A5263","soft":"#F7EAEE","darkAccent":"#EDB3C2","darkSoft":"#472D37"},"ESTJ":{"accent":"#345A8B","soft":"#E7EEF7","darkAccent":"#A9C7F2","darkSoft":"#26354B"},"ESFJ":{"accent":"#A1503E","soft":"#FAEAE3","darkAccent":"#F3B29C","darkSoft":"#4B302A"},"ISTP":{"accent":"#317469","soft":"#E4F2EE","darkAccent":"#98D6C8","darkSoft":"#243F38"},"ISFP":{"accent":"#795B98","soft":"#F2EAF9","darkAccent":"#D3B6F1","darkSoft":"#3B2D4C"},"ESTP":{"accent":"#9B5B20","soft":"#FFF0DE","darkAccent":"#F7C286","darkSoft":"#4C3724"},"ESFP":{"accent":"#A3477A","soft":"#F9E9F2","darkAccent":"#F0AED4","darkSoft":"#492C40"}};</script>
<script>/* Shared by the standalone page and Node verification. No fitted persona weights. */
(function (root) {
  'use strict';
  const axes = [
    { id: 'EI', title: 'מאיפה מגיעה האנרגיה', labels: ['מוחצן', 'מופנם'], explanations: ['מפגש עם אנשים ועיבוד בקול', 'מרחב אישי ועיבוד פנימי'] },
    { id: 'SN', title: 'איך קולטים את העולם', labels: ['קונקרטי', 'עיוני'], explanations: ['פרטים מוחשיים וניסיון ישיר', 'דפוסים, רעיונות ואפשרויות'] },
    { id: 'TF', title: 'מה מנחה החלטות', labels: ['שכלתני', 'רגשי'], explanations: ['עקביות, עקרונות ושיקולים ענייניים', 'ערכים אישיים וההשפעה על אנשים'] },
    { id: 'JP', title: 'איך ניגשים לחיי היום-יום', labels: ['גבולני', 'פתוח'], explanations: ['מסגרת, תכנון וסגירת קצוות', 'גמישות, התאמה והשארת אפשרויות'] }
  ];
  const hebrew = { E: 'ח', I: 'מ', S: 'ק', N: 'ע', T: 'ש', F: 'ר', J: 'ג', P: 'פ', X: '?' };
  function score(questions, answers) {
    if (!Array.isArray(answers) || answers.length !== questions.length || Array.from(answers).some(a => !Number.isInteger(a) || a < 1 || a > 5)) {
      throw new Error('יש להשיב על כל השאלות בתשובות בין 1 ל-5');
    }
    const results = axes.map(axis => {
      let sum = 0, count = 0, neutral = 0, first = 0, second = 0;
      questions.forEach((q, i) => {
        if (q.axis !== axis.id) return;
        const value = (3 - answers[i]) * (q.aPole === axis.id[0] ? 1 : -1);
        sum += value; count++;
        if (!value) neutral++; else if (value > 0) first++; else second++;
      });
      if (!count) throw new Error('Missing axis: ' + axis.id);
      const normalized = sum / (count * 2);
      const firstPercent = Math.round(50 + 50 * normalized);
      return { ...axis, sum, count, neutral, first, second, normalized, firstPercent,
        secondPercent: 100 - firstPercent, letter: sum === 0 ? 'X' : sum > 0 ? axis.id[0] : axis.id[1],
        close: Math.abs(normalized) <= 0.25,
        label: sum === 0 ? 'ללא העדפה מכריעה' : Math.abs(normalized) <= 0.25 ? 'נטייה קלה' : Math.abs(normalized) <= 0.6 ? 'נטייה בינונית' : 'נטייה בולטת' };
    });
    const code = results.map(a => a.letter).join('');
    const candidates = results.reduce((codes, a) => codes.flatMap(c => (a.close ? [...a.id] : [a.letter]).map(l => c + l)), ['']);
    candidates.sort((a, b) => distance(a) - distance(b) || a.localeCompare(b));
    function distance(type) { return results.reduce((total, axis, i) => total + (1 - (type[i] === axis.id[0] ? 1 : -1) * axis.normalized), 0); }
    return { code, hebrewCode: [...code].map(c => hebrew[c]).join(''), axes: results, candidates,
      neutralCount: answers.filter(a => a === 3).length,
      straightLine: new Set(answers).size === 1 };
  }
  const api = { axes, hebrew, score };
  if (typeof module !== 'undefined' && module.exports) module.exports = api;
  else root.MBTI = api;
})(typeof globalThis !== 'undefined' ? globalThis : this);
</script>
<script>(() => {
  'use strict';
  const $ = id => document.getElementById(id);
  const questions = MBTI_DATA.questions;
  const key = 'nhlocal.16-types.v1';
  const themeKey = 'nhlocal.16-types.theme';
  const systemTheme = matchMedia('(prefers-color-scheme: dark)');
  let explicitTheme = null;
  try { const saved = localStorage.getItem(themeKey); if (saved === 'light' || saved === 'dark') explicitTheme = saved; } catch {}
  function applyTheme(theme) {
    document.documentElement.dataset.theme = theme;
    const dark = theme === 'dark';
    $('theme-toggle').setAttribute('aria-pressed', String(dark));
    $('theme-toggle').title = dark ? 'מעבר למצב בהיר' : 'מעבר למצב אפל';
    $('theme-color').content = dark ? '#171d28' : '#fcf7f1';
  }
  applyTheme(explicitTheme || (systemTheme.matches ? 'dark' : 'light'));
  $('theme-toggle').addEventListener('click', () => {
    explicitTheme = document.documentElement.dataset.theme === 'dark' ? 'light' : 'dark';
    applyTheme(explicitTheme);
    try { localStorage.setItem(themeKey, explicitTheme); } catch {}
  });
  systemTheme.addEventListener('change', event => { if (!explicitTheme) applyTheme(event.matches ? 'dark' : 'light'); });
  const optionLabels = ["בבירור א'", "נוטה ל-א'", 'לא ברור', "נוטה ל-ב'", "בבירור ב'"];
  const fullLabels = ["בבירור א', העדפה ברורה לאפשרות א'", "נוטה ל-א', העדפה קלה לאפשרות א'", 'לא ברור, אין העדפה ברורה בין האפשרויות', "נוטה ל-ב', העדפה קלה לאפשרות ב'", "בבירור ב', העדפה ברורה לאפשרות ב'"];
  let answers = Array(questions.length).fill(null), current = 0, screen = 'welcome', returnToReview = false, result = null, storageWorks = true, resetStartsQuiz = false, toastTimer;
  const esc = value => String(value).replace(/[&<>"']/g, char => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[char]));
  const answered = () => answers.filter(a => a !== null).length;
  function storageFailure() {
    storageWorks = false;
    $('storage-status').hidden = false;
    $('storage-status').textContent = 'השמירה בדפדפן אינה זמינה כרגע. אפשר להמשיך, אבל רענון או סגירה של הדף עלולים למחוק את ההתקדמות';
    $('pause').textContent = 'יציאה מהשאלון';
  }
  function load() {
    try {
      const raw = localStorage.getItem(key);
      if (!raw) return;
      const saved = JSON.parse(raw);
      if (!saved || saved.version !== MBTI_DATA.revision || !Array.isArray(saved.answers) || saved.answers.length !== questions.length || !saved.answers.every(a => a === null || (Number.isInteger(a) && a >= 1 && a <= 5)) || !Number.isInteger(saved.current) || saved.current < 0 || saved.current >= questions.length) {
        localStorage.removeItem(key); return;
      }
      answers = saved.answers; current = saved.current;
    } catch (error) {
      if (error instanceof SyntaxError) { try { localStorage.removeItem(key); } catch { storageFailure(); } }
      else storageFailure();
    }
  }
  function save() {
    if (!storageWorks) return;
    try { localStorage.setItem(key, JSON.stringify({version: MBTI_DATA.revision, answers, current})); }
    catch { storageFailure(); }
  }
  function show(id, focusId) {
    screen = id;
    ['welcome','quiz','review','results'].forEach(name => { $(name).hidden = name !== id; });
    if (focusId) $(focusId).focus({preventScroll:true});
    window.scrollTo({top:0,behavior:'instant'});
  }
  function welcome() {
    const count = answered();
    $('start').hidden = count > 0;
    $('resume').hidden = count === 0;
    $('fresh').hidden = count === 0;
    $('resume').querySelector('span').textContent = count === questions.length ? 'חזרה לתוצאה שלי' : 'להמשיך מאיפה שעצרתי';
    show('welcome');
  }
  function updateProgress() {
    $('progress').max = questions.length;
    $('progress').value = answered();
    $('progress-text').textContent = `${answered()} מתוך ${questions.length} נענו`;
  }
  function renderQuestion() {
    const q = questions[current], chapter = Math.floor(current / 8);
    $('chapter-label').textContent = `פרק ${chapter + 1} מתוך ${MBTI_DATA.chapters.length} · ${MBTI_DATA.chapters[chapter]}`;
    $('question-counter').textContent = `שאלה ${current + 1} מתוך ${questions.length}`;
    $('question-heading').textContent = q.text;
    $('option-a').textContent = q.a; $('option-b').textContent = q.b;
    $('answer-options').innerHTML = optionLabels.map((label, i) => `<label class="answer-choice"><input type="radio" name="answer" value="${i+1}" aria-label="${esc(fullLabels[i])}" ${answers[current] === i+1 ? 'checked' : ''}><span><i aria-hidden="true"></i>${label}</span></label>`).join('');
    $('previous').disabled = current === 0;
    $('next').querySelector('span').textContent = returnToReview ? 'שמירה וחזרה למפה' : current === questions.length - 1 ? 'לתוצאות' : 'הבא';
    $('answer-error').hidden = true;
    updateProgress(); save();
    show('quiz', 'question-heading');
    $('announcement').textContent = `שאלה ${current+1} מתוך ${questions.length}. ${MBTI_DATA.chapters[chapter]}`;
  }
  function start() { current = 0; returnToReview = false; renderQuestion(); }
  function review() {
    $('review-count').textContent = `${answered()} מתוך ${questions.length} שאלות נענו`;
    $('review-list').innerHTML = MBTI_DATA.chapters.map((chapter, c) => `<section class="review-group"><h3>${c+1}. ${esc(chapter)}</h3>${questions.slice(c*8,c*8+8).map(q => {
      const a = answers[q.id-1];
      return `<button class="review-question" data-index="${q.id-1}"><b>${q.id}.</b> ${esc(q.text)}<small>${a === null ? 'עדיין לא נענתה' : esc(fullLabels[a-1]) + (a === 3 ? '' : ': ' + esc(a < 3 ? q.a : q.b))}</small></button>`;
    }).join('')}</section>`).join('');
    $('review-finish').querySelector('span').textContent = answered() === questions.length ? 'לתוצאות' : `להמשיך לשאלות שנותרו (${questions.length - answered()})`;
    show('review', 'review-heading');
  }
  function typeStyle(code) {
    const p = MBTI_PALETTES[code];
    return p ? `--type-light-accent:${p.accent};--type-light-soft:${p.soft};--type-dark-accent:${p.darkAccent};--type-dark-soft:${p.darkSoft}` : '';
  }
  function profileHTML(code, preview = false) {
    const p = MBTI_PROFILES[code];
    const words = [...code].map((letter,i) => MBTI.axes[i].labels[MBTI.axes[i].id.indexOf(letter)]).join(' · ');
    return `<div class="type-profile ${preview ? 'preview-card' : ''}" style="${typeStyle(code)}"><div class="profile-top"><div class="profile-identity"><div class="profile-codes"><bdi class="type-code">${code}</bdi><span class="he-code">${p.he}</span></div><h3 class="profile-name">${esc(p.name)}</h3><p>${words}</p></div><img class="profile-character" src="${MBTI_ILLUSTRATIONS[code]}" alt="" width="210" height="210"></div><p>${esc(p.description)}</p><h4>העדפות וחוזקות אפשריות</h4><ul>${p.strengths.map(s => `<li>${esc(s)}</li>`).join('')}</ul><h4>נקודה למחשבה</h4><p>${esc(p.stretch)}</p><h4>בקשרים עם אנשים</h4><p>${esc(p.relationships)}</p><h4>בלמידה ובעשייה</h4><p>${esc(p.work)}</p><div class="experiment"><h4>אפשר לנסות השבוע</h4><p>${esc(p.experiment)}</p></div></div>`;
  }
  function typeButton(code) {
    const p = MBTI_PROFILES[code];
    return `<button type="button" class="type-chip" style="${typeStyle(code)}" data-type="${code}" aria-pressed="false" aria-controls="type-preview"><img class="type-character" src="${MBTI_ILLUSTRATIONS[code]}" alt="" width="96" height="96" loading="lazy"><span class="type-chip-codes"><bdi dir="ltr">${code}</bdi><span>${p.he}</span></span><span class="type-chip-name">${esc(p.name)}</span></button>`;
  }
  function previewType(code) {
    document.querySelectorAll('[data-type]').forEach(button => button.setAttribute('aria-pressed', String(button.dataset.type === code)));
    $('type-preview').innerHTML = profileHTML(code, true);
  }
  function results() {
    if (answered() !== questions.length) { current = answers.indexOf(null); returnToReview = false; renderQuestion(); return; }
    result = MBTI.score(questions, answers);
    const tied = result.code.includes('X');
    $('results').style.cssText = typeStyle(result.code);
    $('result-heading').textContent = tied ? 'לא התקבלה העדפה בכל הצירים' : `הכיוון שלך: ${MBTI_PROFILES[result.code].name}`;
    $('result-subtitle').textContent = tied ? 'בחלק מהצירים אין כרגע העדפה מכריעה. אפשר לעיין בפירוט ולהשוות בין התיאורים' : 'הפרופיל שעולה מהתשובות שלך';
    $('profile-card').innerHTML = tied ? `<div class="profile-top"><bdi class="type-code">${result.code}</bdi></div><h3>אין טיפוס יחיד בתוצאה הזו</h3><p>האות X מסמנת ציר שבו התקבל שוויון. לא בחרנו עבורך צד שרירותי, ולכן אין כאן תיאור של טיפוס יחיד.</p><p>אפשר לעיין בצירופים המוצעים בהמשך, ולחשוב איזו העדפה חוזרת בחיים שלך כשיש חופש לבחור.</p><div class="experiment"><h4>אפשר לנסות השבוע</h4><p>לתעד שלושה רגעים של בחירה חופשית: מה בחרת, למה, והאם זו הייתה העדפה או דרישה של המצב.</p></div>` : profileHTML(result.code);
    $('axis-results').innerHTML = result.axes.map(a => {
      const winner = a.id.indexOf(a.letter);
      const percentages = [a.firstPercent, a.secondPercent];
      const emphasis = i => i === winner ? ' is-dominant' : '';
      const summary = winner < 0 ? 'אין העדפה לצד מסוים' : `${a.close ? 'נטייה קלה' : 'הנטייה שלך'}: ${a.labels[winner]}`;
      return `<section class="axis-row"><div class="axis-title"><b>${a.title}</b></div><div class="axis-labels">${a.labels.map((label,i) => `<div class="axis-pole${emphasis(i)}"><strong>${label}</strong><bdi dir="ltr">${a.id[i]} · ${percentages[i]}%</bdi></div>`).join('')}</div><div class="axis-bar" role="img" aria-label="${a.labels[0]} ${a.firstPercent} אחוז, ${a.labels[1]} ${a.secondPercent} אחוז">${percentages.map((value,i) => `<i class="${emphasis(i).trim()}" style="width:${value}%"></i>`).join('')}</div><p class="axis-explain"><strong>${summary}</strong>${winner < 0 ? '' : `<br>${a.explanations[winner]}`}</p></section>`;
    }).join('');
    const notices = [];
    if (result.neutralCount >= questions.length / 2) notices.push('בחלק גדול מהשאלות נבחר האמצע. ייתכן ששתי האפשרויות מתאימות לך או שההעדפות משתנות בין מצבים. כדאי לתת לתיאורים משקל מוגבל');
    if (result.straightLine && result.neutralCount === 0) notices.push('נבחרה אותה עמדה בכל השאלות. מכיוון שכיוון האפשרויות מתחלף, התוצאה מאוזנת. כדאי לעבור על התשובות ולבדוק שהבחירות מבטאות את ההעדפות שלך');
    const close = result.axes.filter(a => a.close);
    if (close.length && !tied) notices.push(`בצירים ${close.map(a=>a.labels.join(' / ')).join(', ')} הנטייה קרובה לאמצע. שינוי בכמה תשובות עשוי לשנות את האות המתאימה`);
    $('result-notice').hidden = notices.length === 0;
    $('result-notice').innerHTML = notices.map(n => `<p>${esc(n)}</p>`).join('');
    const nearby = result.candidates.filter(c => c !== result.code);
    $('nearby').hidden = nearby.length === 0;
    $('nearby-explanation').textContent = 'בצירים הקרובים לאמצע כדאי להשוות גם לתיאורים האלה';
    $('nearby-types').innerHTML = nearby.map(typeButton).join('');
    $('type-picker').innerHTML = Object.keys(MBTI_PROFILES).map(typeButton).join('');
    previewType(tied ? result.candidates[0] : result.code);
    save(); show('results', 'result-heading');
  }
  function resultText() {
    const lines = ['16 הטיפוסים | שאלון עצמאי להיכרות עצמית', '', `הצירוף: ${result.code} (${result.hebrewCode})`];
    if (MBTI_PROFILES[result.code]) {
      const p = MBTI_PROFILES[result.code];
      lines.push(p.name, '', p.description, '', 'חוזקות אפשריות:', ...p.strengths.map(s=>'• '+s), '', 'נקודה למחשבה:',p.stretch,'','בקשרים:',p.relationships,'','בלמידה ובעשייה:',p.work,'','ניסוי קטן:',p.experiment);
    } else lines.push('X מסמן שוויון בציר. לא נבחר טיפוס יחיד');
    lines.push('', 'ההעדפות שלך בארבעת התחומים:');
    result.axes.forEach(a => lines.push(`${a.labels[0]} ${a.firstPercent}% | ${a.labels[1]} ${a.secondPercent}% (${a.label})`));
    if (result.candidates.length > 1) lines.push('', 'צירופים להשוואה: ' + result.candidates.join(', '));
    if (!$('result-notice').hidden) lines.push('', $('result-notice').textContent);
    lines.push('', 'האחוזים הם ציוני נטייה מהתשובות, לא הסתברות או מדד ליכולת. שאלון זה אינו מבחן MBTI רשמי ולא עבר תיקוף פסיכומטרי. התוצאה אינה אבחון.', `גרסת שאלון: ${MBTI_DATA.revision}`);
    return lines.join('\n');
  }
  function toast(message) { $('toast').textContent = message; $('toast').hidden = false; clearTimeout(toastTimer); toastTimer = setTimeout(() => {$('toast').hidden = true;}, 5000); }
  function askReset(startAfter) {
    resetStartsQuiz = startAfter;
    $('reset-dialog').setAttribute('aria-labelledby','reset-title');
    $('confirm-reset').textContent = startAfter ? 'למחוק ולהתחיל מחדש' : 'למחוק את התשובות';
    $('reset-dialog').showModal();
  }
  $('start').addEventListener('click',start);
  $('resume').addEventListener('click',()=>{ returnToReview=false; answered()===questions.length ? results() : renderQuestion(); });
  $('pause').addEventListener('click',()=>{save();welcome();$('resume').focus();});
  $('answer-options').addEventListener('change',event=>{ if(event.target.name !== 'answer') return; answers[current]=Number(event.target.value);$('answer-error').hidden=true;save();updateProgress();});
  $('quiz-form').addEventListener('submit',event=>{
    event.preventDefault();
    if(answers[current]===null){$('answer-error').hidden=false;$('answer-options').querySelector('input').focus();return;}
    if(returnToReview){returnToReview=false;review();return;}
    if(current===questions.length-1){results();return;}
    current++;renderQuestion();
  });
  $('previous').addEventListener('click',()=>{if(current>0){current--;renderQuestion();}});
  $('review-link').addEventListener('click',review);
  $('review-list').addEventListener('click',event=>{const button=event.target.closest('[data-index]');if(!button)return;current=Number(button.dataset.index);returnToReview=true;renderQuestion();});
  $('review-back').addEventListener('click',()=>{returnToReview=false;renderQuestion();});
  $('review-finish').addEventListener('click',results);
  $('edit').addEventListener('click',review);
  $('type-picker').addEventListener('click', event => {
    const button = event.target.closest('[data-type]');
    if (!button) return;
    previewType(button.dataset.type);
    $('type-preview').focus({preventScroll:true});
    $('type-preview').scrollIntoView({block:'start',behavior:'instant'});
  });
  $('nearby-types').addEventListener('click',event=>{const button=event.target.closest('[data-type]');if(!button)return;document.querySelector('.explore').open=true;previewType(button.dataset.type);$('type-preview').focus({preventScroll:true});$('type-preview').scrollIntoView({block:'start',behavior:'instant'});});
  $('download').addEventListener('click',()=>{const blob=new Blob(['\ufeff'+resultText()],{type:'text/plain;charset=utf-8'});const url=URL.createObjectURL(blob);const link=document.createElement('a');link.href=url;link.download=`16-types-${result.code}.txt`;document.body.appendChild(link);link.click();link.remove();setTimeout(()=>URL.revokeObjectURL(url),1000);toast('הסיכום מוכן להורדה');});
  $('copy').addEventListener('click',async()=>{try{await navigator.clipboard.writeText(resultText());toast('הסיכום הועתק');}catch{toast('ההעתקה אינה זמינה בדפדפן הזה. אפשר לשמור את התוצאה כקובץ');}});
  $('print').addEventListener('click',()=>window.print());
  $('fresh').addEventListener('click',()=>askReset(true));
  $('restart').addEventListener('click',()=>askReset(true));
  $('erase').addEventListener('click',()=>askReset(false));
  $('cancel-reset').addEventListener('click',()=>$('reset-dialog').close());
  $('confirm-reset').addEventListener('click',()=>{
    let removed=true;
    try{localStorage.removeItem(key);}catch{removed=false;storageFailure();}
    answers=Array(questions.length).fill(null);current=0;result=null;returnToReview=false;
    $('reset-dialog').close();
    if(resetStartsQuiz)start();else{welcome();$('start').focus();}
    toast(removed?'התשובות הקודמות נמחקו':'התשובות אופסו בדף. מחיקת האחסון חסומה; אפשר לנקות את נתוני האתר בהגדרות הדפדפן');
  });
  $('about-toggle').addEventListener('click',()=>{const open=$('method').hidden;$('method').hidden=!open;$('about-toggle').setAttribute('aria-expanded',String(open));});
  load(); welcome();
})();
</script>
</body>
</html>
"; +window.NHLocalDownloads["the_16_types"] = "<!DOCTYPE html>
<html lang="he" dir="rtl">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <meta id="theme-color" name="theme-color" content="#fcf7f1">
  <script>
    (() => {
      let saved;
      try { saved = localStorage.getItem("nhlocal.16-types.theme"); } catch {}
      const dark = saved === "dark" || (saved !== "light" && matchMedia("(prefers-color-scheme: dark)").matches);
      document.documentElement.dataset.theme = dark ? "dark" : "light";
      document.getElementById("theme-color").content = dark ? "#171d28" : "#fcf7f1";
    })();
  </script>
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 64 64'%3E%3Crect width='64' height='64' rx='18' fill='%23e9eef5'/%3E%3Ctext x='32' y='45' font-family='Arial' font-size='36' font-weight='700' text-anchor='middle' fill='%23526b91'%3E16%3C/text%3E%3C/svg%3E">
  <style>/* Embedded Assistant font license:
Copyright 2020 The Assistant Project Authors (https://github.com/hafontia/Assistant).
Copyright 2010 The Source Sans Pro Authors (https://github.com/adobe-fonts/source-sans-pro), with Reserved Font Name 'Source'.
Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries.

This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at:
http://scripts.sil.org/OFL


-----------------------------------------------------------
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------

PREAMBLE
The goals of the Open Font License (OFL) are to stimulate worldwide
development of collaborative font projects, to support the font creation
efforts of academic and linguistic communities, and to provide a free and
open framework in which fonts may be shared and improved in partnership
with others.

The OFL allows the licensed fonts to be used, studied, modified and
redistributed freely as long as they are not sold by themselves. The
fonts, including any derivative works, can be bundled, embedded,
redistributed and/or sold with any software provided that any reserved
names are not used by derivative works. The fonts and derivatives,
however, cannot be released under any other type of license. The
requirement for fonts to remain under this license does not apply
to any document created using the fonts or their derivatives.

DEFINITIONS
"Font Software" refers to the set of files released by the Copyright
Holder(s) under this license and clearly marked as such. This may
include source files, build scripts and documentation.

"Reserved Font Name" refers to any names specified as such after the
copyright statement(s).

"Original Version" refers to the collection of Font Software components as
distributed by the Copyright Holder(s).

"Modified Version" refers to any derivative made by adding to, deleting,
or substituting -- in part or in whole -- any of the components of the
Original Version, by changing formats or by porting the Font Software to a
new environment.

"Author" refers to any designer, engineer, programmer, technical
writer or other person who contributed to the Font Software.

PERMISSION & CONDITIONS
Permission is hereby granted, free of charge, to any person obtaining
a copy of the Font Software, to use, study, copy, merge, embed, modify,
redistribute, and sell modified and unmodified copies of the Font
Software, subject to the following conditions:

1) Neither the Font Software nor any of its individual components,
in Original or Modified Versions, may be sold by itself.

2) Original or Modified Versions of the Font Software may be bundled,
redistributed and/or sold with any software, provided that each copy
contains the above copyright notice and this license. These can be
included either as stand-alone text files, human-readable headers or
in the appropriate machine-readable metadata fields within text or
binary files as long as those fields can be easily viewed by the user.

3) No Modified Version of the Font Software may use the Reserved Font
Name(s) unless explicit written permission is granted by the corresponding
Copyright Holder. This restriction only applies to the primary font name as
presented to the users.

4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
Software shall not be used to promote, endorse or advertise any
Modified Version, except to acknowledge the contribution(s) of the
Copyright Holder(s) and the Author(s) or with their explicit written
permission.

5) The Font Software, modified or unmodified, in part or in whole,
must be distributed entirely under this license, and must not be
distributed under any other license. The requirement for fonts to
remain under this license does not apply to any document created
using the Font Software.

TERMINATION
This license becomes null and void if any of the above conditions are
not met.

DISCLAIMER
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
OTHER DEALINGS IN THE FONT SOFTWARE.

*/
@font-face{font-family:Assistant;src:url(data:font/ttf;base64,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) format('truetype');font-weight:200 800;font-display:swap}
:root {
  color-scheme: light;
  --on-accent: #fff;
  --surface-warm: #f6f1ea;
  --surface-cool: #f0f3f7;
  --sheet-border: #ffffffad;
  --sheet-shadow: 10px 12px 0 #efe2d565, 0 18px 40px #687a9610;
  --sheet-row: #fffdf9;
  --sheet-row-alt: #f9f2eb;
  --notice-bg: #f6ecdc;
  --notice-line: #e7d4b4;
  --track: #dce1e8;
  --paper: #fcf7f1;
  --white: #fffdfa;
  --ink: #3b414e;
  --muted: #686772;
  --accent: #526b91;
  --accent-hover: #435b80;
  --clay: #9b634f;
  --blue-soft: #e9eef5;
  --peach-soft: #f5e6dc;
  --line: #e4dfd9;
  --green: #526b91;
  --error: #aa3b37;
  --ease: 180ms ease;
  --soft-shadow: 0 12px 35px #63564c08;
}
:root[data-theme="dark"] {
  color-scheme: dark;
  --paper: #171d28;
  --white: #222c3a;
  --ink: #edf1f7;
  --muted: #b6c1d1;
  --accent: #a5c1eb;
  --accent-hover: #bed2f0;
  --on-accent: #18263b;
  --clay: #e4b298;
  --blue-soft: #293b52;
  --peach-soft: #3a302e;
  --line: #415065;
  --surface-warm: #2b3039;
  --surface-cool: #263241;
  --sheet-border: #35465b;
  --sheet-shadow: 10px 12px 0 #111722, 0 18px 40px #0002;
  --sheet-row: #222e3e;
  --sheet-row-alt: #32333b;
  --notice-bg: #3a3229;
  --notice-line: #64553f;
  --track: #445066;
  --green: #a5c1eb;
  --error: #ffaba5;
  --soft-shadow: 0 10px 30px #0002;
}
* { box-sizing: border-box; }
body { margin: 0; background: var(--paper); color: var(--ink); font-family: Assistant, "Segoe UI", Arial, sans-serif; font-size: 18px; line-height: 1.7; }
button, input, select { font: inherit; }
button, a, summary, select { touch-action: manipulation; }
button { cursor: pointer; color: inherit; }
a { color: inherit; }
button:disabled { cursor: default; opacity: .4; }
[hidden] { display: none !important; }
::selection { background: #d6e1f0; color: var(--ink); }
:focus-visible { outline: 3px solid var(--accent); outline-offset: 5px; }
h1, h2, h3, p { margin-top: 0; }
h1, h2, h3 { line-height: 1.3; font-weight: 700; letter-spacing: 0; }
h2 { font-size: clamp(1.8rem, 3.4vw, 2.7rem); }
h3 { font-size: 1.3rem; }
p { margin-bottom: 1em; }
.shell { max-width: 1170px; padding-inline: 40px; margin-inline: auto; }
.site-header { min-height: 108px; display: flex; justify-content: space-between; align-items: center; gap: 20px; }
.brand { display: flex; align-items: center; gap: 11px; font-size: 1.28rem; font-weight: 550; text-decoration: none; }
.brand-mark { display: grid; place-items: center; flex: 0 0 auto; width: 52px; height: 52px; border-radius: 18px; background: var(--blue-soft); color: var(--accent); font-size: 1.5rem; font-weight: 750; line-height: 1; letter-spacing: 0; direction: ltr; }
.back-link { font-size: .9rem; text-decoration: none; color: var(--muted); padding: 8px 13px; border-radius: 20px; }
.header-actions { display: flex; align-items: center; gap: 16px; }
.theme-toggle { display: grid; place-items: center; width: 44px; height: 44px; flex-shrink: 0; padding: 0; border: 1px solid var(--line); border-radius: 50%; background: var(--white); color: var(--accent); }
.theme-toggle:hover { background: var(--blue-soft); }
.theme-toggle .icon { width: 21px; height: 21px; }
.theme-toggle .theme-sun, [data-theme="dark"] .theme-toggle .theme-moon { display: none; }
[data-theme="dark"] .theme-toggle .theme-sun { display: block; }
.back-link:hover { color: var(--accent); background: var(--blue-soft); }
.back-link { display: inline-flex; align-items: center; gap: 7px; }
.icon { display: block; width: 1.1em; height: 1.1em; flex: 0 0 auto; fill: none; stroke: currentColor; stroke-width: 1.8; stroke-linecap: round; stroke-linejoin: round; }
.screen { animation: arrive .28s ease both; }
.hero { display: grid; grid-template-columns: 1.2fr 1fr; gap: 78px; align-items: center; padding-block: 43px 58px; }
.hero h1 { font-size: clamp(3rem, 5.3vw, 4.7rem); font-weight: 800; line-height: 1.2; letter-spacing: -.015em; margin: 0 0 27px; }
.hero h1 em { font-style: normal; color: var(--clay); font-weight: 800; }
.lead { color: var(--muted); font-size: 1.06rem; line-height: 1.95; max-width: 550px; }
.hero .lead { margin-bottom: 28px; }
.button { display: inline-flex; align-items: center; justify-content: center; gap: 12px; min-height: 48px; max-width: 100%; padding: 11px 22px; border: 1px solid transparent; border-radius: 14px; font-size: 1.125rem; line-height: 1.3; font-weight: 700; text-align: center; text-decoration: none; transition: background var(--ease), transform var(--ease), box-shadow var(--ease); }
.hero-copy > .button { min-height: 52px; padding: 12px 24px; font-size: 1.25rem; gap: 18px; }
.primary { color: var(--on-accent); background: var(--accent); box-shadow: 0 3px 8px #526b9118; }
.primary:not(:disabled):hover { background: var(--accent-hover); transform: translateY(-1px); box-shadow: 0 4px 10px #526b9126; }
.primary:not(:disabled):active { transform: translateY(0); box-shadow: none; }
.secondary { color: var(--ink); background: var(--white); border-color: var(--line); }
.secondary:hover { background: var(--blue-soft); border-color: var(--line); }
.text-button { border: 0; background: transparent; color: var(--muted); padding: 10px 3px; border-radius: 8px; font-size: .85rem; text-decoration: underline; text-decoration-color: transparent; text-underline-offset: 5px; }
.text-button:hover { color: var(--accent); text-decoration-color: currentColor; }
.micro { font-size: .81rem; color: var(--muted); line-height: 1.8; margin-block: 15px 0; }
.type-sheet { position: relative; padding: 20px 27px 30px; background: var(--blue-soft); border: 7px solid var(--sheet-border); border-radius: 43% 43% 37px 37px; transform: rotate(-3deg); box-shadow: var(--sheet-shadow); }
.sheet-number { font-size: 9.2rem; font-weight: 650; line-height: 1.5; letter-spacing: -.11em; text-align: center; direction: ltr; padding-inline-end: .08em; color: var(--accent); }
.sheet-axes { display: grid; gap: 9px; }
.sheet-axes > div { display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 8px; align-items: center; padding: 10px 18px; background: var(--sheet-row); border-radius: 24px; font-size: .91rem; box-shadow: 0 2px 0 #c7d2df44; }
.sheet-axes > div:nth-child(even) { background: var(--sheet-row-alt); }
.sheet-axes > div > span:last-child { text-align: left; }
.sheet-axes bdi { text-align: center; font-size: .8rem; letter-spacing: .06em; color: var(--accent); }
.intro-details { margin: 17px auto 44px; display: grid; grid-template-columns: 1fr 1fr; gap: 16px; align-items: start; }
details { padding: 21px 22px; border: 1px solid var(--line); background: var(--white); border-radius: 23px; box-shadow: 0 4px 14px #60564e03; }
summary { cursor: pointer; font-weight: 600; list-style-position: outside; margin-inline-start: 16px; padding-inline-start: 7px; }
summary::marker { color: #7c8ba1; font-size: .8em; }
details > p, details > div { margin-top: 18px; color: var(--muted); font-size: .93rem; }
.eyebrow { display: inline-flex; align-items: center; gap: 9px; font-size: .83rem; font-weight: 450; color: var(--muted); }
.quiz-wrap { max-width: 850px; margin: 26px auto 55px; }
.quiz-top, .progress-heading { display: flex; justify-content: space-between; align-items: center; gap: 16px; }
.quiz-top { margin-bottom: 15px; }
.progress-heading { font-size: .84rem; margin-bottom: 10px; color: var(--muted); }
progress { display: block; border: 0; background: var(--track); width: 100%; height: 7px; border-radius: 10px; overflow: hidden; accent-color: var(--accent); }
progress::-webkit-progress-bar { background: var(--track); border-radius: 10px; }
progress::-webkit-progress-value { background: var(--accent); border-radius: 10px; transition: width .2s ease; }
progress::-moz-progress-bar { background: var(--accent); border-radius: 10px; }
.question-card { margin-top: 27px; padding: 36px 37px 32px; background: var(--white); border: 1px solid var(--line); border-radius: 32px; box-shadow: var(--soft-shadow); }
.question-card h2 { font-size: clamp(1.4rem, 2.6vw, 1.9rem); font-weight: 700; line-height: 1.55; margin: 0 0 25px; min-height: 3.1em; letter-spacing: 0; }
.situation-options { display: grid; grid-template-columns: 1fr 1fr; gap: 15px; margin-bottom: 25px; }
.situation { padding: 20px; background: var(--surface-warm); border-radius: 22px; }
.situation > span { display: grid; place-items: center; width: 34px; height: 34px; border-radius: 13px; background: var(--blue-soft); color: var(--accent); font-weight: 500; font-size: 1.05rem; margin-bottom: 12px; }
.situation p { margin: 0; font-size: 1.125rem; line-height: 1.7; }
fieldset { border: 0; padding: 0; margin: 0; min-width: 0; }
legend { font-size: 1rem; text-align: center; margin: 0 auto 16px; padding: 0; color: var(--muted); }
.answer-options { display: grid; grid-template-columns: repeat(5, minmax(0, 1fr)); gap: 9px; }
.answer-choice { position: relative; cursor: pointer; }
.answer-choice input { position: absolute; opacity: 0; width: 1px; height: 1px; }
.answer-choice > span { display: flex; align-items: center; justify-content: center; flex-direction: column; gap: 12px; padding: 15px 3px; min-height: 98px; font-size: 1rem; font-weight: 600; line-height: 1.35; text-align: center; border: 1px solid var(--line); border-radius: 18px; background: var(--white); transition: background var(--ease), border-color var(--ease), box-shadow var(--ease); }
.answer-choice i { display: block; width: 19px; height: 19px; border: 1.5px solid var(--muted); border-radius: 50%; position: relative; }
.answer-choice:nth-child(1) i, .answer-choice:nth-child(5) i { width: 24px; height: 24px; }
.answer-choice:nth-child(3) i { width: 14px; height: 14px; }
.answer-choice:hover > span { background: var(--surface-cool); border-color: var(--accent); }
.answer-choice input:checked + span { background: var(--accent); color: var(--on-accent); border-color: var(--accent); box-shadow: 0 2px 7px #526b9118; }
.answer-choice input:checked + span i { border-color: var(--on-accent); background: var(--on-accent); }
.answer-choice input:checked + span i:after { content: ""; position: absolute; inset: 4px; border-radius: 50%; background: var(--accent); }
.answer-choice input:focus-visible + span { outline: 3px solid var(--accent); outline-offset: 4px; }
.quiz-nav { display: flex; justify-content: space-between; gap: 16px; margin-top: 25px; }
.quiz-nav .button { min-width: 112px; }
.quiz-bottom { display: flex; justify-content: flex-end; margin-top: 18px; }
.error { color: var(--error); font-size: .9rem; margin: 18px 0 0; }
.reading-width { max-width: 850px; margin: 38px auto 60px; }
.reading-width h2 { margin-top: 12px; }
.review-group { margin-top: 28px; }
.review-question { display: block; width: 100%; text-align: start; border: 1px solid var(--line); background: var(--white); border-radius: 18px; padding: 17px 20px; margin-bottom: 10px; font-size: .97rem; }
.review-question:hover { background: var(--surface-cool); }
.review-question small { display: block; color: var(--muted); margin-top: 7px; font-size: .85rem; }
.action-row { display: flex; gap: 12px; align-items: center; flex-wrap: wrap; margin-top: 25px; }
.result-intro { margin: 35px 0 29px; }
.result-intro h2 { margin: 15px 0; }
.result-intro .lead { max-width: 750px; }
main.shell:has(#results:not([hidden])) { max-width: 1400px; }
.result-layout { display: grid; grid-template-columns: minmax(0, 1.75fr) minmax(320px, 1fr); gap: 27px; align-items: start; }
#results, .type-profile, .type-chip { --type-accent: var(--type-light-accent, var(--accent)); --type-soft: var(--type-light-soft, var(--blue-soft)); }
[data-theme="dark"] #results, [data-theme="dark"] .type-profile, [data-theme="dark"] .type-chip { --type-accent: var(--type-dark-accent, var(--accent)); --type-soft: var(--type-dark-soft, var(--blue-soft)); }
#results .profile-card { border-color: color-mix(in srgb, var(--type-accent) 30%, var(--line)); }
/* Keep the illustration backdrop distinct from its surrounding surface. */
.type-profile, .type-chip { --type-art-surface: color-mix(in srgb, var(--type-soft) 40%, var(--white)); }
.type-profile .profile-top { background: var(--type-art-surface); }
.type-profile .type-code, .profile-card .type-profile h4, .preview-card.type-profile h4 { color: var(--type-accent); }
.type-profile .experiment { background: var(--type-soft); }
#results .axis-pole.is-dominant { border-color: var(--type-accent); color: var(--type-accent); }
#results .axis-bar i.is-dominant { background: var(--type-accent); }
.profile-card { background: var(--white); padding: 30px; border: 1px solid var(--line); border-radius: 30px; box-shadow: var(--soft-shadow); }
.profile-top { display: flex; align-items: center; justify-content: space-between; gap: 14px; padding: 16px 21px; margin-bottom: 24px; border-radius: 22px; background: var(--blue-soft); }
.profile-codes { display: flex; flex-wrap: wrap; align-items: baseline; gap: 8px 12px; }
.profile-codes .he-code { margin: 0; }
.profile-identity { min-width: 0; }
.profile-identity .profile-name { margin: 12px 0 8px; }
.profile-identity p { margin: 0; font-size: .98rem; color: var(--muted); }
.profile-character { display: block; width: clamp(120px, 16vw, 210px); height: auto; flex: 0 0 auto; }
.type-character { display: block; width: 96px; height: 96px; align-self: center; }
.type-code { font-size: 2.8rem; letter-spacing: .02em; font-weight: 600; line-height: 1.15; color: var(--accent); }
.he-code { font-size: 1.2rem; margin-inline-start: 12px; color: var(--muted); }
.profile-name { font-size: 1.7rem; margin-bottom: 15px; }
.profile-card p { font-size: 1.0625rem; line-height: 1.8; }
.profile-card h4 { font-size: 1.02rem; margin: 25px 0 9px; color: var(--clay); font-weight: 500; }
.profile-card ul { padding-inline-start: 20px; font-size: 1.05rem; }
.profile-card li { margin-bottom: 7px; }
.experiment { padding: 18px 20px; border-radius: 20px; background: var(--peach-soft); margin-top: 25px; }
.experiment h4 { margin-top: 0; }
.experiment p { margin-bottom: 0; }
.axis-panel { container: preferences / inline-size; padding: 28px 25px; background: var(--surface-cool); border: 1px solid var(--line); border-radius: 30px; }
.axis-row { margin: 26px 0; padding-bottom: 24px; border-bottom: 1px solid var(--line); }
.axis-row:last-child { margin-bottom: 0; padding-bottom: 0; border-bottom: 0; }
.axis-title { font-size: 1rem; margin-bottom: 12px; }
.axis-title b { font-weight: 650; }
.axis-labels { display: grid; grid-template-columns: 1fr 1fr; gap: 8px; }
.axis-pole { display: flex; flex-direction: row; align-items: center; justify-content: space-between; gap: 8px; white-space: nowrap; padding: 10px 12px; border: 2px solid transparent; border-radius: 14px; color: var(--muted); }
.axis-pole strong { font-weight: 500; }
.axis-pole.is-dominant { border-color: var(--accent); background: var(--white); color: var(--accent); }
.axis-pole.is-dominant strong { font-weight: 800; }
.axis-pole bdi { font-size: .95rem; font-weight: 650; }
.axis-bar { display: flex; height: 10px; border-radius: 20px; background: var(--track); margin: 12px 0; overflow: hidden; direction: rtl; }
.axis-bar i { display: block; height: 100%; background: var(--track); }
.axis-bar i.is-dominant { background: var(--accent); }
.axis-bar i + i { border-inline-start: 2px solid var(--white); }
.axis-explain { font-size: .96rem; color: var(--muted); line-height: 1.7; margin: 0; }
.axis-explain strong { color: var(--ink); }
.axis-note { font-size: .93rem; color: var(--muted); line-height: 1.7; }
.notice { border: 1px solid var(--notice-line); background: var(--notice-bg); border-radius: 20px; padding: 18px 23px; font-size: .96rem; margin: 25px 0; }
.notice p:last-child { margin-bottom: 0; }
.nearby { margin-top: 27px; padding: 24px; background: var(--surface-warm); border-radius: 25px; }
.nearby p { font-size: .95rem; color: var(--muted); }
.type-chips, .type-picker { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 12px; }
.type-chip { display: flex; flex-direction: column; align-items: stretch; gap: 8px; min-width: 0; border: 1px solid var(--line); border-radius: 18px; background: var(--white); color: var(--ink); padding: 16px; text-align: start; cursor: pointer; transition: background var(--ease), border-color var(--ease); }
.type-chip { border-block-start: 3px solid var(--type-accent); }
.type-chip:hover { background: var(--type-art-surface); border-color: var(--type-accent); }
.type-chip[aria-pressed="true"] { background: var(--type-art-surface); border-color: var(--type-accent); box-shadow: inset 0 0 0 1px var(--type-accent); }
.type-chip-codes { display: flex; align-items: baseline; justify-content: space-between; gap: 8px; }
.type-chip-codes bdi { font-size: 1.3rem; font-weight: 750; color: var(--type-accent); letter-spacing: .04em; }
.type-chip-codes > span { color: var(--muted); font-size: .95rem; }
.type-chip-name { font-size: 1.05rem; font-weight: 650; line-height: 1.4; }
.result-disclaimer { max-width: 930px; }
.explore { margin: 27px 0 40px; }
.explore summary { font-size: 1.2rem; font-weight: 650; }
#type-preview { scroll-margin-top: 24px; }
.preview-card { background: var(--white); padding: 15px; max-width: 820px; color: var(--ink); }
.preview-card p { font-size: .97rem; }
.preview-card h4 { margin-bottom: 8px; }
.preview-card ul { padding-inline-start: 22px; }
.site-footer { display: flex; flex-wrap: wrap; align-items: center; gap: 12px; padding-block: 10px 30px; font-size: .83rem; color: var(--muted); }
.site-footer > div { display: flex; gap: 24px; }
.site-footer .text-button { font-size: .82rem; }
.site-footer section { flex-basis: 100%; max-width: 850px; font-size: .97rem; margin-top: 20px; }
.site-footer section h2 { font-size: 1.6rem; }
.site-footer li { margin-block: 8px; }
.storage-status { background: var(--notice-bg); padding: 14px 19px; border-radius: 16px; font-size: .91rem; }
.toast { position: fixed; bottom: 24px; inset-inline: 20px; max-width: 500px; margin: auto; background: var(--accent-hover); color: var(--on-accent); padding: 14px 22px; border-radius: 20px; z-index: 10; text-align: center; box-shadow: 0 6px 22px #526b9130; font-size: .93rem; }
dialog { border: 1px solid var(--line); border-radius: 28px; padding: 30px; background: var(--paper); color: var(--ink); max-width: 540px; width: calc(100% - 32px); box-shadow: 0 25px 80px #3b414e30; }
dialog h2 { font-size: 1.8rem; }
dialog::backdrop { background: #41495c80; backdrop-filter: blur(4px); }
.sr-only { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0,0,0,0); white-space: nowrap; }
.skip-link { position: fixed; top: -100px; right: 20px; padding: 12px; background: var(--white); z-index: 99; }
.skip-link:focus { top: 15px; }
@keyframes arrive { from { opacity: 0; transform: translateY(5px); } to { opacity: 1; transform: translateY(0); } }
@media (min-width: 1450px) { .hero { padding-block: 62px 65px; } }
@media (max-width: 900px) {
  .shell { padding-inline: 28px; }
  .hero { gap: 35px; padding-block: 35px 40px; }
  .hero h1 { font-size: 3.8rem; }
  .type-sheet { padding: 17px 18px 24px; border-width: 5px; }
  .sheet-number { font-size: 8rem; }
  .sheet-axes > div { font-size: .8rem; padding: 9px 12px; gap: 4px; }
  .sheet-axes bdi { font-size: .75rem; }
  .result-layout { grid-template-columns: 1fr; gap: 20px; }
  .type-chips, .type-picker { grid-template-columns: repeat(2, minmax(0, 1fr)); }
  .profile-card { padding: 25px; }
  .axis-panel { padding: 24px 20px; }
  .axis-title { flex-wrap: wrap; gap: 3px 10px; }
}
@media (max-width: 620px) {
  .header-actions { gap: 9px; }
  .brand { flex-shrink: 0; }
  .shell { padding-inline: 20px; }
  .site-header { min-height: 88px; }
  .brand { font-size: 1.08rem; gap: 9px; }
  .brand-mark { width: 44px; height: 44px; font-size: 1.3rem; border-radius: 17px; }
  .back-link { font-size: .78rem; padding-inline: 4px; }
  .hero { grid-template-columns: 1fr; padding-block: 24px 34px; gap: 35px; }
  .hero h1 { font-size: clamp(2.9rem, 12vw, 3.8rem); margin-bottom: 19px; line-height: 1.23; }
  .lead { font-size: 1rem; line-height: 1.95; }
  .hero .lead { margin-bottom: 23px; }
  .hero-copy > .button { width: auto; }
  .type-sheet { transform: rotate(-2deg); padding: 19px 18px 20px; border-radius: 50px 50px 30px 30px; display: grid; grid-template-columns: .8fr 1.7fr; gap: 12px; margin-inline: 5px; border-width: 4px; box-shadow: var(--sheet-shadow); }
  .sheet-number { font-size: 4.8rem; line-height: 1; align-self: center; }
  .sheet-axes { gap: 7px; }
  .sheet-axes > div { font-size: .75rem; padding: 7px 10px; gap: 3px; border-radius: 15px; }
  .sheet-axes bdi { font-size: .62rem; letter-spacing: 0; }
  .intro-details { grid-template-columns: 1fr; gap: 11px; margin-block: 12px 22px; }
  details { padding: 19px 17px; border-radius: 21px; }
  summary { font-size: .92rem; padding-inline-start: 3px; }
  .quiz-wrap { margin-top: 16px; }
  .quiz-top { gap: 9px; margin-bottom: 10px; }
  .quiz-top .eyebrow, .quiz-top .text-button { font-size: .75rem; }
  .progress-heading { font-size: .77rem; }
  .question-card { padding: 25px 15px; border-radius: 25px; margin-top: 23px; }
  .question-card h2 { font-size: 1.3rem; min-height: 0; line-height: 1.6; margin-bottom: 22px; }
  .situation-options { gap: 10px; margin-bottom: 23px; }
  .situation { padding: 14px 12px 16px; border-radius: 17px; }
  .situation p { font-size: 1rem; line-height: 1.9; }
  .situation > span { width: 29px; height: 29px; border-radius: 10px; font-size: .95rem; margin-bottom: 11px; }
  .situation-options { grid-template-columns: 1fr; }
  .situation { display: grid; grid-template-columns: 29px 1fr; gap: 12px; align-items: start; }
  .situation > span { margin: 0; }
  legend { font-size: .9375rem; }
  .answer-options { grid-template-columns: 1fr; gap: 8px; }
  .answer-choice > span { flex-direction: row; justify-content: flex-start; font-size: 1.0625rem; min-height: 49px; padding: 11px 16px; border-radius: 13px; gap: 13px; text-align: start; }
  .answer-choice i { width: 17px; height: 17px; }
  .answer-choice:nth-child(1) i, .answer-choice:nth-child(5) i { width: 21px; height: 21px; }
  .quiz-nav .button { padding-inline: 18px; min-height: 48px; font-size: 1.125rem; }
  .quiz-nav { gap: 12px; }
  .quiz-bottom .text-button { font-size: .8rem; }
  .reading-width { margin-block: 28px; }
  .result-intro { margin-top: 25px; }
  .type-chip { padding: 12px; }
  .type-chip-codes { flex-wrap: wrap; gap: 4px 8px; }
  .result-layout { grid-template-columns: 1fr; gap: 22px; }
  .profile-card { padding: 24px 20px; border-radius: 25px; }
  .profile-top { padding: 17px; border-radius: 18px; }
  .axis-panel { padding: 25px 20px; border-radius: 25px; }
  .result-actions { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
  .result-actions .primary { grid-column: 1 / -1; justify-self: start; }
  .result-actions .button { font-size: 1.0625rem; padding-inline: 16px; }
  .result-actions .text-button { font-size: .81rem; }
  .site-footer { display: block; padding-bottom: 20px; }
  .site-footer > div { margin-top: 8px; justify-content: space-between; gap: 8px; flex-wrap: wrap; }
  .site-footer .text-button { font-size: .72rem; }
  .notice { font-size: .9rem; padding: 17px; }
  .profile-character { width: 108px; }
  .profile-top { gap: 8px; padding: 12px; }
  .profile-identity .profile-name { font-size: 1.35rem; }
  .profile-identity p { font-size: .85rem; }
  .type-code { font-size: 2.2rem; }
  .profile-name { font-size: 1.6rem; }
  .axis-title { font-size: .9rem; }
  .axis-title span { font-size: .76rem; }
  .axis-labels { font-size: .86rem; }
}
@container preferences (max-width: 350px) {
  .axis-labels { grid-template-columns: 1fr; gap: 6px; }
  .axis-pole { padding: 9px 12px; }
}
@media (max-width: 360px) {
  .shell { padding-inline: 15px; }
  .hero h1 { font-size: 2.9rem; }
  .type-sheet { padding-inline: 12px; gap: 8px; }
  .sheet-number { font-size: 4rem; }
  .sheet-axes > div { font-size: .68rem; padding-inline: 8px; }
  .question-card { padding-inline: 12px; }
  .answer-options { gap: 4px; }
  .answer-choice > span { font-size: 1.0625rem; }
  .quiz-top .eyebrow, .quiz-top .text-button { font-size: .7rem; }
}
@media (prefers-reduced-motion: reduce) { *, *:before, *:after { animation: none !important; transition: none !important; scroll-behavior: auto !important; } }
@media print {
  :root, :root[data-theme="dark"] { color-scheme: light; --paper: #fff; --white: #fff; --ink: #303640; --muted: #525b68; --accent: #526b91; --on-accent: #fff; --clay: #815340; --blue-soft: #eef2f7; --peach-soft: #f7eee7; --line: #ccc; --surface-warm: #faf7f2; --surface-cool: #f4f6f8; --notice-bg: #faf5ed; --notice-line: #ddd; --track: #dce1e8; }
  body { background: white; color: #303640; font-size: 11pt; }
  #results, .type-profile { --type-accent: var(--type-light-accent, #526b91) !important; --type-soft: var(--type-light-soft, #eef2f7) !important; }
  .site-header, .site-footer, .result-actions, .explore, .toast, .storage-status, .skip-link, .screen:not(#results) { display: none !important; }
  .shell { max-width: none; padding: 0; }
  .result-layout { display: block; }
  .profile-card { background: white !important; color: #303640; border: 1px solid #aaa; box-shadow: none; }
  .profile-card p, .profile-card h4 { color: #303640; }
  .axis-panel { margin-top: 20px; break-inside: avoid; }
  .axis-bar { print-color-adjust: exact; -webkit-print-color-adjust: exact; }
  .nearby { break-inside: avoid; }
  .type-chips button { color: #303640; background: white; }
  .result-intro { margin-top: 0; }
  #results[hidden] { display: none !important; }
  dialog { display: none; }
}

/* Clear question choices in dark mode and a separate restart action. */
#fresh { display: block; width: fit-content; margin-top: 8px; }
@media screen {
  :root[data-theme="dark"] .question-card legend { color: var(--ink); font-size: 1.125rem; font-weight: 650; line-height: 1.5; }
  :root[data-theme="dark"] .situation { background: #303f53; border: 1px solid #52667e; }
  :root[data-theme="dark"] .situation p { color: #f5f7fb; font-size: 1.125rem; font-weight: 550; line-height: 1.7; }
  :root[data-theme="dark"] .situation > span { background: #3c5270; color: #f3f7ff; font-weight: 700; }
}

#reset-dialog .action-row { justify-content: flex-end; }
</style>
<!-- catalog metadata:start -->
<title>מבחן 16 הטיפוסים | ארגז הכלים של NH Local</title>
    <meta name="description" content="שאלון עצמאי בעברית בהשראת MBTI, עם 56 שאלות, שמירת התקדמות ותוצאה מפורטת. פועל גם ללא חיבור לרשת.">
    <link rel="canonical" href="https://tools.ze-kal.top/tools/the_16_types.html">
    <meta property="og:type" content="website">
    <meta property="og:locale" content="he_IL">
    <meta property="og:site_name" content="ארגז הכלים של NH Local">
    <meta property="og:title" content="מבחן 16 הטיפוסים | ארגז הכלים של NH Local">
    <meta property="og:description" content="שאלון עצמאי בעברית בהשראת MBTI, עם 56 שאלות, שמירת התקדמות ותוצאה מפורטת. פועל גם ללא חיבור לרשת.">
    <meta property="og:url" content="https://tools.ze-kal.top/tools/the_16_types.html">
    <meta property="og:image" content="https://tools.ze-kal.top/assets/social-card.png">
    <meta property="og:image:width" content="1200"><meta property="og:image:height" content="630">
    <meta property="og:image:alt" content="ארגז הכלים של NH Local: סקילים, כלי דפדפן, סקריפטים ותוספי כרום">
    <meta name="twitter:card" content="summary_large_image">
    <script type="application/ld+json">{"@context": "https://schema.org", "@graph": [{"@type": "WebSite", "@id": "https://tools.ze-kal.top/#website", "url": "https://tools.ze-kal.top/", "name": "ארגז הכלים של NH Local", "inLanguage": "he"}, {"@type": "WebPage", "@id": "https://tools.ze-kal.top/tools/the_16_types.html", "url": "https://tools.ze-kal.top/tools/the_16_types.html", "name": "מבחן 16 הטיפוסים | ארגז הכלים של NH Local", "description": "שאלון עצמאי בעברית בהשראת MBTI, עם 56 שאלות, שמירת התקדמות ותוצאה מפורטת. פועל גם ללא חיבור לרשת.", "inLanguage": "he", "isPartOf": {"@id": "https://tools.ze-kal.top/#website"}}]}</script>
<!-- catalog metadata:end -->
</head>
<body>
<a class="skip-link" href="#main">דילוג לתוכן</a>
<header class="site-header shell">
  <a class="brand" href="the_16_types.html" aria-label="16 הטיפוסים, דף הפתיחה"><span class="brand-mark" aria-hidden="true">16</span><span>הטיפוסים</span></a>
  <div class="header-actions">
    <a class="back-link" href="../index.html">לארגז הכלים <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M7 17 17 7M7 7h10v10"/></svg></a>
    <button id="theme-toggle" class="theme-toggle" type="button" aria-label="מצב אפל" aria-pressed="false" title="מעבר למצב אפל">
      <svg class="icon theme-moon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M20.5 13A8.5 8.5 0 0 1 11 3.5 8.5 8.5 0 1 0 20.5 13Z"/></svg>
      <svg class="icon theme-sun" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><circle cx="12" cy="12" r="4"/><path d="M12 2v2m0 16v2M2 12h2m16 0h2M5 5l1.5 1.5m11 11L19 19M5 19l1.5-1.5m11-11L19 5"/></svg>
    </button>
  </div>
</header>
<main id="main" class="shell" tabindex="-1">
  <section id="welcome" class="screen">
    <div class="hero">
      <div class="hero-copy">
        <h1>מה בדרך כלל<br><em>טבעי לך?</em></h1>
        <p class="lead">לחשוב בקול או לעבד בשקט? לתכנן מראש או להחליט בדרך?<br>56 שאלות על ההעדפות שלך ביומיום, ובסופן פרופיל לפי מודל 16 הטיפוסים.</p>
        <button id="start" class="button primary">להתחלת השאלון <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M19 12H5m7-7-7 7 7 7"/></svg></button>
        <button id="resume" class="button primary" hidden><span>להמשיך מאיפה שעצרתי</span> <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M19 12H5m7-7-7 7 7 7"/></svg></button>
        <button id="fresh" class="text-button" hidden>להתחיל מחדש ולמחוק את ההתקדמות</button>
      </div>
      <aside class="type-sheet" aria-label="ארבעת צירי השאלון">
        <div class="sheet-number" aria-hidden="true">16</div>
        <div class="sheet-axes"><div><span>מוחצן</span><bdi>E / I</bdi><span>מופנם</span></div><div><span>קונקרטי</span><bdi>S / N</bdi><span>עיוני</span></div><div><span>שכלתני</span><bdi>T / F</bdi><span>רגשי</span></div><div><span>גבולני</span><bdi>J / P</bdi><span>פתוח</span></div></div>
      </aside>
    </div>
    <div class="intro-details">
      <details><summary>רגע לפני: איך כדאי לענות?</summary><p>כדאי לחשוב על ההעדפות הרגילות שלך בחודשים האחרונים, כשיש לך חופש לבחור, ולא רק על יום עמוס במיוחד או על תפקיד בעבודה. בכל מצב יש שתי אפשרויות טובות. בוחרים למה נוטים יותר, ובאיזו מידה. כששתיהן מתאימות באותה מידה, אפשר לבחור באמצע.</p><p>אפשר לחזור ולשנות כל תשובה. ההתקדמות נשמרת במכשיר הזה, כל עוד הדפדפן מאפשר זאת. אין צורך לענות מהר.</p></details>
      <details><summary>מה זה MBTI, ומה המבחן הזה מציע?</summary><p>מודל 16 הטיפוסים מחבר ארבעה זוגות של העדפות: מוחצן או מופנם, קונקרטי או עיוני, שכלתני או רגשי, גבולני או פתוח. הצירוף של ארבע הבחירות יוצר אחד מ-16 טיפוסים אפשריים.</p><p>המינוחים בעברית וכינויי הטיפוסים כאן תואמים לטבלה שסופקה לפרויקט. <b>גבולני</b> הוא הכינוי כאן להעדפה למסגרת ולסגירת קצוות (J), ללא משמעות קלינית. <b>רגשי</b> מתאר מתן משקל לערכים ולאנשים, ולא חוסר היגיון. <b>עיוני</b> מתייחס לדפוסים ולאפשרויות, ולא לרמת השכלה.</p><p>זהו שאלון עצמאי בהשראת ארבעת צירי MBTI, ולא מבחן MBTI רשמי או שאלון של 16Personalities. הוא נועד להיכרות עצמית, אינו אבחון ולא עבר תיקוף פסיכומטרי. טיפוס אינו מדד ליכולת או לערך אישי.</p></details>
    </div>
  </section>
  <section id="quiz" class="screen quiz-wrap" hidden aria-labelledby="question-heading">
    <div class="quiz-top"><span id="chapter-label" class="eyebrow"></span><button id="pause" class="text-button">שמירה ויציאה</button></div>
    <div class="progress-heading"><span id="question-counter"></span><span id="progress-text"></span></div>
    <progress id="progress" max="56" value="0" aria-label="שאלות שנענו"></progress>
    <form id="quiz-form" novalidate>
      <div class="question-card">
        <h2 id="question-heading" tabindex="-1"></h2>
        <div class="situation-options"><div class="situation option-a"><span aria-hidden="true">א'</span><p id="option-a"></p></div><div class="situation option-b"><span aria-hidden="true">ב'</span><p id="option-b"></p></div></div>
        <fieldset><legend>מה מרגיש לך יותר טבעי?</legend><div id="answer-options" class="answer-options"></div></fieldset>
        <p id="answer-error" class="error" role="alert" hidden>צריך לבחור תשובה כדי להמשיך. אפשר לבחור גם באמצע</p>
      </div>
      <div class="quiz-nav"><button id="previous" type="button" class="button secondary"><svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M5 12h14m-7-7 7 7-7 7"/></svg> <span>הקודם</span></button><button id="next" type="submit" class="button primary"><span>הבא</span> <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M19 12H5m7-7-7 7 7 7"/></svg></button></div>
    </form>
    <div class="quiz-bottom"><button id="review-link" class="text-button">כל התשובות שלי</button></div>
  </section>
  <section id="review" class="screen reading-width" hidden aria-labelledby="review-heading">
    <span class="eyebrow">בדיקה ועריכה</span><h2 id="review-heading" tabindex="-1">התשובות שלך</h2><p>לחיצה על שאלה מאפשרת לעדכן את התשובה. אין צורך לענות מחדש על הכול.</p><p id="review-count"></p><div id="review-list"></div><div class="action-row"><button id="review-finish" class="button primary"><span>לתוצאות</span> <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M19 12H5m7-7-7 7 7 7"/></svg></button><button id="review-back" class="button secondary">חזרה לשאלון</button></div>
  </section>
  <section id="results" class="screen" hidden aria-labelledby="result-heading">
    <div class="result-intro"><h2 id="result-heading" tabindex="-1"></h2><p id="result-subtitle" class="lead"></p></div>
    <div id="result-notice" class="notice" hidden></div>
    <div class="result-layout"><div id="profile-card" class="profile-card"></div><div class="axis-panel"><h3>ההעדפות שלך בארבעת התחומים</h3><div id="axis-results"></div><p class="axis-note">האחוזים מתארים נטייה בתשובות, ולא סבירות לטיפוס</p></div></div>
    <div id="nearby" class="nearby" hidden><h3>טיפוסים נוספים להשוואה</h3><p id="nearby-explanation"></p><div id="nearby-types" class="type-chips"></div></div>
    <div class="result-actions action-row"><button id="download" class="button primary"><span>לשמור את התוצאה</span> <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M12 3v12m-5-5 5 5 5-5M5 16v5h14v-5"/></svg></button><button id="copy" class="button secondary">העתקת סיכום</button><button id="print" class="button secondary">הדפסה</button><button id="edit" class="text-button">לעבור על התשובות</button><button id="restart" class="text-button">להתחיל מחדש</button></div>
    <p class="micro result-disclaimer">שאלון עצמאי להיכרות עצמית, ללא תיקוף פסיכומטרי. התוצאה אינה אבחון</p>
    <details class="explore"><summary>כל 16 הטיפוסים</summary><p>אפשר לעיין בכל התיאורים. הבחירה כאן אינה משנה את התוצאה שלך.</p><div id="type-picker" class="type-picker" role="group" aria-label="בחירת טיפוס לעיון"></div><div id="type-preview" tabindex="-1"></div></details>
  </section>
  <p id="storage-status" class="storage-status" role="status" hidden></p>
  <noscript><div class="notice">כדי למלא את השאלון נדרש להפעיל JavaScript בדפדפן. אין צורך בחיבור לרשת</div></noscript>
</main>
<footer class="shell site-footer"><div><button id="about-toggle" class="text-button" aria-expanded="false" aria-controls="method">מקורות ושיטת החישוב</button><button id="erase" class="text-button">מחיקת התשובות מהמכשיר</button></div>
<section id="method" hidden><h2>על מה מבוסס השאלון?</h2><p>56 השאלות נכתבו במיוחד לשאלון זה. בכל ציר 14 שאלות במשקל שווה, במחציתן כל צד מופיע ראשון. השאלות עוסקות באנרגיה ועיבוד, קליטת מידע, שיקולי החלטה וגישה למסגרת. הן אינן העתק של שאלון מסחרי.</p><p>כל תשובה מקבלת ערך בין 2- ל-2 בהתאם לכיוון ולמידת ההעדפה. סכום של 14 התשובות בציר מומר לסולם 0 עד 100, עם אמצע ב-50. בשוויון מוצג X ולא נבחר צד שרירותי. כשציון הצד המוביל אינו עולה על 62.5, מוצעים גם צירופים קרובים להשוואה. זהו סף תצוגה שנבחר לשאלון, לא גבול מחקרי או רווח סמך.</p><p>המודל של 16Personalities מוסיף ממד חמישי משלו; הוא אינו נמדד כאן. תיאורי הטיפוסים הם הצעות להתבוננות שנכתבו לשאלון, ולא ניבוי של הצלחה בעבודה או בקשרים. סימולציות עם סוכני שפה שימשו לאיתור בעיות ניסוח וניקוד, ואינן תיקוף על בני אדם.</p><ul><li><a href="https://www.myersbriggs.org/my-mbti-personality-type/the-mbti-preferences/" target="_blank" rel="noopener noreferrer">Myers &amp; Briggs Foundation: ארבעת זוגות ההעדפות</a></li><li><a href="https://www.myersbriggs.org/my-mbti-personality-type/my-mbti-results/" target="_blank" rel="noopener noreferrer">Myers &amp; Briggs Foundation: פרשנות התוצאה והתאמה אישית</a></li><li><a href="https://www.16personalities.com/articles/our-theory" target="_blank" rel="noopener noreferrer">16Personalities: ההבדל בין המודל שלהם ל-MBTI</a></li><li><a href="https://pubmed.ncbi.nlm.nih.gov/2709300/" target="_blank" rel="noopener noreferrer">McCrae &amp; Costa (1989): בחינה ביקורתית של החלוקה לטיפוסים</a></li><li><a href="https://pubmed.ncbi.nlm.nih.gov/16367525/" target="_blank" rel="noopener noreferrer">Tzeng ואחרים (1984): תוקף פריטים וסוגיות בבניית שאלות</a></li></ul></section></footer>
<div id="announcement" class="sr-only" aria-live="polite"></div><div id="toast" class="toast" role="status" hidden></div>
<dialog id="reset-dialog"><h2 id="reset-title">למחוק את התשובות?</h2><p>התשובות והתוצאה השמורות בדפדפן הזה יימחקו. אפשר לבטל ולהמשיך מהמצב הקיים.</p><div class="action-row"><button id="cancel-reset" class="button secondary" autofocus>ביטול</button><button id="confirm-reset" class="button primary">למחוק ולהתחיל מחדש</button></div></dialog>
<script>const MBTI_DATA = {"version":"1.1.0","chapters":["ברגעים הקטנים","אנשים סביבנו","משהו חדש מתחיל","בין רעיון למעשה","כשצריך לבחור","יוצאים מהשגרה","התמונה השלמה"],"questions":[{"id":1,"axis":"EI","aPole":"I","facet":"recharge","text":"התפנה לך ערב אחרי יום עמוס. מה בדרך כלל ממלא אותך מחדש?","a":"זמן שקט לעצמי, בלי צורך לדבר","b":"מפגש או שיחה עם אנשים שנעים לי איתם","sourceId":1},{"id":2,"axis":"SN","aPole":"S","facet":"learning","text":"התחלת ללמוד משחק חדש. איזו פתיחה נוחה לך יותר?","a":"הדגמה של תור אחד, צעד אחר צעד","b":"הסבר של הרעיון שמאחורי המשחק והאפשרויות שבו","sourceId":2},{"id":3,"axis":"TF","aPole":"F","facet":"decisions","text":"בוחרים מקום לבילוי עם חברים. מה נוטה להכריע אצלך כשאין אפשרות שמתאימה להכול?","a":"הרצונות האישיים של מי שיוצאים איתי","b":"השוואה של המחיר, המרחק ומה שיש בכל מקום","sourceId":3},{"id":4,"axis":"JP","aPole":"J","facet":"planning","text":"לקראת יום חופשי, מה מרגיש לך נעים יותר?","a":"להחליט מראש מה עושים ומתי","b":"להשאיר את היום פתוח ולבחור תוך כדי","sourceId":4},{"id":5,"axis":"SN","aPole":"N","facet":"attention","text":"אחרי ביקור במקום מעניין, על מה המחשבות שלך נוטות להתעכב?","a":"על הרעיונות והקשרים שהמקום עורר בי","b":"על המראות והפרטים המסוימים שראיתי","sourceId":5},{"id":6,"axis":"EI","aPole":"E","facet":"processing","text":"רעיון מתחיל להתגבש לך בראש. מה בדרך כלל עוזר להבהיר אותו?","a":"לספר עליו למישהו ולחשוב בקול תוך כדי","b":"לעבד אותו בשקט לפני שמשתפים","sourceId":6},{"id":7,"axis":"JP","aPole":"P","facet":"closure","text":"מצאת אפשרות טובה לבילוי, ואפשר להזמין גם מחר. מה טבעי לך?","a":"להשאיר עוד קצת מקום לאפשרויות נוספות","b":"לסגור את הבחירה ולהתפנות לדברים אחרים","sourceId":7},{"id":8,"axis":"TF","aPole":"T","facet":"fairness","text":"צריך לחלק תורנויות בבית. מה נראה לך הוגן יותר?","a":"לקבוע כלל אחיד שלפיו כולם מתחלקים בתורנויות","b":"להתאים את החלוקה למצב האישי של כל אחד","sourceId":8},{"id":9,"axis":"EI","aPole":"E","facet":"breadth","text":"במפגש נעים שבו אפשר לנוע בין שיחות, למה יש לך יותר חשק?","a":"לפגוש כמה אנשים ולהצטרף למעגלי שיחה שונים","b":"להישאר לשיחה ממושכת עם אדם אחד או שניים","sourceId":9},{"id":10,"axis":"TF","aPole":"T","facet":"feedback","text":"חבר מבקש את דעתך על סיפור שכתב. במה יתמקד המשוב שלך קודם?","a":"עד כמה העלילה מובנת והאירועים מתחברים זה לזה","b":"איך הסיפור השפיע עליי ומה הרגשתי כלפי הדמויות","sourceId":10},{"id":11,"axis":"SN","aPole":"N","facet":"patterns","text":"מישהו מספר על כמה אירועים שקרו לו. למה תשומת הלב שלך נמשכת?","a":"לחוט המקשר ולמשמעות שמסתתרת ביניהם","b":"למה שקרה בכל אירוע ולפרטים שמבדילים ביניהם","sourceId":11},{"id":12,"axis":"JP","aPole":"P","facet":"structure","text":"קבוצה קובעת איך להעביר מפגש חברתי. איזו מסגרת נוחה לך?","a":"כיוון כללי, עם מקום לשנות לפי האווירה","b":"תוכנית מוסכמת, כך שברור מה עומד לקרות","sourceId":12},{"id":13,"axis":"TF","aPole":"F","facet":"conflict","text":"שני חברים חלוקים בדעתם ומבקשים לשמוע את דעתך. מאיפה טבעי לך להתחיל?","a":"ממה שחשוב לכל אחד מהם ומאיך ההחלטה תשפיע עליו","b":"מהטענות של כל אחד מהם ומאיזו מהן מבוססת יותר","sourceId":13},{"id":14,"axis":"JP","aPole":"J","facet":"planning","text":"מתכננים ארוחה משותפת בעוד שבוע. מה עדיף לך?","a":"לקבוע כבר עכשיו מי מביא מה","b":"להחליט קרוב למועד לפי מה שיתאים אז","sourceId":14},{"id":15,"axis":"EI","aPole":"I","facet":"processing","text":"צריך להסביר דעה בנושא מורכב, ויש אפשרות לבחור איך. מה נוח לך יותר?","a":"לנסח אותה בכתב לפני שמשוחחים עליה","b":"לפתח אותה בשיחה שבה אפשר לשאול ולהגיב","sourceId":15},{"id":16,"axis":"SN","aPole":"S","facet":"learning","text":"כשמסבירים לך רעיון מורכב, מה הכי עוזר לך לעקוב?","a":"דוגמה ממשית שממחישה בדיוק למה הכוונה","b":"דימוי או עיקרון רחב שמחבר את החלקים","sourceId":16},{"id":17,"axis":"JP","aPole":"J","facet":"sequence","text":"החלטת ללמוד משהו חדש בזמן הפנוי. איך נוח לך להתקדם?","a":"לחלק את הלמידה לשלבים וללכת לפי הסדר","b":"לבחור בכל פעם במה להעמיק לפי מה שמעניין אותי","sourceId":17},{"id":18,"axis":"SN","aPole":"S","facet":"experience","text":"קראת על דרך חיים שונה מאוד משלך. מה היית רוצה להכיר יותר מקרוב?","a":"איך נראים חיי היומיום: האוכל, הבתים והמנהגים","b":"אילו רעיונות ותפיסות עולם עומדים מאחורי דרך החיים","sourceId":18},{"id":19,"axis":"EI","aPole":"I","facet":"initiation","text":"נכנסת לקבוצה חדשה שמקבלת אותך בחום. מה מרגיש טבעי יותר?","a":"להכיר בהדרגה דרך כמה שיחות אישיות","b":"להיכנס מהר לשיחה הקבוצתית ולהכיר תוך כדי","sourceId":19},{"id":20,"axis":"TF","aPole":"F","facet":"values","text":"שתי אפשרויות מתאימות לך באותה מידה מבחינה מעשית. מה יעזור לך לבחור?","a":"לחשוב איזו מהן קרובה יותר למה שחשוב לי אישית","b":"להשוות את הנימוקים בעד ונגד כל אחת","sourceId":20},{"id":21,"axis":"SN","aPole":"N","facet":"possibilities","text":"קיבלת כלי חדש שאפשר להשתמש בו בדרכים שונות. מה מסקרן אותך קודם?","a":"אילו שימושים חדשים ולא צפויים אפשר להמציא לו","b":"מה הוא יודע לעשות בפועל ואיך משתמשים בו היטב","sourceId":21},{"id":22,"axis":"JP","aPole":"P","facet":"adaptability","text":"באמצע עיסוק בשעות הפנאי עולה רעיון למשהו אחר, ויש זמן לשניהם. מה טבעי לך?","a":"לעצור ולנסות את הרעיון החדש","b":"לסיים את מה שהתחלתי ואז לנסות את הרעיון החדש","sourceId":22},{"id":23,"axis":"TF","aPole":"T","facet":"decisions","text":"קיבלת החלטה שמשפיעה גם על אנשים קרובים. מה נותן לך יותר ביטחון בה?","a":"שיש לי נימוקים ברורים לבחירה שעשיתי","b":"שהבחירה מתאימה למה שחשוב לי ולאנשים הקרובים אליי","sourceId":23},{"id":24,"axis":"EI","aPole":"E","facet":"initiation","text":"במפגש הושיבו אותך ליד אדם שנראה נעים, ועדיין לא דיברתם. מה טבעי לך יותר?","a":"לפתוח בשיחה ולהתחיל להכיר","b":"לתת לשיחה להיפתח בהדרגה, בלי ליזום מיד","sourceId":24},{"id":25,"axis":"TF","aPole":"T","facet":"perspective","text":"כדי לפתור מחלוקת מתמשכת, מה יעזור לך יותר בהתחלה?","a":"להפריד בין הטענות ולבדוק מה מבוסס בכל אחת","b":"להבין מה חשוב לכל צד ומה עומד מאחורי עמדתו","sourceId":25},{"id":26,"axis":"EI","aPole":"E","facet":"recharge","text":"אחרי כמה שעות טובות של עיסוק לבד, מה לרוב מתחשק לך?","a":"לצאת קצת החוצה ולפגוש או לדבר עם אנשים","b":"להמשיך עוד זמן במרחב האישי הנעים שלי","sourceId":26},{"id":27,"axis":"JP","aPole":"P","facet":"sequence","text":"יש כמה דברים לעשות בבית, ואין סדר מחייב. איך נוח לך לגשת אליהם?","a":"לעבור מדבר לדבר לפי מה שמתחשק לי באותו רגע","b":"לבחור סדר ולסיים דבר אחד לפני שמתחילים את הבא","sourceId":27},{"id":28,"axis":"SN","aPole":"S","facet":"attention","text":"כשצריך לתאר חדר שהיה לך נעים בו, במה יתמקד התיאור שלך?","a":"באור, בצבעים, ברהיטים ובמה שהיה בחדר","b":"באווירה, באסוציאציות ובמה שהחדר הזכיר לי","sourceId":31},{"id":29,"axis":"EI","aPole":"I","facet":"privacy","text":"קרה לך משהו אישי ומשמח. מה בדרך כלל מתאים לך?","a":"לשמור אותו לעצמי בהתחלה ולשתף רק מעטים","b":"לשתף כמה אנשים קרובים די מהר","sourceId":29},{"id":30,"axis":"TF","aPole":"F","facet":"appreciation","text":"מישהו מודה לך על עזרה. איזה חלק בדבריו משמעותי לך יותר?","a":"שהרגיש שראיתי אותו והבנתי מה הוא צריך","b":"שהעזרה שלי פתרה את הבעיה בצורה טובה","sourceId":30},{"id":31,"axis":"SN","aPole":"S","facet":"interpretation","text":"בסרט מופיע רגע שאפשר להבין בכמה דרכים. מה מעניין אותך יותר?","a":"מה קרה בפועל ומה הדמויות אמרו ועשו","b":"איזו משמעות נוספת או סמל עשויים להיות ברגע הזה","sourceId":33},{"id":32,"axis":"JP","aPole":"J","facet":"preparation","text":"עומדים לצאת לכמה שעות מהבית. מה נוח לך יותר?","a":"להכין מראש את כל מה שצריך לקחת","b":"לאסוף את הדברים כשמגיע הזמן לצאת","sourceId":32},{"id":33,"axis":"EI","aPole":"I","facet":"stimulation","text":"אפשר לבלות שעה נעימה בבית קפה תוסס או בפינה שקטה. מה מושך אותך יותר?","a":"הפינה השקטה, שבה פחות קורה סביבי","b":"בית הקפה התוסס, שבו מרגישים את האנשים מסביב","sourceId":36},{"id":34,"axis":"SN","aPole":"N","facet":"possibilities","text":"כשעולה רעיון לשיפור מקום מוכר, מה מעסיק אותך קודם?","a":"איך המקום יכול להיראות בעתיד אם נחשוב אחרת","b":"מה פועל בו עכשיו ואיזה שינוי ממשי יועיל","sourceId":38},{"id":35,"axis":"TF","aPole":"F","facet":"support","text":"חבר מספר על יום קשה. מה התגובה הראשונה שטבעית לך?","a":"להקשיב ולתת מקום למה שהוא מרגיש","b":"לברר מה קרה ולחשוב איתו מה עשוי לעזור","sourceId":35},{"id":36,"axis":"JP","aPole":"J","facet":"pace","text":"יש לך שבוע להכין משהו למפגש חברים. איזה קצב מתאים לך יותר?","a":"להתחיל מוקדם ולהתקדם קצת בכל יום","b":"לרכז את ההכנה סמוך למפגש, כשכבר נכנסים לאווירה","sourceId":34},{"id":37,"axis":"SN","aPole":"N","facet":"communication","text":"חבר מבקש לשמוע על חוויה שלך. באיזו דרך טבעי לך לספר?","a":"לספר לו מה החוויה גרמה לי לחשוב ומה היא מזכירה לי","b":"לספר לו מה קרה, לפי הסדר, עם פרטים ותיאורים","sourceId":44},{"id":38,"axis":"EI","aPole":"E","facet":"expression","text":"בחבורה קרובה מבקשים ממך לספר סיפור שכולם יקשיבו לו. איך זה מרגיש לך?","a":"נעים לי להיות במרכז השיחה ולשתף את כולם","b":"נעים לי יותר לספר לאדם אחד מאשר לכל החבורה","sourceId":39},{"id":39,"axis":"JP","aPole":"P","facet":"routine","text":"קבעת לעשות משהו בשעות הפנאי, ובאותו יום מתחשק לך משהו אחר. מה טבעי לך?","a":"לשנות את התוכנית לפי מה שמתאים לי עכשיו","b":"להישאר עם התוכנית שבחרתי מראש","sourceId":37},{"id":40,"axis":"TF","aPole":"T","facet":"support","text":"מישהו מציע לך לשנות הרגל. איזה הסבר עשוי לשכנע אותך יותר?","a":"הסבר שמראה איך השינוי יעבוד ומה התועלת שלו","b":"הסבר שמחבר את השינוי לדברים שחשובים לי בחיים","sourceId":40},{"id":41,"axis":"EI","aPole":"E","facet":"stimulation","text":"יום פנוי עבר כמעט בלי קשר עם אחרים. מה בדרך כלל חסר לך בסופו?","a":"קצת נוכחות של אנשים והתרחשות סביבי","b":"לא בהכרח חסר לי משהו, השקט נעים לי","sourceId":43},{"id":42,"axis":"TF","aPole":"F","facet":"fairness","text":"יש כלל קבוע במפגש חברים, ומישהו מבקש לחרוג ממנו. מה השיקול הראשון שלך?","a":"למה החריגה חשובה לו ומה המשמעות שלה עבורו","b":"האם יש סיבה שאפשר להחיל גם על מקרים דומים","sourceId":45},{"id":43,"axis":"SN","aPole":"S","facet":"experience","text":"משהו קטן בבית לא פועל כרגיל. איך טבעי לך להתחיל לבדוק מה קרה?","a":"לבדוק אחד אחד את הפרטים שאפשר לראות ולנסות","b":"לחשוב על הסבר שיכול לחבר בין כל הסימנים","sourceId":46},{"id":44,"axis":"JP","aPole":"J","facet":"routine","text":"בשגרה שיש לך חופש לקבוע, מה מרגיש לך נוח יותר?","a":"לעשות דברים מסוימים בשעות קבועות","b":"לשנות את סדר היום לפי מה שמתאים בכל פעם","sourceId":47},{"id":45,"axis":"TF","aPole":"F","facet":"feedback","text":"חבר מבקש חוות דעת על בחירה שחשובה לו. איך טבעי לך לנסח הסתייגות?","a":"להסביר קודם שאני מבין מה חשוב לו, ואז לומר מה מטריד אותי","b":"לומר קודם מה הבעיה שאני רואה, ואז להסביר את הסיבה","sourceId":51},{"id":46,"axis":"JP","aPole":"J","facet":"closure","text":"סיימת משהו שיצרת להנאתך, והוא מוצלח בעיניך. מה נעים לך יותר?","a":"להחליט שהוא גמור ולעבור לדבר הבא","b":"להשאיר אותו פתוח לעוד שינויים שיעלו בהמשך","sourceId":52},{"id":47,"axis":"EI","aPole":"I","facet":"company","text":"יש לך תחביב שאפשר ליהנות ממנו לבד או יחד. מה בדרך כלל עדיף לך?","a":"לעסוק בו לבד, בקצב ובמרחב שלי","b":"לעסוק בו עם אחרים ולהחליף חוויות תוך כדי","sourceId":49},{"id":48,"axis":"SN","aPole":"N","facet":"interpretation","text":"בקריאת סיפור, מה נוטה לתפוס אותך יותר?","a":"הרעיונות, הסמלים והאפשרויות לפרשנות","b":"הפרטים החיים והתחושה של להיות בתוך ההתרחשות","sourceId":53},{"id":49,"axis":"JP","aPole":"P","facet":"preparation","text":"יוצאים למקום מוכר ולא חסר שם ציוד. איך נוח לך להתכונן?","a":"לקחת את הדברים הבסיסיים ולהחליט במקום מה עוד צריך","b":"לחשוב מראש על מה שאולי ארצה ולהכין בהתאם","sourceId":55},{"id":50,"axis":"SN","aPole":"N","facet":"application","text":"אפשר לקרוא על שימוש מעשי בתגלית או על מה שעוד עשוי להתאפשר בזכותה. מה מושך אותך יותר?","a":"לחשוב על האפשרויות העתידיות שהיא פותחת","b":"להבין איך אפשר להשתמש בה כבר היום","sourceId":59},{"id":51,"axis":"EI","aPole":"E","facet":"company","text":"בזמן עיסוק נינוח, מכר נעים מתחיל איתך שיחה לא דחופה. מה ההרגשה הראשונית שלך?","a":"נחמד לי שנוצרה הזדמנות לשיחה תוך כדי","b":"הייתי מעדיף להמשיך בעיסוק שלי בלי שיחה כרגע","sourceId":56},{"id":52,"axis":"TF","aPole":"T","facet":"conflict","text":"בני הבית לא מסכימים מה עדיף לעשות. איזה תפקיד טבעי לך לקחת בשיחה?","a":"לחדד את ההבדלים בין ההצעות כדי שיהיה קל להכריע","b":"למצוא מה משותף להצעות כדי שיהיה קל להגיע להסכמה","sourceId":54},{"id":53,"axis":"SN","aPole":"S","facet":"application","text":"בתחום שמעניין אותך, מה מושך אותך יותר?","a":"לשפר משהו קיים כך שיעבוד טוב יותר","b":"לחשוב על משהו חדש שעדיין לא ניסו","sourceId":64},{"id":54,"axis":"JP","aPole":"P","facet":"structure","text":"למשחק חברתי חדש מציעים לקבוע כללים יחד. מה מתאים לך יותר?","a":"להתחיל עם כמה כללים ולהוסיף לפי מה שיתעורר","b":"להסכים מראש על הכללים לפני שמתחילים לשחק","sourceId":58},{"id":55,"axis":"TF","aPole":"T","facet":"values","text":"שמעת הצעה שנשמעת טובה בהתחלה. מה טבעי לך לבדוק קודם?","a":"אילו חסרונות או קשיים אולי לא הביאו בחשבון","b":"מה יש בה שכדאי לתמוך בו ולעודד","sourceId":57},{"id":56,"axis":"EI","aPole":"I","facet":"privacy","text":"הצטרפת לחבורה נחמדה והאווירה פתוחה. כמה מעצמך טבעי לך לשתף בהתחלה?","a":"בעיקר דברים כלליים, ואת האישי לשמור להמשך ההיכרות","b":"גם מחשבות וחוויות אישיות, אם השיחה מזמינה זאת","sourceId":63}],"revision":"1.1.0-f21b74663d17"};
const MBTI_PROFILES = {"ISTJ":{"he":"מקשג","name":"המפקח / הלוגיסטיקן","description":"הצירוף הזה מציע העדפה לעבודה שקולה, לפרטים ממשיים ולהתקדמות בתוך מסגרת ברורה. ייתכן שנוח לך לברר מה נדרש, לבנות דרך מסודרת ולדאוג שגם הפרטים הקטנים יקבלו מענה.","strengths":["מעקב אחר פרטים והתחייבויות","תרגום ניסיון לשיטה שימושית","קבלת החלטות לפי קריטריונים עקביים"],"stretch":"כששיטה מוכרת עובדת, קל לפסול חלופה לפני שנותנים לה הזדמנות. כדאי לברר מתי הניסיון מועיל ומתי התנאים כבר השתנו.","relationships":"אכפתיות יכולה להתבטא אצלך בעשייה ובנוכחות עקבית. לפעמים כדאי לומר במילים את מה שמבחינתך כבר ברור מהמעשים.","work":"מטרה מוגדרת, אחריות ברורה וזמן להכנה עשויים לעזור לך להביא את המיטב.","experiment":"לבחור הרגל קטן ולנסות לו חלופה אחת, בלי להתחייב לאמץ אותה."},"ISFJ":{"he":"מקרג","name":"המגן","description":"כאן נפגשות תשומת לב לפרטים, התחשבות אישית וחיבה למסגרת. ייתכן שחשוב לך לזכור מה מועיל לאנשים סביבך וליצור עבורם תחושה של רציפות וביטחון, גם בלי לעמוד במרכז.","strengths":["זיכרון לפרטים אישיים שימושיים","תמיכה מעשית שמתאימה לאדם","התמדה בטיפוח קשרים ומסגרות"],"stretch":"הרצון לשמור על מה שטוב לאחרים עלול לדחוק את ההעדפות שלך. הבעת צורך אישי אינה מבטלת את ההתחשבות.","relationships":"מחוות קטנות עשויות להיות שפה טבעית עבורך. שיחה מפורשת על ציפיות יכולה לחסוך הנחות שאינן משותפות לשני הצדדים.","work":"סביבה מכבדת, משימות מוחשיות וציפיות ידועות עשויות להתאים לקצב שלך.","experiment":"לנסח בקשה אישית אחת באופן ברור, לפני שמציעים שוב עזרה."},"INFJ":{"he":"מערג","name":"הסנגור","description":"השילוב הזה נוטה לחבר התבוננות פנימית, חיפוש משמעות והתחשבות באנשים עם רצון להתקדם לכיוון ברור. ייתכן שחשוב לך להבין לא רק מה קורה, אלא גם מה עומד מאחוריו ולאן הוא מוביל.","strengths":["חיבור בין רעיונות לערכים","הקשבה למשמעויות שמאחורי הדברים","התמקדות בכיוון בעל משמעות אישית"],"stretch":"תמונה פנימית משכנעת אינה תמיד התמונה של האחר. כדאי לבדוק פרשנויות במקום להניח שהבנת בדיוק למה התכוונו.","relationships":"ייתכן שחשובות לך שיחות עומק וזמן לעיבוד. אפשר לבקש את שניהם במפורש, גם בלי לצפות שאחרים ינחשו.","work":"מרחב ריכוז, מטרה משמעותית ויכולת לתכנן את הדרך עשויים לתמוך בך.","experiment":"לבדוק פרשנות אחת באמצעות שאלה פשוטה: האם לזה התכוונת?"},"INTJ":{"he":"מעשג","name":"האדריכל","description":"התשובות בכיוון הזה מחברות חשיבה עצמאית, זיהוי דפוסים ובחינה עניינית עם רצון במבנה ובהכרעה. ייתכן שנוח לך לבנות תמונה רחבה ואז לחפש את הדרך ההגיונית שתהפוך אותה למציאות.","strengths":["בניית תמונה אסטרטגית","בחינת הנחות ומבנים","מיקוד מאמץ בכיוון ארוך טווח"],"stretch":"תוכנית בהירה בראש אינה בהכרח ברורה לאחרים. שיתוף בהנחות ובשיקולים יכול להיות חלק מהביצוע עצמו.","relationships":"עצמאות וישירות עשויות להיות חשובות לך. כדאי להשאיר מקום גם למה שאנשים מרגישים לפני שמציעים שיפור.","work":"בעיה מורכבת, חופש לחשוב ומטרות ברורות עשויים להיות שילוב נוח עבורך.","experiment":"להציג רעיון לפני שהוא מושלם ולבקש מאדם אחר לזהות הנחה חסרה."},"ISTP":{"he":"מקשפ","name":"האומן / הווירטואוז","description":"זהו שילוב של מרחב אישי, תשומת לב למה שקורה בפועל, בחינה הגיונית וגמישות. ייתכן שנוח לך להבין בעיה דרך התנסות ולבחור פתרון לפי המצב, בלי להעמיס עליו מסגרת מיותרת.","strengths":["איתור תקלות באופן ענייני","למידה דרך התנסות ישירה","התאמת פתרונות לתנאים בשטח"],"stretch":"פתרון שעובד ברגע זה אינו תמיד מסביר לאחרים מה יקרה בהמשך. מעט תיאום מראש יכול להגן על החופש שלך.","relationships":"ייתכן שנוח לך להראות אכפתיות דרך עזרה מעשית וזמן משותף. לפעמים הצד השני צריך גם לשמוע מה עובר עליך.","work":"עצמאות, בעיות מוחשיות ומרחב לשנות את דרך הפעולה עשויים להתאים לך.","experiment":"לשתף מישהו בצעד הבא שלך עוד לפני שהוא שואל."},"ISFP":{"he":"מקרפ","name":"ההרפתקן","description":"כאן נפגשים עיבוד פנימי, חוויה מוחשית, ערכים אישיים וגמישות. ייתכן שנוח לך להרגיש את הדברים מקרוב ולבחור בקצב שלך מה מתאים לך, בלי להפוך כל חוויה לתוכנית מסודרת.","strengths":["רגישות לפרטים בחוויה המיידית","נאמנות למה שחשוב לך","התחשבות אישית שאינה מחייבת במה"],"stretch":"שמירת האפשרויות פתוחות עשויה להקשות על אחרים להבין למה לצפות. אפשר לקבוע עוגן קטן בלי לוותר על גמישות.","relationships":"ייתכן שמעשים וחוויות משותפות קרובים לליבך. הבעת העדפות במילים נותנת לאחרים הזדמנות לכבד אותן.","work":"מרחב אישי, עשייה מוחשית וחופש בדרך הביצוע עשויים לעזור לך.","experiment":"לבחור התחייבות קטנה אחת לשבוע ולתת לה זמן מוגדר."},"INFP":{"he":"מערפ","name":"המתווך","description":"הצירוף הזה מחבר התבוננות פנימית, דמיון וערכים אישיים עם פתיחות לאפשרויות. ייתכן שחשוב לך למצוא דרך שנאמנה למה שיקר לך, ולראות מעבר למצב הקיים גם את מה שהוא יכול להיות.","strengths":["התבוננות מזוויות אפשריות שונות","חיבור בין רעיונות לערכים אישיים","מתן מקום לחוויה של אדם אחר"],"stretch":"כשיש הרבה אפשרויות משמעותיות, הבחירה באחת עלולה להרגיש כמו ויתור. צעד קטן אינו מחייב החלטה לכל החיים.","relationships":"ייתכן שחשובים לך כנות, עומק ומרחב להיות עצמך. שיתוף בצרכים קונקרטיים יכול לקרב יותר מרמזים.","work":"משמעות אישית, זמן לחשיבה וגמישות מסוימת בדרך עשויים לעזור לך להתמיד.","experiment":"להפוך רעיון יקר לך לפעולה שאפשר להשלים בעשרים דקות."},"INTP":{"he":"מעשפ","name":"הלוגיקאי / הפילוסוף","description":"זהו שילוב של מחשבה עצמאית, עניין בדפוסים, בחינה הגיונית ופתיחות. ייתכן שהסקרנות שלך מתעוררת כשאפשר לפרק הנחות, לבדוק הסברים ולגלות אפשרות שלא נראתה בהתחלה.","strengths":["בחינה של עקביות פנימית","יצירת הסברים וחיבורים חדשים","נכונות לעדכן רעיון כשמוצאים בו פער"],"stretch":"תמיד אפשר לחדד עוד, אבל לפעמים ערכו של רעיון מתברר רק כשמנסים אותו. כדאי להגדיר מה מספיק לניסוי ראשון.","relationships":"שיחה על רעיונות עשויה להיות דרך לחיבור. שווה לבדוק אם כרגע מבקשים ממך ניתוח, הקשבה או עזרה מעשית.","work":"שאלות מורכבות, זמן ללא הפרעות וחופש לבדוק חלופות עשויים להתאים לך.","experiment":"להגדיר שעת עצירה למחקר ולהוציא גרסה קטנה שאפשר לבחון."},"ESTP":{"he":"חקשפ","name":"היזם","description":"כאן נפגשים קשר עם הסביבה, התמקדות במציאות, שיקולים ענייניים וגמישות. ייתכן שנוח לך לפגוש מצב כפי שהוא, לנסות משהו ולתקן בהתאם למשוב שמגיע מהשטח.","strengths":["זיהוי אפשרויות מעשיות ברגע נתון","למידה מהירה דרך עשייה","שיחה ישירה שמקדמת פעולה"],"stretch":"הצעד הזמין ביותר אינו תמיד המתאים ביותר לטווח ארוך. עצירה קצרה יכולה לחשוף מחיר שלא רואים מיד.","relationships":"עשייה משותפת ושיחה חיה עשויות להיות טבעיות לך. כדאי לתת מקום גם לקצב עיבוד איטי משלך.","work":"מגע עם אנשים, משוב מיידי ומרחב לאלתור עשויים לעזור לך להתקדם.","experiment":"לפני פעולה חדשה, לרשום תוצאה אפשרית אחת להיום ואחת לעוד חודש."},"ESFP":{"he":"חקרפ","name":"הבדרן","description":"השילוב הזה מציע עניין באנשים, חוויה מוחשית, התחשבות וגמישות. ייתכן שקל לך להתחבר למה שקורה עכשיו ולשים לב כיצד אפשר להפוך את הרגע לנעים ומשמעותי יותר עבור המשתתפים.","strengths":["יצירת קשר דרך חוויה משותפת","תשומת לב לתגובות של אנשים בזמן אמת","התאמה גמישה למה שקורה סביבך"],"stretch":"מה שנעים ברגע זה עלול להשאיר משימה חשובה למועד לא נוח. עוגנים קטנים יכולים לפנות מקום להנאה בהמשך.","relationships":"ייתכן שחום, נוכחות ועשייה משותפת חשובים לך. שיחות שקטות יכולות לחשוף צרכים שאינם בולטים על פני השטח.","work":"סביבה אנושית, משימות מוחשיות ומגוון עשויים להיטיב איתך.","experiment":"לסיים משימה קטנה שקבעת מראש לפני שעוברים להזדמנות המפתה הבאה."},"ENFP":{"he":"חערפ","name":"הפעיל / האקטיביסט","description":"כאן מתחברים עיבוד דרך קשר עם אחרים, חיפוש אפשרויות, ערכים אישיים וגמישות. ייתכן ששיחה טובה מעוררת אצלך כיוונים חדשים, במיוחד כשהם מתחברים לאנשים או למשהו שחשוב לך.","strengths":["חיבור בין רעיונות ואנשים","זיהוי פוטנציאל שעדיין לא התממש","התלהבות שמזמינה השתתפות"],"stretch":"ריבוי כיוונים יכול לפזר את האנרגיה גם כשכולם טובים. בחירת כיוון זמני יכולה לעזור לרעיון אחד לקבל חיים.","relationships":"סקרנות וחילופי מחשבות עשויים להיות דרך טבעית לקרבה. כדאי לבדוק גם אילו התחייבויות קטנות הצד השני צריך.","work":"גיוון, משמעות ומרחב להציע דרכים חדשות עשויים להתאים לך.","experiment":"לבחור רעיון אחד לשבוע הקרוב ולהגדיר לו תוצר קטן ומועד."},"ENTP":{"he":"חעשפ","name":"הפולמוסן / המתווכח","description":"השילוב הזה מחבר חשיבה בקול, עניין באפשרויות, בדיקה עניינית ופתיחות. ייתכן ששיחה היא עבורך מעבדה לרעיונות: מציעים, מערערים ומשנים כדי למצוא זווית טובה יותר.","strengths":["יצירת חלופות לא שגרתיות","זיהוי הנחות שאפשר לאתגר","פיתוח רעיון באמצעות שיחה וביקורת"],"stretch":"בחינת טיעון לשם הסקרנות עלולה להיחוות כביקורת אישית. כדאי להבהיר את הכוונה ולברר אם הצד השני רוצה דיון כזה עכשיו.","relationships":"ייתכן שהחלפת רעיונות נותנת לך אנרגיה. הקשבה בלי להציע מיד זווית נגדית יכולה לפתוח סוג אחר של קרבה.","work":"שאלות פתוחות, שותפים לחשיבה וחופש לנסות חלופות עשויים להיטיב איתך.","experiment":"לבחור חלופה אחת ולבדוק אותה בפועל לפני שמציעים שלוש נוספות."},"ESTJ":{"he":"חקשג","name":"המנהל","description":"זהו חיבור בין מעורבות בסביבה, תשומת לב לעובדות, הכרעה עניינית ומסגרת. ייתכן שנוח לך להבהיר את המטרה, לסכם מה צריך לקרות וליצור סדר שמאפשר לאנשים להתקדם יחד.","strengths":["הפיכת מטרות למשימות מוגדרות","תיאום אחריות וציפיות","בחינת התקדמות לפי נתונים ברורים"],"stretch":"קצב החלטה מהיר עלול להקדים מידע או הסתייגות שעדיין לא נאמרו. הזמנה מפורשת להשמיע קושי יכולה לשפר את התוכנית.","relationships":"נאמנות ועזרה מעשית עשויות להיות חשובות לך. לא כל קושי שמספרים לך עליו דורש ארגון מחדש.","work":"יעדים ברורים, תיאום ומרחב לקדם ביצוע עשויים להתאים לך.","experiment":"לפני סיכום החלטה, לבקש מכל משתתף לציין דבר אחד שעוד לא נשקל."},"ESFJ":{"he":"חקרג","name":"היועץ","description":"כאן נפגשים קשר פעיל עם אנשים, תשומת לב לפרטים, התחשבות ומסגרת. ייתכן שחשוב לך שהציפיות יהיו ברורות ושהאנשים המעורבים ירגישו שיש מי שרואה אותם ודואג למפגש מוצלח.","strengths":["תיאום צרכים מעשיים של אנשים","יצירת תחושת שותפות","מעקב אחר פרטים שמקלים על אחרים"],"stretch":"ניסיון לדאוג לכולם עלול להפוך להסכמה אוטומטית. גבול ברור עוזר לשמור גם על הקשר וגם על הכוחות שלך.","relationships":"שיתוף, מחוות והדדיות עשויים להיות חשובים לך. כדאי לבדוק אם לאחרים יש דרך שונה להביע אכפתיות.","work":"שיתוף פעולה, תפקידים ידועים ומשוב אנושי עשויים לסייע לך.","experiment":"להחליף הסכמה מיידית אחת במשפט: אבדוק מה מתאים לי ואחזור עם תשובה."},"ENFJ":{"he":"חערג","name":"הגיבור","description":"הצירוף הזה מחבר מעורבות חברתית, ראיית אפשרויות, ערכים ורצון בכיוון ברור. ייתכן שנוח לך לחשוב יחד עם אחרים על מה שיכול לצמוח, ולעזור לרעיון משותף להפוך למחויבות מעשית.","strengths":["ניסוח כיוון שאנשים יכולים להתחבר אליו","זיהוי שאיפות וצרכים בשיחה","ארגון מאמץ סביב מטרה משותפת"],"stretch":"ראיית פוטנציאל באדם אינה אומרת שזה הכיוון שהוא רוצה. אפשר להציע תמיכה ולהשאיר את הבחירה בידיו.","relationships":"ייתכן שחשוב לך לדבר על משמעות ועל צמיחה משותפת. לפעמים קשר צריך פשוט מקום להיות, בלי יעד לשיפור.","work":"מטרה בעלת משמעות, קשר עם אנשים ותוכנית ברורה עשויים להתאים לך.","experiment":"לשאול אדם קרוב איזה סוג תמיכה הוא רוצה, ולפעול לפי תשובתו."},"ENTJ":{"he":"חעשג","name":"המפקד","description":"כאן מתחברים חשיבה דרך מעורבות, תמונה רחבה, הכרעה עניינית והעדפה למסגרת. ייתכן שנוח לך לזהות כיוון, להציב סדרי עדיפויות ולהניע שיחה שמסתיימת בהחלטה ובצעד הבא.","strengths":["חיבור בין אסטרטגיה להחלטות","תעדוף של מאמץ ומשאבים","הבהרת מטרות והנעת התקדמות"],"stretch":"כשברור לך מה צריך לקרות, קל להניח שגם לאחרים ברור ומוסכם. בדיקת ההבנה וההשפעה האנושית יכולה לחזק את הביצוע.","relationships":"ישירות ומחויבות עשויות להיות חשובות לך. אפשר להראות אכפתיות גם בהקשבה שאין בסופה פתרון.","work":"אתגר מורכב, אחריות ברורה ואפשרות לקדם כיוון עשויים לעזור לך.","experiment":"בדיון הבא, לשמוע את ההצעות של האחרים לפני שמציגים את ההכרעה שלך."}};
const MBTI_ILLUSTRATIONS = {"ISTJ":"data:image/svg+xml;base64,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","ISFJ":"data:image/svg+xml;base64,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","INFJ":"data:image/svg+xml;base64,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","INTJ":"data:image/svg+xml;base64,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","ISTP":"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNDAgMjQwIiByb2xlPSJpbWciIGFyaWEtbGFiZWxsZWRieT0iaXN0cC10aXRsZSIgYXJpYS1kZXNjcmliZWRieT0iaXN0cC1kZXNjIj4KPHRpdGxlIGlkPSJpc3RwLXRpdGxlIj5JU1RQOiBUaGUgbWFrZXIga25lZWxpbmcgd2l0aCBhIHdyZW5jaDwvdGl0bGU+CjxkZXNjIGlkPSJpc3RwLWRlc2MiPkEgYmVhcmRlZCBtYWxlIG1ha2VyIGluIGEgZ3JlZW4gd29yayBzaGlydCBhbmQgY2FwIGtuZWVscyB3aXRoIGEgc3RlZWwgb3Blbi1lbmRlZCB3cmVuY2guIFJvbGxlZCBzbGVldmVzLCB0d28gcG9ja2V0cyBhbmQgYSBncm91bmRlZCBwb3NlIGtlZXAgdGhlIHNjZW5lIHByYWN0aWNhbC48L2Rlc2M+CjxjaXJjbGUgY3g9IjEyMCIgY3k9IjEyMiIgcj0iODQiIGZpbGw9IiNFNEYyRUUiLz4KPGVsbGlwc2UgY3g9IjEyMCIgY3k9IjIxNiIgcng9IjY1IiByeT0iMyIgZmlsbD0iIzI2M0Q0OCIgb3BhY2l0eT0iLjA4Ii8+CjxnIGZpbGw9Im5vbmUiIHN0cm9rZT0iIzI2M0Q0OCIgc3Ryb2tlLXdpZHRoPSIxLjQiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+CjxwYXRoIGQ9Ik04MyAxNTQgMTA3IDE2MCA5MiAxOTYgMTEwIDIwNSAxMDQgMjE2SDc5UTY4IDIxNSA3MyAyMDRaIiBmaWxsPSIjMjYzRDQ4Ii8+CjxwYXRoIGQ9Ik0xMDkgMTU0IDEzMiAxNjAgMTU0IDE3NFExNTkgMTc4IDE1NyAxODZMMTUxIDIwN0gxMzVMMTM3IDE4NiAxMTEgMTc5WiIgZmlsbD0iIzM1NTk1NCIvPgo8ZyB0cmFuc2Zvcm09InRyYW5zbGF0ZSgxMDMgMjA2KSByb3RhdGUoMCkgc2NhbGUoMSAxKSI+CjxwYXRoIGQ9Ik0wIDBIMTRRMTggNCAyNiA1UTMwIDYgMjkgMTFILTFRLTQgOCAwIDBaIiBmaWxsPSIjMjYzRDQ4Ii8+CjxwYXRoIGQ9Ik0wIDlIMjciIHN0cm9rZT0iI0ZGRjlFRCIgc3Ryb2tlLXdpZHRoPSIxIiBvcGFjaXR5PSIuMzgiLz4KPC9nPgo8ZyB0cmFuc2Zvcm09InRyYW5zbGF0ZSgxMzYgMjA1KSByb3RhdGUoMCkgc2NhbGUoMSAxKSI+CjxwYXRoIGQ9Ik0wIDBIMTRRMTggNCAyNiA1UTMwIDYgMjkgMTFILTFRLTQgOCAwIDBaIiBmaWxsPSIjMjYzRDQ4Ii8+CjxwYXRoIGQ9Ik0wIDlIMjciIHN0cm9rZT0iI0ZGRjlFRCIgc3Ryb2tlLXdpZHRoPSIxIiBvcGFjaXR5PSIuMzgiLz4KPC9nPgo8cGF0aCBkPSJNNzggMTEzUTYzIDEzNiA1MSAxNjciIHN0cm9rZS13aWR0aD0iMTYuNiIvPgo8cGF0aCBkPSJNNzggMTEzUTYzIDEzNiA1MSAxNjciIHN0cm9rZT0iIzMxNzQ2OSIgc3Ryb2tlLXdpZHRoPSIxNCIvPgo8cGF0aCBkPSJNMTI3IDExNCAxNDkgMTM5UTE1NSAxNDMgMTYwIDEzNEwxNzEgMTE1IiBzdHJva2Utd2lkdGg9IjE2LjYiLz4KPHBhdGggZD0iTTEyNyAxMTQgMTQ5IDEzOVExNTUgMTQzIDE2MCAxMzRMMTcxIDExNSIgc3Ryb2tlPSIjMzE3NDY5IiBzdHJva2Utd2lkdGg9IjE0Ii8+CjxnIHRyYW5zZm9ybT0idHJhbnNsYXRlKDEwMyAwKSByb3RhdGUoNiAwIDEyNikiPgo8cGF0aCBkPSJNLTEwIDk2US0yNiA5Ny0yOCAxMDlMLTI0IDE1OFEwIDE2MyAyNiAxNTZMMjUgMTA5UTIzIDk5IDEwIDk2WiIgZmlsbD0iIzMxNzQ2OSIvPgo8cGF0aCBkPSJNLTkgOTcgMCAxMDQgMTAgOTcgMTIgMTU2LTcgMTU5WiIgZmlsbD0iI0ZGRjlFRCIgc3Ryb2tlPSJub25lIi8+CjxwYXRoIGQ9Ik0tMTEgOTYtMiAxMDQtMTAgMTIyLTIwIDEwOFoiIGZpbGw9IiM1QzlCOEIiIHN0cm9rZT0ibm9uZSIvPgo8cGF0aCBkPSJNMTEgOTYgMiAxMDQgMTIgMTIxIDIxIDEwN1oiIGZpbGw9IiM1QzlCOEIiIHN0cm9rZT0ibm9uZSIvPgo8cGF0aCBkPSJNLTEwIDEyNC0xMSAxNTRNMTMgMTI1IDE2IDE1MyIgc3Ryb2tlPSIjRkZGOUVEIiBzdHJva2Utd2lkdGg9IjEiIG9wYWNpdHk9Ii4yOCIvPgo8L2c+CjxwYXRoIGQ9Ik04MSAxMzEgOTIgMTI5IDk0IDE0MCA4MyAxNDJaTTExNSAxMjggMTI2IDEzMCAxMjUgMTQxIDExNCAxMzlaIiBmaWxsPSIjMjc2MzU1IiBzdHJva2U9Im5vbmUiLz4KPGcgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoMTAxIDczKSByb3RhdGUoNykiPgo8cmVjdCB4PSItNiIgeT0iMTciIHdpZHRoPSIxMiIgaGVpZ2h0PSIxNiIgcng9IjMiIGZpbGw9IiM5QTYyNDciLz4KPHBhdGggZD0iTS01IDIxUTAgMjYgNiAyMlYyOFEwIDMwLTUgMjdaIiBmaWxsPSIjN0Q0QTM2IiBzdHJva2U9Im5vbmUiLz4KPGVsbGlwc2UgY3g9Ii0xNi41IiBjeT0iMyIgcng9IjMuNSIgcnk9IjUiIGZpbGw9IiM5QTYyNDciLz4KPGVsbGlwc2UgY3g9IjE2LjUiIGN5PSIzIiByeD0iMy41IiByeT0iNSIgZmlsbD0iIzlBNjI0NyIvPgo8cGF0aCBkPSJNLTE2LTEyUS0xNi0yNCAwLTI0UTE2LTI0IDE2LTEyVjdRMTUgMjEgMCAyNFEtMTQgMjItMTYgOFoiIGZpbGw9IiM5QTYyNDciLz4KPHBhdGggZD0iTS0xOC03US0xOS0yNi0xLTI4UTE0LTI5IDE4LTExTDI0LTdRMjctMyAyMi0ySC0xMlY1SC0xNloiIGZpbGw9IiMzMzQ2M0IiIHN0cm9rZT0iIzMzNDYzQiIvPgo8cGF0aCBkPSJNLTE2LThRNC0xMiAyMC02TS00LTI0UTQtMjIgNy0xMyIgc3Ryb2tlPSIjRkZGOUVEIiBzdHJva2Utd2lkdGg9IjEuMiIgb3BhY2l0eT0iLjQ4Ii8+CjxwYXRoIGQ9Ik0tMTUgNi0xMCAxMC01IDEwIDAgOCA2IDEwIDExIDkgMTUgNSAxMyAxNlE4IDI0IDAgMjRRLTEwIDIyLTE0IDE1WiIgZmlsbD0iIzMzNDYzQiIgc3Ryb2tlPSIjMzM0NjNCIi8+CjxwYXRoIGQ9Ik0tMTEtMlEtNy00LTMtMk00LTJROC00IDEyLTIiIHN0cm9rZT0iIzMzNDYzQiIvPgo8Y2lyY2xlIGN4PSItNyIgY3k9IjMiIHI9IjEuMTUiIGZpbGw9IiMyNjNENDgiIHN0cm9rZT0ibm9uZSIvPgo8Y2lyY2xlIGN4PSI4IiBjeT0iMyIgcj0iMS4xNSIgZmlsbD0iIzI2M0Q0OCIgc3Ryb2tlPSJub25lIi8+CjxwYXRoIGQ9Ik0xIDQtMSA5IDIgMTAiIHN0cm9rZT0iIzdENEEzNiIgc3Ryb2tlLXdpZHRoPSIxLjIiLz4KPHBhdGggZD0iTS01IDE0UTAgMTkgNiAxNCIgc3Ryb2tlPSIjRkZGOUVEIi8+CjwvZz4KPGcgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoNDcgMTc1KSByb3RhdGUoMjUpIj4KPHBhdGggZD0iTS01IDNWLTRRLTUtNy0yLTdIM1E3LTcgNy0zVjNRNiA4IDEgOFEtMyA4LTUgM1oiIGZpbGw9IiM5QTYyNDciLz4KPHBhdGggZD0iTS01IDAtMS0yUTItMyAzIDBMMCAzIiBzdHJva2U9IiM3RDRBMzYiIHN0cm9rZS13aWR0aD0iMSIvPgo8L2c+CjxnIHRyYW5zZm9ybT0idHJhbnNsYXRlKDE4MiA4OSkgcm90YXRlKDIzKSI+CjxwYXRoIGQ9Ik0tNCAyOVYtOFEtMTQtMTMtMTEtMjRMLTYtMTZIM0w4LTI0UTE0LTEzIDQtOFYyOVEwIDM1LTQgMjlaIiBmaWxsPSIjODI5OTlCIi8+CjxwYXRoIGQ9Ik0wIDIwVi01IiBzdHJva2U9IiNGRkY5RUQiIHN0cm9rZS13aWR0aD0iMS4yIi8+CjxjaXJjbGUgY3g9IjAiIGN5PSIyNyIgcj0iMS42IiBmaWxsPSIjMjYzRDQ4IiBzdHJva2U9Im5vbmUiLz4KPC9nPgo8ZyB0cmFuc2Zvcm09InRyYW5zbGF0ZSgxNzEgMTE1KSByb3RhdGUoMjQpIj4KPHBhdGggZD0iTS01IDNWLTRRLTUtNy0yLTdIM1E3LTcgNy0zVjNRNiA4IDEgOFEtMyA4LTUgM1oiIGZpbGw9IiM5QTYyNDciLz4KPHBhdGggZD0iTS01IDAtMS0yUTItMyAzIDBMMCAzIiBzdHJva2U9IiM3RDRBMzYiIHN0cm9rZS13aWR0aD0iMSIvPgo8L2c+CjwvZz4KPC9zdmc+Cg==","ISFP":"data:image/svg+xml;base64,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","INFP":"data:image/svg+xml;base64,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","INTP":"data:image/svg+xml;base64,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","ESTP":"data:image/svg+xml;base64,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","ESFP":"data:image/svg+xml;base64,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","ENFP":"data:image/svg+xml;base64,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","ENTP":"data:image/svg+xml;base64,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","ESTJ":"data:image/svg+xml;base64,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","ESFJ":"data:image/svg+xml;base64,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","ENFJ":"data:image/svg+xml;base64,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","ENTJ":"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNDAgMjQwIiByb2xlPSJpbWciIGFyaWEtbGFiZWxsZWRieT0iZW50ai10aXRsZSIgYXJpYS1kZXNjcmliZWRieT0iZW50ai1kZXNjIj4KPHRpdGxlIGlkPSJlbnRqLXRpdGxlIj5FTlRKOiBUaGUgbGVhZGVyIGluZGljYXRpbmcgdGhlIG5leHQgc3RlcDwvdGl0bGU+CjxkZXNjIGlkPSJlbnRqLWRlc2MiPkEgY29uZmlkZW50IG1vdXN0YWNoZWQgbWFsZSBsZWFkZXIgd2VhcnMgYSBidXJndW5keSBzdWl0LiBPbmUgZm9vdCBpcyBvbiBhIGxvdyBzdGVwIGFuZCBvbmUgaGFuZCBwb2ludHMgZm9yd2FyZCBhbmQgdXB3YXJkIGFsb25nIGEgY2xlYXIgc3RhaXJjYXNlLjwvZGVzYz4KPGNpcmNsZSBjeD0iMTIwIiBjeT0iMTIyIiByPSI4NCIgZmlsbD0iI0Y3RTlFRCIvPgo8ZWxsaXBzZSBjeD0iMTIwIiBjeT0iMjE2IiByeD0iNjUiIHJ5PSIzIiBmaWxsPSIjMjYzRDQ4IiBvcGFjaXR5PSIuMDgiLz4KPGcgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjMjYzRDQ4IiBzdHJva2Utd2lkdGg9IjEuNCIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIj4KPHBhdGggZD0iTTEzOSAyMTVWMTkySDE2NlYxNzJIMTkyVjE1MEgyMTRWMjE1WiIgZmlsbD0iI0U4QzhDRSIgc3Ryb2tlPSJub25lIi8+CjxwYXRoIGQ9Ik0xNjYgMTkxSDE5MU0xOTIgMTcxSDIxMiIgc3Ryb2tlPSIjOTMzRjU2IiBvcGFjaXR5PSIuMjUiLz4KPHBhdGggZD0iTTg0IDE1MkgxMDhMMTA0IDIwMkg4NloiIGZpbGw9IiMyNjNENDgiLz4KPHBhdGggZD0iTTEwOCAxNTEgMTMxIDE0OVExNDIgMTUwIDE1MSAxNjBMMTU0IDE4MEgxMzhMMTM2IDE3MCAxMTQgMTc0WiIgZmlsbD0iIzM3NEE1NyIvPgo8ZyB0cmFuc2Zvcm09InRyYW5zbGF0ZSg4NSAyMDEpIHJvdGF0ZSgwKSBzY2FsZSgtMSAxKSI+CjxwYXRoIGQ9Ik0wIDBIMTRRMTggNCAyNiA1UTMwIDYgMjkgMTFILTFRLTQgOCAwIDBaIiBmaWxsPSIjMjYzRDQ4Ii8+CjxwYXRoIGQ9Ik0wIDlIMjciIHN0cm9rZT0iI0ZGRjlFRCIgc3Ryb2tlLXdpZHRoPSIxIiBvcGFjaXR5PSIuMzgiLz4KPC9nPgo8ZyB0cmFuc2Zvcm09InRyYW5zbGF0ZSgxMzkgMTgxKSByb3RhdGUoMCkgc2NhbGUoMSAxKSI+CjxwYXRoIGQ9Ik0wIDBIMTRRMTggNCAyNiA1UTMwIDYgMjkgMTFILTFRLTQgOCAwIDBaIiBmaWxsPSIjMjYzRDQ4Ii8+CjxwYXRoIGQ9Ik0wIDlIMjciIHN0cm9rZT0iI0ZGRjlFRCIgc3Ryb2tlLXdpZHRoPSIxIiBvcGFjaXR5PSIuMzgiLz4KPC9nPgo8cGF0aCBkPSJNODcgMTA3IDcyIDEzM1E3MCAxNDMgOTMgMTQ3IiBzdHJva2Utd2lkdGg9IjE2LjYiLz4KPHBhdGggZD0iTTg3IDEwNyA3MiAxMzNRNzAgMTQzIDkzIDE0NyIgc3Ryb2tlPSIjOTMzRjU2IiBzdHJva2Utd2lkdGg9IjE0Ii8+CjxwYXRoIGQ9Ik0xMzMgMTA3IDE1MiAxMjJRMTU2IDEyMyAxNjAgMTE1TDE3NyA4OCIgc3Ryb2tlLXdpZHRoPSIxNi42Ii8+CjxwYXRoIGQ9Ik0xMzMgMTA3IDE1MiAxMjJRMTU2IDEyMyAxNjAgMTE1TDE3NyA4OCIgc3Ryb2tlPSIjOTMzRjU2IiBzdHJva2Utd2lkdGg9IjE0Ii8+CjxnIHRyYW5zZm9ybT0idHJhbnNsYXRlKDEwOCAwKSByb3RhdGUoMCAwIDEyNikiPgo8cGF0aCBkPSJNLTEwIDk2US0yNiA5Ny0yOCAxMDlMLTI0IDE1OFEwIDE2MyAyNiAxNTZMMjUgMTA5UTIzIDk5IDEwIDk2WiIgZmlsbD0iIzkzM0Y1NiIvPgo8cGF0aCBkPSJNLTkgOTcgMCAxMDQgMTAgOTcgMTIgMTU2LTcgMTU5WiIgZmlsbD0iI0ZGRjlFRCIgc3Ryb2tlPSJub25lIi8+CjxwYXRoIGQ9Ik0tMTEgOTYtMiAxMDQtMTAgMTIyLTIwIDEwOFoiIGZpbGw9IiM3QjM1NDkiIHN0cm9rZT0ibm9uZSIvPgo8cGF0aCBkPSJNMTEgOTYgMiAxMDQgMTIgMTIxIDIxIDEwN1oiIGZpbGw9IiM3QjM1NDkiIHN0cm9rZT0ibm9uZSIvPgo8cGF0aCBkPSJNLTEwIDEyNC0xMSAxNTRNMTMgMTI1IDE2IDE1MyIgc3Ryb2tlPSIjRkZGOUVEIiBzdHJva2Utd2lkdGg9IjEiIG9wYWNpdHk9Ii4yOCIvPgo8L2c+CjxwYXRoIGQ9Ik0xMDYgMTA2IDExMSAxMDYgMTE1IDEzMiAxMTEgMTM4IDEwNiAxMzJaIiBmaWxsPSIjRTZCNjVEIiBzdHJva2U9Im5vbmUiLz4KPHBhdGggZD0iTTczIDEzNlE3NiAxNDQgOTEgMTQ2IiBzdHJva2Utd2lkdGg9IjE0LjYiLz4KPHBhdGggZD0iTTczIDEzNlE3NiAxNDQgOTEgMTQ2IiBzdHJva2U9IiM5MzNGNTYiIHN0cm9rZS13aWR0aD0iMTIiLz4KPGcgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoOTUgMTQ1KSByb3RhdGUoNzUpIj4KPHBhdGggZD0iTS01IDNWLTRRLTUtNy0yLTdIM1E3LTcgNy0zVjNRNiA4IDEgOFEtMyA4LTUgM1oiIGZpbGw9IiM5QTYyNDciLz4KPHBhdGggZD0iTS01IDAtMS0yUTItMyAzIDBMMCAzIiBzdHJva2U9IiM3RDRBMzYiIHN0cm9rZS13aWR0aD0iMSIvPgo8L2c+CjxnIHRyYW5zZm9ybT0idHJhbnNsYXRlKDEwOCA2Nikgcm90YXRlKC00KSI+CjxyZWN0IHg9Ii02IiB5PSIxNyIgd2lkdGg9IjEyIiBoZWlnaHQ9IjE2IiByeD0iMyIgZmlsbD0iIzlBNjI0NyIvPgo8cGF0aCBkPSJNLTUgMjFRMCAyNiA2IDIyVjI4UTAgMzAtNSAyN1oiIGZpbGw9IiM3RDRBMzYiIHN0cm9rZT0ibm9uZSIvPgo8ZWxsaXBzZSBjeD0iLTE2LjUiIGN5PSIzIiByeD0iMy41IiByeT0iNSIgZmlsbD0iIzlBNjI0NyIvPgo8ZWxsaXBzZSBjeD0iMTYuNSIgY3k9IjMiIHJ4PSIzLjUiIHJ5PSI1IiBmaWxsPSIjOUE2MjQ3Ii8+CjxwYXRoIGQ9Ik0tMTYtMTJRLTE2LTI0IDAtMjRRMTYtMjQgMTYtMTJWN1ExNSAyMSAwIDI0US0xNCAyMi0xNiA4WiIgZmlsbD0iIzlBNjI0NyIvPgo8cGF0aCBkPSJNLTE2IDNRLTIwLTktMTYtMTdRLTEyLTI1IDAtMjVRMTQtMjYgMTctMTZMMTYgMkgxM1YtMTJRMC04LTEyLTEyVjNaIiBmaWxsPSIjMjYzRDQ4Ii8+CjxwYXRoIGQ9Ik0tMTEtMlEtNy00LTMtMk00LTJROC00IDEyLTIiLz4KPGNpcmNsZSBjeD0iLTciIGN5PSIzIiByPSIxLjE1IiBmaWxsPSIjMjYzRDQ4IiBzdHJva2U9Im5vbmUiLz4KPGNpcmNsZSBjeD0iOCIgY3k9IjMiIHI9IjEuMTUiIGZpbGw9IiMyNjNENDgiIHN0cm9rZT0ibm9uZSIvPgo8cGF0aCBkPSJNMSA0LTEgOSAyIDEwIiBzdHJva2U9IiM3RDRBMzYiIHN0cm9rZS13aWR0aD0iMS4yIi8+CjxwYXRoIGQ9Ik0tOSAxM1EtNCA5IDAgMTJRNSA5IDEwIDEzUTcgMTcgMSAxNFEtNSAxNy05IDEzWiIgZmlsbD0iIzI2M0Q0OCIgc3Ryb2tlPSJub25lIi8+CjxwYXRoIGQ9Ik0tMyAxOVExIDIxIDUgMTgiIHN0cm9rZS13aWR0aD0iMS4xIi8+CjwvZz4KPGcgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoMTc3IDgyKSByb3RhdGUoMTkpIj4KPHBhdGggZD0iTS01IDctNi0zUS03LTgtMy04TDAtNiAyLTIwUTMtMjQgNS0yMUw2LTUgMTAtMiA5IDdRNSAxMiAwIDExWiIgZmlsbD0iIzlBNjI0NyIvPgo8cGF0aCBkPSJNMC01IDQtMiIgc3Ryb2tlPSIjN0Q0QTM2IiBzdHJva2Utd2lkdGg9IjEiLz4KPC9nPgo8L2c+Cjwvc3ZnPgo="};
const MBTI_PALETTES = {"INTJ":{"accent":"#43558B","soft":"#EBEDF7","darkAccent":"#AFBAF4","darkSoft":"#252D49"},"INTP":{"accent":"#745F8B","soft":"#F0EBF5","darkAccent":"#CEB4E6","darkSoft":"#362A43"},"ENTJ":{"accent":"#933F56","soft":"#F7E9ED","darkAccent":"#F2A9BA","darkSoft":"#482935"},"ENTP":{"accent":"#A4502B","soft":"#F9ECDF","darkAccent":"#F5B48C","darkSoft":"#493124"},"INFJ":{"accent":"#3B6C59","soft":"#E7F1EB","darkAccent":"#9ED4B7","darkSoft":"#263D33"},"INFP":{"accent":"#5E7034","soft":"#EFF2E2","darkAccent":"#C6D598","darkSoft":"#363D25"},"ENFJ":{"accent":"#267376","soft":"#E4F2EF","darkAccent":"#98DADB","darkSoft":"#203D40"},"ENFP":{"accent":"#89641B","soft":"#FBF2D8","darkAccent":"#EAC66F","darkSoft":"#443921"},"ISTJ":{"accent":"#476778","soft":"#E8EFF3","darkAccent":"#ABCADB","darkSoft":"#293942"},"ISFJ":{"accent":"#9A5263","soft":"#F7EAEE","darkAccent":"#EDB3C2","darkSoft":"#472D37"},"ESTJ":{"accent":"#345A8B","soft":"#E7EEF7","darkAccent":"#A9C7F2","darkSoft":"#26354B"},"ESFJ":{"accent":"#A1503E","soft":"#FAEAE3","darkAccent":"#F3B29C","darkSoft":"#4B302A"},"ISTP":{"accent":"#317469","soft":"#E4F2EE","darkAccent":"#98D6C8","darkSoft":"#243F38"},"ISFP":{"accent":"#795B98","soft":"#F2EAF9","darkAccent":"#D3B6F1","darkSoft":"#3B2D4C"},"ESTP":{"accent":"#9B5B20","soft":"#FFF0DE","darkAccent":"#F7C286","darkSoft":"#4C3724"},"ESFP":{"accent":"#A3477A","soft":"#F9E9F2","darkAccent":"#F0AED4","darkSoft":"#492C40"}};</script>
<script>/* Shared by the standalone page and Node verification. No fitted persona weights. */
(function (root) {
  'use strict';
  const axes = [
    { id: 'EI', title: 'מאיפה מגיעה האנרגיה', labels: ['מוחצן', 'מופנם'], explanations: ['מפגש עם אנשים ועיבוד בקול', 'מרחב אישי ועיבוד פנימי'] },
    { id: 'SN', title: 'איך קולטים את העולם', labels: ['קונקרטי', 'עיוני'], explanations: ['פרטים מוחשיים וניסיון ישיר', 'דפוסים, רעיונות ואפשרויות'] },
    { id: 'TF', title: 'מה מנחה החלטות', labels: ['שכלתני', 'רגשי'], explanations: ['עקביות, עקרונות ושיקולים ענייניים', 'ערכים אישיים וההשפעה על אנשים'] },
    { id: 'JP', title: 'איך ניגשים לחיי היום-יום', labels: ['גבולני', 'פתוח'], explanations: ['מסגרת, תכנון וסגירת קצוות', 'גמישות, התאמה והשארת אפשרויות'] }
  ];
  const hebrew = { E: 'ח', I: 'מ', S: 'ק', N: 'ע', T: 'ש', F: 'ר', J: 'ג', P: 'פ', X: '?' };
  function score(questions, answers) {
    if (!Array.isArray(answers) || answers.length !== questions.length || Array.from(answers).some(a => !Number.isInteger(a) || a < 1 || a > 5)) {
      throw new Error('יש להשיב על כל השאלות בתשובות בין 1 ל-5');
    }
    const results = axes.map(axis => {
      let sum = 0, count = 0, neutral = 0, first = 0, second = 0;
      questions.forEach((q, i) => {
        if (q.axis !== axis.id) return;
        const value = (3 - answers[i]) * (q.aPole === axis.id[0] ? 1 : -1);
        sum += value; count++;
        if (!value) neutral++; else if (value > 0) first++; else second++;
      });
      if (!count) throw new Error('Missing axis: ' + axis.id);
      const normalized = sum / (count * 2);
      const firstPercent = Math.round(50 + 50 * normalized);
      return { ...axis, sum, count, neutral, first, second, normalized, firstPercent,
        secondPercent: 100 - firstPercent, letter: sum === 0 ? 'X' : sum > 0 ? axis.id[0] : axis.id[1],
        close: Math.abs(normalized) <= 0.25,
        label: sum === 0 ? 'ללא העדפה מכריעה' : Math.abs(normalized) <= 0.25 ? 'נטייה קלה' : Math.abs(normalized) <= 0.6 ? 'נטייה בינונית' : 'נטייה בולטת' };
    });
    const code = results.map(a => a.letter).join('');
    const candidates = results.reduce((codes, a) => codes.flatMap(c => (a.close ? [...a.id] : [a.letter]).map(l => c + l)), ['']);
    candidates.sort((a, b) => distance(a) - distance(b) || a.localeCompare(b));
    function distance(type) { return results.reduce((total, axis, i) => total + (1 - (type[i] === axis.id[0] ? 1 : -1) * axis.normalized), 0); }
    return { code, hebrewCode: [...code].map(c => hebrew[c]).join(''), axes: results, candidates,
      neutralCount: answers.filter(a => a === 3).length,
      straightLine: new Set(answers).size === 1 };
  }
  const api = { axes, hebrew, score };
  if (typeof module !== 'undefined' && module.exports) module.exports = api;
  else root.MBTI = api;
})(typeof globalThis !== 'undefined' ? globalThis : this);
</script>
<script>(() => {
  'use strict';
  const $ = id => document.getElementById(id);
  const questions = MBTI_DATA.questions;
  const key = 'nhlocal.16-types.v1';
  const themeKey = 'nhlocal.16-types.theme';
  const systemTheme = matchMedia('(prefers-color-scheme: dark)');
  let explicitTheme = null;
  try { const saved = localStorage.getItem(themeKey); if (saved === 'light' || saved === 'dark') explicitTheme = saved; } catch {}
  function applyTheme(theme) {
    document.documentElement.dataset.theme = theme;
    const dark = theme === 'dark';
    $('theme-toggle').setAttribute('aria-pressed', String(dark));
    $('theme-toggle').title = dark ? 'מעבר למצב בהיר' : 'מעבר למצב אפל';
    $('theme-color').content = dark ? '#171d28' : '#fcf7f1';
  }
  applyTheme(explicitTheme || (systemTheme.matches ? 'dark' : 'light'));
  $('theme-toggle').addEventListener('click', () => {
    explicitTheme = document.documentElement.dataset.theme === 'dark' ? 'light' : 'dark';
    applyTheme(explicitTheme);
    try { localStorage.setItem(themeKey, explicitTheme); } catch {}
  });
  systemTheme.addEventListener('change', event => { if (!explicitTheme) applyTheme(event.matches ? 'dark' : 'light'); });
  const optionLabels = ["בבירור א'", "נוטה ל-א'", 'לא ברור', "נוטה ל-ב'", "בבירור ב'"];
  const fullLabels = ["בבירור א', העדפה ברורה לאפשרות א'", "נוטה ל-א', העדפה קלה לאפשרות א'", 'לא ברור, אין העדפה ברורה בין האפשרויות', "נוטה ל-ב', העדפה קלה לאפשרות ב'", "בבירור ב', העדפה ברורה לאפשרות ב'"];
  let answers = Array(questions.length).fill(null), current = 0, screen = 'welcome', returnToReview = false, result = null, storageWorks = true, resetStartsQuiz = false, toastTimer;
  const esc = value => String(value).replace(/[&<>"']/g, char => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[char]));
  const answered = () => answers.filter(a => a !== null).length;
  function storageFailure() {
    storageWorks = false;
    $('storage-status').hidden = false;
    $('storage-status').textContent = 'השמירה בדפדפן אינה זמינה כרגע. אפשר להמשיך, אבל רענון או סגירה של הדף עלולים למחוק את ההתקדמות';
    $('pause').textContent = 'יציאה מהשאלון';
  }
  function load() {
    try {
      const raw = localStorage.getItem(key);
      if (!raw) return;
      const saved = JSON.parse(raw);
      if (!saved || saved.version !== MBTI_DATA.revision || !Array.isArray(saved.answers) || saved.answers.length !== questions.length || !saved.answers.every(a => a === null || (Number.isInteger(a) && a >= 1 && a <= 5)) || !Number.isInteger(saved.current) || saved.current < 0 || saved.current >= questions.length) {
        localStorage.removeItem(key); return;
      }
      answers = saved.answers; current = saved.current;
    } catch (error) {
      if (error instanceof SyntaxError) { try { localStorage.removeItem(key); } catch { storageFailure(); } }
      else storageFailure();
    }
  }
  function save() {
    if (!storageWorks) return;
    try { localStorage.setItem(key, JSON.stringify({version: MBTI_DATA.revision, answers, current})); }
    catch { storageFailure(); }
  }
  function show(id, focusId) {
    screen = id;
    ['welcome','quiz','review','results'].forEach(name => { $(name).hidden = name !== id; });
    if (focusId) $(focusId).focus({preventScroll:true});
    window.scrollTo({top:0,behavior:'instant'});
  }
  function welcome() {
    const count = answered();
    $('start').hidden = count > 0;
    $('resume').hidden = count === 0;
    $('fresh').hidden = count === 0;
    $('resume').querySelector('span').textContent = count === questions.length ? 'חזרה לתוצאה שלי' : 'להמשיך מאיפה שעצרתי';
    show('welcome');
  }
  function updateProgress() {
    $('progress').max = questions.length;
    $('progress').value = answered();
    $('progress-text').textContent = `${answered()} מתוך ${questions.length} נענו`;
  }
  function renderQuestion() {
    const q = questions[current], chapter = Math.floor(current / 8);
    $('chapter-label').textContent = `פרק ${chapter + 1} מתוך ${MBTI_DATA.chapters.length} · ${MBTI_DATA.chapters[chapter]}`;
    $('question-counter').textContent = `שאלה ${current + 1} מתוך ${questions.length}`;
    $('question-heading').textContent = q.text;
    $('option-a').textContent = q.a; $('option-b').textContent = q.b;
    $('answer-options').innerHTML = optionLabels.map((label, i) => `<label class="answer-choice"><input type="radio" name="answer" value="${i+1}" aria-label="${esc(fullLabels[i])}" ${answers[current] === i+1 ? 'checked' : ''}><span><i aria-hidden="true"></i>${label}</span></label>`).join('');
    $('previous').disabled = current === 0;
    $('next').querySelector('span').textContent = returnToReview ? 'שמירה וחזרה למפה' : current === questions.length - 1 ? 'לתוצאות' : 'הבא';
    $('answer-error').hidden = true;
    updateProgress(); save();
    show('quiz', 'question-heading');
    $('announcement').textContent = `שאלה ${current+1} מתוך ${questions.length}. ${MBTI_DATA.chapters[chapter]}`;
  }
  function start() { current = 0; returnToReview = false; renderQuestion(); }
  function review() {
    $('review-count').textContent = `${answered()} מתוך ${questions.length} שאלות נענו`;
    $('review-list').innerHTML = MBTI_DATA.chapters.map((chapter, c) => `<section class="review-group"><h3>${c+1}. ${esc(chapter)}</h3>${questions.slice(c*8,c*8+8).map(q => {
      const a = answers[q.id-1];
      return `<button class="review-question" data-index="${q.id-1}"><b>${q.id}.</b> ${esc(q.text)}<small>${a === null ? 'עדיין לא נענתה' : esc(fullLabels[a-1]) + (a === 3 ? '' : ': ' + esc(a < 3 ? q.a : q.b))}</small></button>`;
    }).join('')}</section>`).join('');
    $('review-finish').querySelector('span').textContent = answered() === questions.length ? 'לתוצאות' : `להמשיך לשאלות שנותרו (${questions.length - answered()})`;
    show('review', 'review-heading');
  }
  function typeStyle(code) {
    const p = MBTI_PALETTES[code];
    return p ? `--type-light-accent:${p.accent};--type-light-soft:${p.soft};--type-dark-accent:${p.darkAccent};--type-dark-soft:${p.darkSoft}` : '';
  }
  function profileHTML(code, preview = false) {
    const p = MBTI_PROFILES[code];
    const words = [...code].map((letter,i) => MBTI.axes[i].labels[MBTI.axes[i].id.indexOf(letter)]).join(' · ');
    return `<div class="type-profile ${preview ? 'preview-card' : ''}" style="${typeStyle(code)}"><div class="profile-top"><div class="profile-identity"><div class="profile-codes"><bdi class="type-code">${code}</bdi><span class="he-code">${p.he}</span></div><h3 class="profile-name">${esc(p.name)}</h3><p>${words}</p></div><img class="profile-character" src="${MBTI_ILLUSTRATIONS[code]}" alt="" width="210" height="210"></div><p>${esc(p.description)}</p><h4>העדפות וחוזקות אפשריות</h4><ul>${p.strengths.map(s => `<li>${esc(s)}</li>`).join('')}</ul><h4>נקודה למחשבה</h4><p>${esc(p.stretch)}</p><h4>בקשרים עם אנשים</h4><p>${esc(p.relationships)}</p><h4>בלמידה ובעשייה</h4><p>${esc(p.work)}</p><div class="experiment"><h4>אפשר לנסות השבוע</h4><p>${esc(p.experiment)}</p></div></div>`;
  }
  function typeButton(code) {
    const p = MBTI_PROFILES[code];
    return `<button type="button" class="type-chip" style="${typeStyle(code)}" data-type="${code}" aria-pressed="false" aria-controls="type-preview"><img class="type-character" src="${MBTI_ILLUSTRATIONS[code]}" alt="" width="96" height="96" loading="lazy"><span class="type-chip-codes"><bdi dir="ltr">${code}</bdi><span>${p.he}</span></span><span class="type-chip-name">${esc(p.name)}</span></button>`;
  }
  function previewType(code) {
    document.querySelectorAll('[data-type]').forEach(button => button.setAttribute('aria-pressed', String(button.dataset.type === code)));
    $('type-preview').innerHTML = profileHTML(code, true);
  }
  function results() {
    if (answered() !== questions.length) { current = answers.indexOf(null); returnToReview = false; renderQuestion(); return; }
    result = MBTI.score(questions, answers);
    const tied = result.code.includes('X');
    $('results').style.cssText = typeStyle(result.code);
    $('result-heading').textContent = tied ? 'לא התקבלה העדפה בכל הצירים' : `הכיוון שלך: ${MBTI_PROFILES[result.code].name}`;
    $('result-subtitle').textContent = tied ? 'בחלק מהצירים אין כרגע העדפה מכריעה. אפשר לעיין בפירוט ולהשוות בין התיאורים' : 'הפרופיל שעולה מהתשובות שלך';
    $('profile-card').innerHTML = tied ? `<div class="profile-top"><bdi class="type-code">${result.code}</bdi></div><h3>אין טיפוס יחיד בתוצאה הזו</h3><p>האות X מסמנת ציר שבו התקבל שוויון. לא בחרנו עבורך צד שרירותי, ולכן אין כאן תיאור של טיפוס יחיד.</p><p>אפשר לעיין בצירופים המוצעים בהמשך, ולחשוב איזו העדפה חוזרת בחיים שלך כשיש חופש לבחור.</p><div class="experiment"><h4>אפשר לנסות השבוע</h4><p>לתעד שלושה רגעים של בחירה חופשית: מה בחרת, למה, והאם זו הייתה העדפה או דרישה של המצב.</p></div>` : profileHTML(result.code);
    $('axis-results').innerHTML = result.axes.map(a => {
      const winner = a.id.indexOf(a.letter);
      const percentages = [a.firstPercent, a.secondPercent];
      const emphasis = i => i === winner ? ' is-dominant' : '';
      const summary = winner < 0 ? 'אין העדפה לצד מסוים' : `${a.close ? 'נטייה קלה' : 'הנטייה שלך'}: ${a.labels[winner]}`;
      return `<section class="axis-row"><div class="axis-title"><b>${a.title}</b></div><div class="axis-labels">${a.labels.map((label,i) => `<div class="axis-pole${emphasis(i)}"><strong>${label}</strong><bdi dir="ltr">${a.id[i]} · ${percentages[i]}%</bdi></div>`).join('')}</div><div class="axis-bar" role="img" aria-label="${a.labels[0]} ${a.firstPercent} אחוז, ${a.labels[1]} ${a.secondPercent} אחוז">${percentages.map((value,i) => `<i class="${emphasis(i).trim()}" style="width:${value}%"></i>`).join('')}</div><p class="axis-explain"><strong>${summary}</strong>${winner < 0 ? '' : `<br>${a.explanations[winner]}`}</p></section>`;
    }).join('');
    const notices = [];
    if (result.neutralCount >= questions.length / 2) notices.push('בחלק גדול מהשאלות נבחר האמצע. ייתכן ששתי האפשרויות מתאימות לך או שההעדפות משתנות בין מצבים. כדאי לתת לתיאורים משקל מוגבל');
    if (result.straightLine && result.neutralCount === 0) notices.push('נבחרה אותה עמדה בכל השאלות. מכיוון שכיוון האפשרויות מתחלף, התוצאה מאוזנת. כדאי לעבור על התשובות ולבדוק שהבחירות מבטאות את ההעדפות שלך');
    const close = result.axes.filter(a => a.close);
    if (close.length && !tied) notices.push(`בצירים ${close.map(a=>a.labels.join(' / ')).join(', ')} הנטייה קרובה לאמצע. שינוי בכמה תשובות עשוי לשנות את האות המתאימה`);
    $('result-notice').hidden = notices.length === 0;
    $('result-notice').innerHTML = notices.map(n => `<p>${esc(n)}</p>`).join('');
    const nearby = result.candidates.filter(c => c !== result.code);
    $('nearby').hidden = nearby.length === 0;
    $('nearby-explanation').textContent = 'בצירים הקרובים לאמצע כדאי להשוות גם לתיאורים האלה';
    $('nearby-types').innerHTML = nearby.map(typeButton).join('');
    $('type-picker').innerHTML = Object.keys(MBTI_PROFILES).map(typeButton).join('');
    previewType(tied ? result.candidates[0] : result.code);
    save(); show('results', 'result-heading');
  }
  function resultText() {
    const lines = ['16 הטיפוסים | שאלון עצמאי להיכרות עצמית', '', `הצירוף: ${result.code} (${result.hebrewCode})`];
    if (MBTI_PROFILES[result.code]) {
      const p = MBTI_PROFILES[result.code];
      lines.push(p.name, '', p.description, '', 'חוזקות אפשריות:', ...p.strengths.map(s=>'• '+s), '', 'נקודה למחשבה:',p.stretch,'','בקשרים:',p.relationships,'','בלמידה ובעשייה:',p.work,'','ניסוי קטן:',p.experiment);
    } else lines.push('X מסמן שוויון בציר. לא נבחר טיפוס יחיד');
    lines.push('', 'ההעדפות שלך בארבעת התחומים:');
    result.axes.forEach(a => lines.push(`${a.labels[0]} ${a.firstPercent}% | ${a.labels[1]} ${a.secondPercent}% (${a.label})`));
    if (result.candidates.length > 1) lines.push('', 'צירופים להשוואה: ' + result.candidates.join(', '));
    if (!$('result-notice').hidden) lines.push('', $('result-notice').textContent);
    lines.push('', 'האחוזים הם ציוני נטייה מהתשובות, לא הסתברות או מדד ליכולת. שאלון זה אינו מבחן MBTI רשמי ולא עבר תיקוף פסיכומטרי. התוצאה אינה אבחון.', `גרסת שאלון: ${MBTI_DATA.revision}`);
    return lines.join('\n');
  }
  function toast(message) { $('toast').textContent = message; $('toast').hidden = false; clearTimeout(toastTimer); toastTimer = setTimeout(() => {$('toast').hidden = true;}, 5000); }
  function askReset(startAfter) {
    resetStartsQuiz = startAfter;
    $('reset-dialog').setAttribute('aria-labelledby','reset-title');
    $('confirm-reset').textContent = startAfter ? 'למחוק ולהתחיל מחדש' : 'למחוק את התשובות';
    $('reset-dialog').showModal();
  }
  $('start').addEventListener('click',start);
  $('resume').addEventListener('click',()=>{ returnToReview=false; answered()===questions.length ? results() : renderQuestion(); });
  $('pause').addEventListener('click',()=>{save();welcome();$('resume').focus();});
  $('answer-options').addEventListener('change',event=>{ if(event.target.name !== 'answer') return; answers[current]=Number(event.target.value);$('answer-error').hidden=true;save();updateProgress();});
  $('quiz-form').addEventListener('submit',event=>{
    event.preventDefault();
    if(answers[current]===null){$('answer-error').hidden=false;$('answer-options').querySelector('input').focus();return;}
    if(returnToReview){returnToReview=false;review();return;}
    if(current===questions.length-1){results();return;}
    current++;renderQuestion();
  });
  $('previous').addEventListener('click',()=>{if(current>0){current--;renderQuestion();}});
  $('review-link').addEventListener('click',review);
  $('review-list').addEventListener('click',event=>{const button=event.target.closest('[data-index]');if(!button)return;current=Number(button.dataset.index);returnToReview=true;renderQuestion();});
  $('review-back').addEventListener('click',()=>{returnToReview=false;renderQuestion();});
  $('review-finish').addEventListener('click',results);
  $('edit').addEventListener('click',review);
  $('type-picker').addEventListener('click', event => {
    const button = event.target.closest('[data-type]');
    if (!button) return;
    previewType(button.dataset.type);
    $('type-preview').focus({preventScroll:true});
    $('type-preview').scrollIntoView({block:'start',behavior:'instant'});
  });
  $('nearby-types').addEventListener('click',event=>{const button=event.target.closest('[data-type]');if(!button)return;document.querySelector('.explore').open=true;previewType(button.dataset.type);$('type-preview').focus({preventScroll:true});$('type-preview').scrollIntoView({block:'start',behavior:'instant'});});
  $('download').addEventListener('click',()=>{const blob=new Blob(['\ufeff'+resultText()],{type:'text/plain;charset=utf-8'});const url=URL.createObjectURL(blob);const link=document.createElement('a');link.href=url;link.download=`16-types-${result.code}.txt`;document.body.appendChild(link);link.click();link.remove();setTimeout(()=>URL.revokeObjectURL(url),1000);toast('הסיכום מוכן להורדה');});
  $('copy').addEventListener('click',async()=>{try{await navigator.clipboard.writeText(resultText());toast('הסיכום הועתק');}catch{toast('ההעתקה אינה זמינה בדפדפן הזה. אפשר לשמור את התוצאה כקובץ');}});
  $('print').addEventListener('click',()=>window.print());
  $('fresh').addEventListener('click',()=>askReset(true));
  $('restart').addEventListener('click',()=>askReset(true));
  $('erase').addEventListener('click',()=>askReset(false));
  $('cancel-reset').addEventListener('click',()=>$('reset-dialog').close());
  $('confirm-reset').addEventListener('click',()=>{
    let removed=true;
    try{localStorage.removeItem(key);}catch{removed=false;storageFailure();}
    answers=Array(questions.length).fill(null);current=0;result=null;returnToReview=false;
    $('reset-dialog').close();
    if(resetStartsQuiz)start();else{welcome();$('start').focus();}
    toast(removed?'התשובות הקודמות נמחקו':'התשובות אופסו בדף. מחיקת האחסון חסומה; אפשר לנקות את נתוני האתר בהגדרות הדפדפן');
  });
  $('about-toggle').addEventListener('click',()=>{const open=$('method').hidden;$('method').hidden=!open;$('about-toggle').setAttribute('aria-expanded',String(open));});
  load(); welcome();
})();
</script>
</body>
</html>
"; diff --git a/assets/downloads/the_enneagram.js b/assets/downloads/the_enneagram.js index f0e67be..addad31 100644 --- a/assets/downloads/the_enneagram.js +++ b/assets/downloads/the_enneagram.js @@ -1,3 +1,3 @@ /* Generated by build.py; loaded only for local-file downloads. */ window.NHLocalDownloads = window.NHLocalDownloads || Object.create(null); -window.NHLocalDownloads["the_enneagram"] = "<!DOCTYPE html>
<html lang="he" dir="rtl">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="description" content="מבחן אניאגרמה בעברית: 93 שאלות להיכרות עם תשעת הטיפוסים, הכנפיים ושלושת האינסטינקטים. עם שמירת התקדמות ודוח אישי להורדה.">
  <meta name="theme-color" content="#f5f5fa">
  <title>מבחן אניאגרמה | קצת יותר קרוב לעצמך</title>
  <link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 40 40'%3E%3Crect width='40' height='40' rx='10' fill='%235443a8'/%3E%3Ccircle cx='20' cy='20' r='13' stroke='%23e3f0af' fill='none' stroke-width='2'/%3E%3Cpath d='M20 7 31 27H9Z' stroke='%23e3f0af' fill='none' stroke-width='2'/%3E%3C/svg%3E">
  <style>/* Embedded Assistant font license:
Copyright 2020 The Assistant Project Authors (https://github.com/hafontia/Assistant).
Copyright 2010 The Source Sans Pro Authors (https://github.com/adobe-fonts/source-sans-pro), with Reserved Font Name 'Source'.
Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries.

This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at:
http://scripts.sil.org/OFL


-----------------------------------------------------------
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------

PREAMBLE
The goals of the Open Font License (OFL) are to stimulate worldwide
development of collaborative font projects, to support the font creation
efforts of academic and linguistic communities, and to provide a free and
open framework in which fonts may be shared and improved in partnership
with others.

The OFL allows the licensed fonts to be used, studied, modified and
redistributed freely as long as they are not sold by themselves. The
fonts, including any derivative works, can be bundled, embedded,
redistributed and/or sold with any software provided that any reserved
names are not used by derivative works. The fonts and derivatives,
however, cannot be released under any other type of license. The
requirement for fonts to remain under this license does not apply
to any document created using the fonts or their derivatives.

DEFINITIONS
"Font Software" refers to the set of files released by the Copyright
Holder(s) under this license and clearly marked as such. This may
include source files, build scripts and documentation.

"Reserved Font Name" refers to any names specified as such after the
copyright statement(s).

"Original Version" refers to the collection of Font Software components as
distributed by the Copyright Holder(s).

"Modified Version" refers to any derivative made by adding to, deleting,
or substituting -- in part or in whole -- any of the components of the
Original Version, by changing formats or by porting the Font Software to a
new environment.

"Author" refers to any designer, engineer, programmer, technical
writer or other person who contributed to the Font Software.

PERMISSION & CONDITIONS
Permission is hereby granted, free of charge, to any person obtaining
a copy of the Font Software, to use, study, copy, merge, embed, modify,
redistribute, and sell modified and unmodified copies of the Font
Software, subject to the following conditions:

1) Neither the Font Software nor any of its individual components,
in Original or Modified Versions, may be sold by itself.

2) Original or Modified Versions of the Font Software may be bundled,
redistributed and/or sold with any software, provided that each copy
contains the above copyright notice and this license. These can be
included either as stand-alone text files, human-readable headers or
in the appropriate machine-readable metadata fields within text or
binary files as long as those fields can be easily viewed by the user.

3) No Modified Version of the Font Software may use the Reserved Font
Name(s) unless explicit written permission is granted by the corresponding
Copyright Holder. This restriction only applies to the primary font name as
presented to the users.

4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
Software shall not be used to promote, endorse or advertise any
Modified Version, except to acknowledge the contribution(s) of the
Copyright Holder(s) and the Author(s) or with their explicit written
permission.

5) The Font Software, modified or unmodified, in part or in whole,
must be distributed entirely under this license, and must not be
distributed under any other license. The requirement for fonts to
remain under this license does not apply to any document created
using the Font Software.

TERMINATION
This license becomes null and void if any of the above conditions are
not met.

DISCLAIMER
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
OTHER DEALINGS IN THE FONT SOFTWARE.
*/
@font-face{font-family:Assistant;src:url('data:font/ttf;base64,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') format('truetype');font-weight:200 800;font-display:swap}
:root{color-scheme:light;--paper:#f5f5fa;--surface:#fff;--ink:#29263d;--muted:#625e75;--line:#d4d1df;--accent:#5443a8;--on-accent:#fff;--soft:#ebe7fa;--map:#e5eecb;--map-ink:#35462c;--mint:#e5f0ed;--danger:#ab3042;--radius:16px;--ease:cubic-bezier(.16,1,.3,1)}
:root[data-theme=dark]{color-scheme:dark;--paper:#1c1b27;--surface:#282633;--ink:#f1effa;--muted:#bfb9d0;--line:#504b61;--accent:#b9a6ff;--on-accent:#211741;--soft:#373048;--map:#303d28;--map-ink:#e1eebe;--mint:#283d38;--danger:#ffb0b9}
*{box-sizing:border-box}body{margin:0;background:var(--paper);color:var(--ink);font:18px/1.65 Assistant,'Segoe UI',Arial,sans-serif}button,input{font:inherit}button,a,label,input{touch-action:manipulation}button{cursor:pointer}button,a{-webkit-tap-highlight-color:transparent}button{color:inherit}a{color:var(--accent);text-underline-offset:4px}p,h1,h2,h3{margin:0}h1,h2,h3{line-height:1.2;text-wrap:balance}h1{font-size:clamp(38px,4.5vw,62px);font-weight:800;letter-spacing:-.035em}h2{font-size:28px;font-weight:750}h3{font-size:23px;font-weight:700}p+p{margin-block-start:12px}[hidden]{display:none!important}:focus-visible{outline:3px solid var(--accent);outline-offset:5px}button:disabled{cursor:not-allowed;opacity:.42}svg{display:block}fieldset{border:0;padding:0;margin:0;min-inline-size:0}legend{padding:0}button{border:0}main{max-width:1160px;margin:auto;padding:0 34px;outline:none}.site-header{max-width:1228px;padding:25px 34px;margin:auto;display:flex;align-items:center;justify-content:space-between;gap:20px}.brand{display:flex;gap:12px;align-items:center;text-decoration:none;color:var(--ink);font-size:25px;font-weight:800;line-height:1.15}.brand svg{fill:none;stroke:var(--accent);stroke-width:1.6}.brand-note{display:block;font-size:13px;font-weight:500;color:var(--muted);margin-block-start:5px}.header-actions{display:flex;gap:20px;align-items:center}.icon-btn{background:var(--surface);border:1px solid var(--line);width:42px;height:42px;border-radius:50%;display:grid;place-items:center}.icon-btn svg{fill:none;stroke:currentColor;stroke-width:1.7}.text-btn{background:none;padding:9px 0;color:var(--accent);font-weight:700;min-height:44px;line-height:1.35;text-decoration:underline;text-decoration-color:transparent;text-underline-offset:5px}.text-btn:hover{text-decoration-color:currentColor}.button{display:inline-flex;justify-content:center;align-items:center;gap:25px;min-height:50px;padding:11px 23px;font-weight:750;border-radius:9px;transition:background .15s,transform .15s var(--ease);line-height:1.4}.button:hover:not(:disabled){transform:translateY(-2px)}.primary{background:var(--accent);color:var(--on-accent)}.secondary{background:var(--surface);border:1px solid var(--line)}.large{min-height:58px;font-size:21px;padding-inline:28px}.small{font-size:14px;line-height:1.55}.muted{color:var(--muted)}.skip-link{position:fixed;top:-70px;right:16px;z-index:20;background:var(--surface);padding:12px}.skip-link:focus{top:12px}.intro-grid{display:grid;grid-template-columns:1.03fr 1fr;gap:64px;align-items:center;padding:53px 0 44px}.intro-copy h1 span{color:var(--accent)}.lead{font-size:21px;line-height:1.6;max-width:40ch;margin-top:25px}.quiz-facts{display:flex;flex-wrap:wrap;gap:0;margin:26px 0 25px;font-size:16px;font-weight:650}.quiz-facts span+span{border-inline-start:1px solid var(--line);margin-inline-start:15px;padding-inline-start:15px}.intro-note{color:var(--muted);margin-top:17px;max-width:41ch}.map-panel{background:var(--map);color:var(--map-ink);border-radius:26px;padding:23px 26px 24px;align-self:stretch;display:flex;flex-direction:column;justify-content:center}.map-caption{display:flex;justify-content:space-between;align-items:center;font-size:17px;font-weight:650}.map-caption>span:last-child{font-size:28px}.wheel{position:relative;aspect-ratio:1;max-width:375px;width:100%;margin:8px auto}.wheel>svg{width:100%;height:100%;position:absolute;inset:0;overflow:visible}.wheel-node{position:absolute;transform:translate(-50%,-50%);width:45px;height:45px;padding:0;border-radius:50%;font-size:21px;line-height:1;font-weight:750;background:var(--surface);color:var(--ink);border:1px solid transparent;transition:background .2s,color .2s,scale .2s var(--ease)}.wheel-node:hover,.wheel-node[aria-pressed=true]{background:var(--accent);color:var(--on-accent);scale:1.1}.wheel-center{position:absolute;inset:36% 22%;display:flex;flex-direction:column;justify-content:center;text-align:center;pointer-events:none}.wheel-center strong{font-size:27px;line-height:1.2}.wheel-center span{font-size:14px;margin-top:6px}.map-explainer{min-height:95px;border-top:1px solid color-mix(in srgb,var(--map-ink) 25%,transparent);padding-top:18px}.map-explainer strong{font-size:21px}.map-explainer p{font-size:16px;line-height:1.5;margin-top:6px}.intro-bottom{display:grid;grid-template-columns:1fr 1fr;gap:64px;border-top:1px solid var(--line);padding-top:29px;margin-bottom:24px}.intro-bottom h2{font-size:22px;margin-bottom:10px}.intro-bottom p{font-size:17px;color:var(--muted);max-width:53ch}.save-choice{display:flex;align-items:center;gap:10px;font-size:16px;cursor:pointer;min-height:44px}.save-choice input{accent-color:var(--accent);width:19px;height:19px}.resume-box{margin-top:21px;padding:13px 17px;background:var(--soft);border-radius:10px;font-size:16px}.resume-box .text-btn{padding-bottom:1px}.site-footer{max-width:1160px;margin:45px auto 0;padding:23px 34px;border-top:1px solid var(--line);display:flex;justify-content:space-between;gap:20px;color:var(--muted);font-size:13px}.quiz-layout{display:grid;grid-template-columns:230px 1fr;gap:75px;padding:50px 0;min-height:630px}.journey{border-inline-end:1px solid var(--line);padding-inline-end:30px}.journey h2{font-size:31px}.journey>p{font-size:16px;color:var(--muted);margin:16px 0 27px}.journey ol{list-style:none;padding:0;margin:0 0 20px}.journey li{display:flex;align-items:center;gap:13px;padding:12px 0;font-size:16px;color:var(--muted)}.journey li span{display:grid;place-items:center;width:29px;height:29px;border-radius:50%;border:1px solid var(--line);font-size:13px}.journey li[aria-current=step]{color:var(--accent);font-weight:750}.journey li[aria-current=step] span{background:var(--accent);color:var(--on-accent);border-color:transparent}.journey li.done span{background:var(--soft);border-color:transparent}.journey #save-status{margin:6px 0}.progress-caption{display:flex;justify-content:space-between;gap:15px;font-size:15px;color:var(--muted);margin-bottom:14px}.progress-caption>span:first-child{color:var(--accent);font-weight:750}progress{appearance:none;border:0;width:100%;height:6px;display:block;background:var(--line);border-radius:3px;overflow:hidden}progress::-webkit-progress-bar{background:var(--line)}progress::-webkit-progress-value{background:var(--accent)}progress::-moz-progress-bar{background:var(--accent)}#answers-form{margin-top:49px}#question-text{font-size:clamp(27px,2.9vw,37px);font-weight:700;line-height:1.42;letter-spacing:-.012em;min-height:157px;max-width:29ch;outline:none}#answer-hint{font-size:16px;margin:14px 0 22px}.answers{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:10px}.answer-label{position:relative;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:15px;min-height:121px;padding:15px 8px;border:1px solid var(--line);border-radius:12px;background:var(--surface);cursor:pointer;transition:background .15s,border-color .15s;line-height:1.35;text-align:center;font-size:16px;font-weight:600}.answer-label:hover{border-color:var(--accent);background:var(--soft)}.answer-label:has(input:checked){border:2px solid var(--accent);padding:14px 7px;background:var(--soft);color:var(--accent)}.answer-label:has(input:focus-visible){outline:3px solid var(--accent);outline-offset:4px}.answer-label input{position:absolute;opacity:0;width:1px;height:1px}.answer-dot{width:25px;height:25px;border:1.5px solid var(--muted);border-radius:50%;display:grid;place-items:center}.answer-label input:checked+.answer-dot{border-color:var(--accent);background:var(--accent)}.answer-label input:checked+.answer-dot:after{content:'';width:9px;height:9px;background:var(--on-accent);border-radius:50%}.quiz-nav{display:flex;justify-content:space-between;margin-top:33px;gap:15px}.keyboard-hint{text-align:center;color:var(--muted);margin-top:22px}.chapter-message{margin-top:25px;font-size:16px;color:var(--accent);text-align:center;min-height:27px}.error{font-size:16px;color:var(--danger);margin-top:15px}.result-heading{display:flex;justify-content:space-between;align-items:center;gap:24px;margin:34px 0 28px}.result-heading h1{font-size:42px}.result-heading p{margin-top:8px;font-size:15px}.result-summary{display:grid;grid-template-columns:200px 1fr;gap:40px;padding:36px;background:var(--soft);border-radius:20px;align-items:center}.result-number{font-size:110px;font-weight:800;line-height:1;text-align:center;color:var(--accent);border-inline-end:1px solid var(--line);padding-inline-end:30px}.result-number small{display:block;font-size:17px;font-weight:600;margin-top:15px;line-height:1.4}.result-summary h2{font-size:34px;margin-bottom:13px}.result-summary p{max-width:66ch}.result-summary .result-caution{font-size:15px;color:var(--muted);margin-top:15px}.result-columns{display:grid;grid-template-columns:1fr 1fr;gap:65px}.result-section{padding-block:37px}.result-section h2{margin-bottom:13px}.result-section>p{font-size:16px}.score-list{margin-top:24px}.score-row{display:grid;grid-template-columns:145px 1fr 40px;align-items:center;gap:13px;margin:13px 0;font-size:16px}.score-track{height:8px;background:var(--line);border-radius:4px;overflow:hidden}.score-fill{height:100%;background:var(--accent);border-radius:4px}.score-value{text-align:end;font-size:15px;font-variant-numeric:tabular-nums}.score-label{white-space:nowrap}.score-label b{display:inline-block;min-width:20px;color:var(--accent)}.score-row.leading .score-label{font-weight:750}.wing-choices{display:grid;grid-template-columns:1fr 1fr;gap:20px;margin-top:22px}.wing-choice{padding-top:15px;border-top:2px solid var(--line)}.wing-choice.suggested{border-color:var(--accent)}.wing-choice h3{font-size:22px}.wing-choice p{font-size:16px;margin-top:8px}.wing-score{font-size:15px;color:var(--muted);margin-top:7px}.result-badge{display:inline-block;background:var(--surface);border-radius:6px;padding:3px 9px;font-size:14px;color:var(--accent);margin-top:10px}.instinct-section{background:var(--mint);padding:30px 34px;border-radius:20px;margin:0 0 4px}.section-intro{display:grid;grid-template-columns:1fr 1.5fr;gap:35px;margin-bottom:25px}.section-intro p{font-size:17px}.instinct-summary{font-size:23px;font-weight:700;margin-bottom:18px}.instinct-grid{display:grid;grid-template-columns:repeat(3,1fr);gap:27px}.instinct-item{border-top:1px solid var(--line);padding-top:20px}.instinct-item h3{font-size:22px;margin-bottom:10px}.instinct-item p{font-size:16px}.instinct-item .score-row{grid-template-columns:1fr 40px}.type-tabs{display:flex;flex-wrap:wrap;gap:9px;margin:22px 0}.type-tab{height:43px;min-width:43px;padding:0 13px;border-radius:8px;background:var(--surface);border:1px solid var(--line);font-weight:700}.type-tab[aria-pressed=true]{background:var(--accent);color:var(--on-accent);border-color:transparent}.type-detail{border-top:1px solid var(--line);padding-top:24px}.type-detail>p{max-width:75ch;margin-top:13px}.detail-grid{display:grid;grid-template-columns:1fr 1fr;gap:30px;margin-top:24px}.detail-grid h3{font-size:19px;margin-bottom:7px}.detail-grid p{font-size:17px}.practice{background:var(--soft);border-radius:12px;padding:20px 25px;margin-top:24px}.practice h3{font-size:21px;margin-bottom:8px}.practice .reflection{font-size:17px;margin-top:10px;font-weight:650}.export-panel{background:var(--surface);border:1px solid var(--line);border-radius:16px;padding:27px 30px}.export-panel h2{font-size:26px;margin-bottom:8px}.export-panel p{font-size:16px;color:var(--muted)}.export-actions{display:flex;flex-wrap:wrap;gap:12px;margin-top:22px}.export-actions .button{font-size:16px;padding-inline:17px}.export-panel #export-status{margin-top:15px}.result-footer{display:flex;justify-content:space-between;gap:20px;margin-top:17px;font-size:16px}.about-panel{border-top:1px solid var(--line);padding:35px 0;margin-top:35px;max-width:80ch}.about-panel h2{margin-bottom:18px}.about-panel p{font-size:17px}.about-panel details{margin-top:15px;border-bottom:1px solid var(--line);padding-bottom:15px}.about-panel summary{font-weight:700;cursor:pointer;padding:10px 0;min-height:44px}.about-panel details p{margin-top:13px}.sources{padding-inline-start:22px;font-size:16px}.sources li{margin-top:9px}.notice{background:var(--soft);padding:15px 20px;margin:20px auto;border-radius:10px;font-size:16px;max-width:75ch}dialog{background:var(--surface);color:var(--ink);border:1px solid var(--line);border-radius:16px;padding:30px;max-width:460px;width:calc(100% - 35px)}dialog::backdrop{background:rgb(20 18 32 / .5)}dialog h2{margin-bottom:15px}dialog p{font-size:17px}.dialog-actions{display:flex;justify-content:flex-end;gap:12px;margin-top:25px}
@media(max-width:900px){.intro-grid{gap:30px}.map-panel{padding-inline:20px}.wheel-node{width:39px;height:39px}.quiz-layout{grid-template-columns:175px 1fr;gap:35px}.journey{padding-inline-end:18px}.journey h2{font-size:26px}.result-columns{gap:30px}.score-row{grid-template-columns:135px 1fr 35px}.result-summary{grid-template-columns:140px 1fr;gap:25px}.result-number{font-size:90px;padding-inline-end:20px}}
@media(max-width:650px){body{font-size:17px}main{padding:0 22px}.site-header{padding:18px 22px}.brand{font-size:22px}.brand-note{font-size:12px}.header-actions{gap:17px;font-size:15px}.intro-grid{grid-template-columns:1fr;padding:27px 0 30px;gap:31px}.intro-copy h1{font-size:43px}.lead{font-size:19px;margin-top:20px}.quiz-facts{margin-block:20px;font-size:15px}.intro-copy .large{width:100%;justify-content:space-between}.intro-note{max-width:none}.map-panel{padding:20px 24px}.wheel{max-width:305px}.wheel-node{width:40px;height:40px}.map-explainer{min-height:92px}.intro-bottom{grid-template-columns:1fr;gap:25px;padding-top:26px}.intro-bottom h2{font-size:23px}.site-footer{padding:22px;margin-top:32px;flex-direction:column;gap:6px}.quiz-layout{display:block;padding:15px 0 20px;min-height:0}.journey{border:0;padding:0;display:flex;justify-content:space-between;align-items:center;gap:12px;margin-bottom:24px}.journey h2,.journey>p,.journey ol{display:none}.journey #save-status{display:block;font-size:12px}.journey .text-btn{font-size:15px}.progress-caption{font-size:14px}#answers-form{margin-top:26px}#question-text{font-size:28px;min-height:0;line-height:1.42;max-width:none}#answer-hint{margin:20px 0 17px;font-size:15px}.answers{grid-template-columns:1fr;gap:9px}.answer-label{min-height:55px;flex-direction:row;justify-content:flex-start;padding:13px 17px;gap:16px;text-align:start;font-size:17px}.answer-label:has(input:checked){padding:12px 16px}.answer-dot{width:22px;height:22px;flex-shrink:0}.quiz-nav{margin-top:23px}.quiz-nav .button{flex:1;min-height:49px}.keyboard-hint{display:none}.chapter-message{font-size:15px;margin-top:20px}.result-heading{margin:24px 0;align-items:flex-start}.result-heading h1{font-size:33px}.result-heading .text-btn{font-size:14px}.result-summary{grid-template-columns:1fr;padding:26px;gap:22px}.result-number{border:0;border-bottom:1px solid var(--line);padding:0 0 18px;text-align:start;font-size:72px;display:flex;align-items:center;gap:20px}.result-number small{font-size:16px;margin:0;max-width:16ch}.result-summary h2{font-size:29px}.result-summary p{font-size:17px}.result-columns{grid-template-columns:1fr;gap:0}.result-section{padding-block:28px}.result-section h2{font-size:25px}.result-columns .result-section+.result-section{border-top:1px solid var(--line)}.score-row{grid-template-columns:135px 1fr 32px;gap:10px;font-size:15px}.instinct-section{padding:25px 23px}.section-intro{display:block}.section-intro h2{font-size:26px;margin-bottom:15px}.instinct-grid{grid-template-columns:1fr;gap:25px}.instinct-summary{font-size:21px}.instinct-item{padding-top:18px}.detail-grid{grid-template-columns:1fr;gap:20px}.export-panel{padding:23px}.export-actions{flex-direction:column;gap:10px}.export-actions .button{width:100%}.result-footer{font-size:15px}.practice{padding:20px}.wing-choices{gap:18px}.wing-choice h3{font-size:20px}}
@media(prefers-reduced-motion:no-preference){.map-panel{animation:reveal-map .7s var(--ease) both}@keyframes reveal-map{from{clip-path:inset(0 0 12% 0 round 26px);transform:translateY(8px)}to{clip-path:inset(0 0 0 0 round 26px);transform:translateY(0)}}}
@media(prefers-reduced-motion:reduce){*,*::before,*::after{animation:none!important;transition:none!important;scroll-behavior:auto!important}}
@media print{:root,:root[data-theme=dark]{color-scheme:light;--paper:white;--surface:white;--ink:#222;--muted:#555;--line:#ccc;--accent:#44377d;--on-accent:white;--soft:#f4f1fa;--mint:#f0f6f3}body{font-size:11pt;background:white}.site-header,.site-footer,.export-panel,.result-footer,.type-tabs,#edit-btn,#about-panel,#notice,.skip-link,dialog{display:none!important}main{max-width:none;padding:0}.result-heading{margin-top:0}.result-heading h1{font-size:27pt}.result-summary{padding:20px;border:1px solid #ddd}.result-summary h2{font-size:22pt}.result-number{font-size:64pt}.result-columns{gap:30px}.result-section{padding-block:22px}.result-section h2,.section-intro h2{font-size:19pt}.instinct-section{padding:22px;border:1px solid #ddd}.score-row{margin:8px 0}.result-summary,.wing-choice,.instinct-item,.practice,.detail-grid>div{break-inside:avoid}.score-track,.score-fill{print-color-adjust:exact;-webkit-print-color-adjust:exact}a{color:inherit}#quiz-screen,#start-screen{display:none!important}@page{size:A4;margin:16mm}}

/* Keep the task surface quiet; explanations live in About. */
.save-choice{margin-top:16px}.map-explainer{min-height:78px}.journey ol{margin-top:24px}#save-status:empty,#export-status:empty{display:none}main{padding-bottom:34px}

.wing-choices:has(>.wing-choice:only-child){grid-template-columns:1fr}

.contrast-options{display:grid;grid-template-columns:1fr 1fr;gap:16px;margin-top:20px}.contrast-options>div{display:flex;align-items:flex-start;gap:12px;background:var(--soft);padding:18px;border-radius:12px}.contrast-options b{color:var(--accent);font-size:23px}.contrast-options p{font-size:19px;line-height:1.55}.paired-question #question-text{min-height:0}.instinct-section .section-intro{display:block}.instinct-section .section-intro h2{max-width:none}@media(max-width:650px){.contrast-options{grid-template-columns:1fr;gap:10px}.contrast-options>div{padding:13px}.contrast-options p{font-size:18px}}
</style>
<!-- catalog metadata:start -->
<link rel="canonical" href="https://tools.ze-kal.top/tools/the_enneagram.html">
<meta property="og:type" content="website">
<meta property="og:locale" content="he_IL">
<meta property="og:title" content="מבחן אניאגרמה | קצת יותר קרוב לעצמך">
<meta property="og:description" content="מבחן אניאגרמה בעברית: 93 שאלות להיכרות עם תשעת הטיפוסים, הכנפיים ושלושת האינסטינקטים. עם שמירת התקדמות ודוח אישי להורדה.">
<meta property="og:url" content="https://tools.ze-kal.top/tools/the_enneagram.html">
<meta property="og:image" content="https://tools.ze-kal.top/assets/social-card.png">
<meta name="twitter:card" content="summary_large_image">
<script type="application/ld+json">{"@context": "https://schema.org", "@type": "WebPage", "url": "https://tools.ze-kal.top/tools/the_enneagram.html", "name": "מבחן אניאגרמה | קצת יותר קרוב לעצמך", "description": "מבחן אניאגרמה בעברית: 93 שאלות להיכרות עם תשעת הטיפוסים, הכנפיים ושלושת האינסטינקטים. עם שמירת התקדמות ודוח אישי להורדה.", "inLanguage": "he"}</script>
<!-- catalog metadata:end -->
</head>
<body>
  <a class="skip-link" href="#main">דילוג לתוכן</a>
  <header class="site-header">
    <a class="brand" href="#" id="home-link" aria-label="מבחן אניאגרמה, למסך הפתיחה">
      <svg viewBox="0 0 40 40" width="36" height="36" aria-hidden="true"><circle cx="20" cy="20" r="17"/><path d="M20 3 35 28H5ZM31 7 37 20 9 33 9 7 37 20 31 33Z"/></svg>
      <span>אניאגרמה</span>
    </a>
    <div class="header-actions"><button id="about-btn" class="text-btn">על המבחן</button><button id="theme-btn" class="icon-btn" aria-label="מעבר לתצוגה כהה" title="שינוי תצוגה"><svg viewBox="0 0 24 24" width="21" height="21" aria-hidden="true"><path d="M20 15.4A8.5 8.5 0 0 1 8.6 4 8.5 8.5 0 1 0 20 15.4Z"/></svg></button></div>
  </header>
  <main id="main" tabindex="-1">
    <section id="start-screen" class="screen" aria-labelledby="start-title">
      <div class="intro-grid">
        <div class="intro-copy">
          <h1 id="start-title" tabindex="-1">יש יותר מדרך אחת<br>להיות <span>עצמך.</span></h1>
          <p class="lead">מה מניע אותך? מגלים את הטיפוס, הכנפיים והאינסטינקטים במפה אישית אחת.</p>
          <div class="quiz-facts"><span>93 שאלות</span><span>כ-12 דקות</span><span>בקצב שלך</span></div>
          <button id="start-btn" class="button primary large">מתחילים להכיר <span aria-hidden="true">←</span></button>
          <label class="save-choice"><input type="checkbox" id="auto-save" checked> שמירת התקדמות במכשיר</label>
          <div id="resume-box" class="resume-box" hidden><p id="resume-text"></p><button id="resume-btn" class="text-btn">להמשיך מהמקום שעצרתי</button></div>
          <div id="saved-box" class="resume-box" hidden><p id="saved-text">יש במכשיר הזה תוצאה שמורה</p><button id="saved-btn" class="text-btn">לפתוח את התוצאה</button></div>
        </div>
        <div class="map-panel">
          <div id="intro-wheel" class="wheel"></div>
          <div class="map-explainer"><strong id="type-preview-title">מגלים את תשעת הטיפוסים</strong><p id="type-preview-text"></p></div>
        </div>
      </div>
    </section>

    <section id="quiz-screen" class="screen" aria-labelledby="question-text" hidden>
      <div class="quiz-layout">
        <aside class="journey" aria-label="התקדמות במבחן"><h2>הדרך שלך</h2><ol id="chapter-list"></ol><button id="pause-btn" class="text-btn">שמירה ויציאה</button><p id="save-status" class="small" role="status"></p></aside>
        <div class="question-area">
          <div class="progress-caption"><span id="chapter-name"></span><span id="question-counter"></span></div>
          <progress id="progress" value="0" max="93" aria-label="מספר השאלות שנענו"></progress>
          <form id="answers-form">
            <fieldset><legend id="question-text" tabindex="-1"></legend><div id="contrast-options" class="contrast-options" hidden></div><p id="answer-hint" class="muted">עד כמה זה מתאר אותך?</p><div id="answers-container" class="answers" aria-describedby="answer-hint"></div></fieldset>
            <p id="error-msg" class="error" role="alert" hidden>כדי להמשיך, צריך לבחור תשובה אחת.</p>
            <div class="quiz-nav"><button type="button" id="prev-btn" class="button secondary">→ הקודם</button><button type="submit" id="next-btn" class="button primary">הבא ←</button></div>
          </form>
        </div>
      </div>
    </section>

    <section id="results-screen" class="screen" aria-labelledby="results-title" hidden>
      <div class="result-heading"><div><h1 id="results-title" tabindex="-1">המפה האישית שלך</h1><p id="result-date" class="muted"></p></div><button id="edit-btn" class="text-btn">חזרה לתשובות</button></div>
      <div id="result-summary" class="result-summary"></div>
      <div class="result-columns"><section class="result-section" aria-labelledby="scores-title"><h2 id="scores-title">הסגנונות בתשובות שלך</h2><div id="type-scores" class="score-list"></div></section><section class="result-section" aria-labelledby="wing-heading"><h2 id="wing-heading">הגוונים שלצד הטיפוס</h2><div id="wing-result"></div></section></div>
      <section class="instinct-section" aria-labelledby="instinct-heading"><div class="section-intro"><h2 id="instinct-heading">לאן תשומת הלב הולכת?</h2></div><div id="instinct-result"></div></section>
      <section class="result-section" aria-labelledby="explore-heading"><h2 id="explore-heading">להכיר את תשעת הטיפוסים</h2><div id="explore-types" class="type-tabs" role="group" aria-label="בחירת טיפוס לקריאה"></div><div id="type-detail" class="type-detail" aria-live="polite"></div></section>
      <div class="export-panel"><div><h2>לקחת את התובנות איתך</h2><p>דוח אישי לקריאה חוזרת, לשמירה או להדפסה.</p></div><div class="export-actions"><button id="save-result-btn" class="button primary">שמירת התוצאה במכשיר</button><button id="download-btn" class="button secondary">הורדת דוח אישי</button><button id="print-btn" class="button secondary">הדפסה / PDF</button><button id="json-btn" class="text-btn">הורדת נתונים (JSON)</button></div><p id="export-status" class="small" role="status"></p></div>
      <div class="result-footer"><button id="restart-btn" class="text-btn">להתחיל מבחן חדש</button><button id="clear-btn" class="text-btn">מחיקת הנתונים מהמכשיר</button></div>
    </section>

    <section id="about-panel" class="about-panel" hidden aria-labelledby="about-title"><h2 id="about-title" tabindex="-1">על המבחן והשיטה</h2><p>זהו כלי להתבוננות עצמית, לא אבחון פסיכולוגי. כדאי לענות לפי הדפוסים שלך לאורך זמן. אפשר לבחור תשובה עם המקשים 1 עד 5 ולהמשיך עם Enter.</p><details><summary>שמירה ופרטיות</summary><p>התשובות מעובדות בדפדפן ואינן נשלחות לשרת. השמירה האוטומטית נעשית במכשיר הזה, ואפשר לבטל אותה במסך הפתיחה. במכשיר משותף כדאי לבטל שמירה או למחוק את הנתונים בסיום. קובצי דוח שהורדו אינם נמחקים במחיקת נתוני האתר.</p></details><p>האניאגרמה מציעה תשעה דפוסי מוטיבציה. לכל טיפוס שני שכנים במעגל, הנקראים כנפיים. כנף היא השפעה אפשרית של שכן, ולא בהכרח הטיפוס שבמקום השני בתוצאה.</p><p>השאלון כולל 54 אמירות על הטיפוסים, שש לכל טיפוס, 21 אמירות על אינסטינקטים ו-18 השוואות בין מניעים. כל טיפוס משתתף בארבע השוואות, שתיים מול כל שכן. השאלות נכתבו מחדש והורחבו בעברית מקורית. זה אינו שאלון RHETI או IVQ ואינו תרגום או גרסה רשמית שלהם.</p><p>שלושת תחומי הקשב הם שימור עצמי (SP), חברתי (SO), ומשיכה ועוצמה (SX). המינוח והפרשנות משתנים בין אסכולות. כאן לא מסיקים חברותיות מהאינסטינקט החברתי, ולא מסיקים את האינסטינקט מהטיפוס או מכישורים בין אישיים.</p><details><summary>איך מחושב הציון?</summary><p>כל תשובה מדורגת מ-1 עד 5. בכל סולם יש גם אמירה בכיוון ההפוך, שהניקוד שלה מתהפך. ממוצע התשובות מומר לסולם 0 עד 100. לכל סולם משקל עצמאי ושווה בין השאלות שבו.</p><p>הטיפוס המוביל נבחר לפי ציוני הסגנון. ההשוואות מחדדות בין מועמדים שמרוחקים עד 15 נקודות מהמוביל: שתי העדפות עקביות של שכן מועמד, בממוצע של 75 לפחות, מסירות את הטיפוס שהפסיד מהבחירה הסופית. מבין הנותרים נבחר בעל הציון המקורי הגבוה. תשובות ניטרליות או סותרות אינן חוסמות תוצאה; אם כל המועמדים נפסלו בהשוואות, חוזרים למוביל המקורי. בתיקו מלא הסדר מספרי. כנף נבחנת רק בין שני השכנים, ודורשת ציון של 62.5 לפחות ולפחות 75% מציון הטיפוס. השכן החזק יותר מוצג ככנף מובילה גם כשהפער קטן. בתיקו בין השכנים אין כנף מובילה. חישוב האינסטינקטים נותר נפרד וללא שינוי.</p><p>אלה כללי תצוגה זהירים שנבחרו עבור הכלי, לא ספים שנקבעו במחקר פסיכומטרי. שאלון זה לא עבר תיקוף על מדגם אנושי. מענה אחיד לכל השאלות נשאר ללא טיפוס מוביל.</p></details><details><summary>מה המחקר אומר, ועל מה התבססנו?</summary><p>סקירה שיטתית של 104 מדגמים מצאה ראיות מעורבות למהימנות ולתוקף האניאגרמה, ומעט מחקר שתומך בהיבטים כמו כנפיים. השימוש כאן הוא לסקרנות ולהתבוננות, ולא לקבלת החלטות טיפוליות או תעסוקתיות.</p><ul class="sources"><li><a href="https://www.enneagraminstitute.com/how-the-enneagram-system-works/" target="_blank" rel="noopener noreferrer">Enneagram Institute: מבנה המודל, כנפיים ואינסטינקטים</a></li><li><a href="https://www.enneagraminstitute.com/type-descriptions/" target="_blank" rel="noopener noreferrer">Enneagram Institute: תשעת הטיפוסים</a></li><li><a href="https://pubmed.ncbi.nlm.nih.gov/33332604/" target="_blank" rel="noopener noreferrer">Hook ועמיתיו, 2021: סקירת המחקר</a></li></ul><p>ניסוח השאלות נבדק מול <a href="https://www.pewresearch.org/writing-survey-questions/" target="_blank" rel="noopener noreferrer">הנחיות Pew</a> ו<a href="https://www.frontiersin.org/journals/public-health/articles/10.3389/fpubh.2018.00149/full" target="_blank" rel="noopener noreferrer">סקירת שיטות לפיתוח שאלונים</a>. זמן המילוי הוא הערכה.</p><p class="small">נבדק בספטמבר 2026. סימולציות של סוכני AI משמשות לבדיקת ניסוח ולוגיקה בלבד ואינן ראיה לתוקף פסיכולוגי.</p></details><button id="close-about-btn" class="text-btn">סגירת ההסבר</button></section>
    <p id="notice" class="notice" role="status" hidden></p>
  </main>
  <dialog id="confirm-dialog" aria-labelledby="confirm-title" aria-describedby="confirm-description"><h2 id="confirm-title">להתחיל מחדש?</h2><p id="confirm-description"></p><div class="dialog-actions"><button id="confirm-cancel" class="button secondary">ביטול</button><button id="confirm-ok" class="button primary">אישור</button></div></dialog>
  <noscript><p class="notice">כדי לענות על המבחן ולחשב תוצאות, יש להפעיל JavaScript בדפדפן.</p></noscript>
  <script id="enneagram-engine">/* Original Hebrew reflection questionnaire. No third-party test items are reproduced. */
(function (root) {
  'use strict';
  const VERSION = '3.1.0';
  const CORE_WINDOW = 15;
  const PAIR_MIN = 75;
  const WING_MIN = 62.5;
  const WING_RATIO = 0.75;
  const WING_GAP = 0;
  const INSTINCT_GAP = 8;
  const typeItems = {
    1: [
      'גם כשאיש לא ידע, חשוב לי לפעול לפי מה שבעיניי נכון וראוי.',
      'כשמשהו נעשה באופן לקוי, קשה לי להניח לו בלי לנסות לתקן.',
      'אחרי טעות קטנה, הביקורת הפנימית שלי ממשיכה לעבוד גם כשהסביבה כבר המשיכה הלאה.',
      'במשימה משותפת, חשוב לי שהדרך תהיה ראויה ויסודית, גם אם קיצור דרך ייתן תוצאה מרשימה.',
      'כשמישהו מתנער מאחריות, מתעורר בי מתח שקשה לי לשחרר.',
      'קל לי לקבל עבודה לא מושלמת בלי להרגיש צורך לתקן אותה.'
    ],
    2: [
      'כשאני עוזר למישהו, התחושה שצריכים אותי מחזקת את תחושת הערך שלי.',
      'אני מבחין בצרכים של אחרים מהר יותר מכפי שאני נותן מקום לצרכים שלי.',
      'קשה לי לסרב לבקשת עזרה כשאני חושש שהסירוב ירחיק ממני אדם חשוב.',
      'אם נתתי מעצמי ולא שמו לב לכך, אני נפגע יותר ממה שאני מראה.',
      'במערכת יחסים חדשה, אני מנסה להתקרב דרך תמיכה, מחוות ועשייה למען הצד השני.',
      'אני מרגיש אהוב גם כשאיני מועיל לאף אחד, ולא צריך להרוויח קרבה באמצעות נתינה.'
    ],
    3: [
      'כשאני לא עומד ביעד, קשה לי להפריד בין התוצאה לבין הערך שלי כאדם.',
      'אני מתאים את האופן שבו אני מציג את עצמי למה שהסביבה מחשיבה להצלחה.',
      'חשוב לי שאנשים יראו בי אדם מצליח, גם כשאני לא אומר זאת בקול.',
      'בפרויקט חדש, אני מחפש במהירות מה יביא לתוצאה שאפשר להציג.',
      'גם בזמן פנוי, אני מתקשה לנוח אם אין לי תחושה שהתקדמתי או השגתי משהו.',
      'גם בתקופה ללא הישגים, תחושת הערך שלי נשארת יציבה למדי.'
    ],
    4: [
      'חשוב לי שהבחירות שלי יבטאו מי אני, גם אם הן שונות ממה שמקובל סביבי.',
      'כשחוויה מרגישה שטחית או לא אותנטית, קשה לי להתחבר אליה גם אם היא נעימה.',
      'אני חוזר לרגשות שלי כדי להבין מה הם מגלים על הזהות שלי.',
      'כשאני משווה את חיי לחיי אחרים, אני שם לב במיוחד לדבר המשמעותי שחסר לי.',
      'כשלא מבינים את העולם הפנימי שלי, מתעוררת בי תחושה עמוקה שאני שונה.',
      'לא מפריע לי במיוחד להיות דומה לאחרים; אין לי צורך שהבחירות שלי יבטאו זהות ייחודית.'
    ],
    5: [
      'לפני שאני נרתם לדבר חדש, אני בודק כמה זמן ואנרגיה יישארו לי לעצמי.',
      'אני דוחה לפעמים השתתפות עד שארגיש שיש לי מספיק ידע כדי להתמודד בכוחות עצמי.',
      'כשדורשים ממני הרבה זמינות, אני מצמצם קשר כדי לשמור על המשאבים שלי.',
      'מול מצב טעון, התגובה הראשונה שלי היא להתרחק מעט ולנסות להבין אותו.',
      'אני מעדיף להבין נושא לעומק בעצמי לפני שאחשוף לאחרים את מה שאני חושב עליו.',
      'קל לי להיכנס לעשייה בלי להבין הרבה מראש, גם אם אצטרך להיעזר באחרים לאורך הדרך.'
    ],
    6: [
      'לפני החלטה חשובה, אני מחפש מה עלול להשתבש ולמי אפשר לפנות אם זה יקרה.',
      'חשוב לי לבדוק אם אפשר לסמוך על אדם, גם כשהוא משדר ביטחון וסמכות.',
      'גם אחרי שקיבלתי עצה טובה, אני עשוי להמשיך לבדוק אם היא באמת אמינה.',
      'אני מכין חלופות מראש כי קשה לי להישען על ההנחה שהכול יסתדר.',
      'כשאני חושש ממשהו, אני מרגיש צורך לבדוק אותו היטב או להתעמת איתו כדי לדעת היכן אני עומד.',
      'לאחר החלטה בתנאי אי ודאות, בדרך כלל קל לי להפסיק לבדוק אם פספסתי סכנה.'
    ],
    7: [
      'הידיעה שיש עוד אפשרויות וחוויות בהמשך נותנת לי אנרגיה גם ביום קשה.',
      'כשעולה בי תחושה לא נעימה, אני מחפש מהר עיסוק או רעיון שיחזיר לי מצב רוח טוב.',
      'כשהמציאות מכבידה, המחשבות שלי נודדות לתוכניות מרגשות יותר.',
      'אחרי אכזבה, אני ממהר למצוא את ההזדמנות החדשה שבה כדי לא להישאר עם הכאב.',
      'קשה לי לוותר על אפשרויות מעניינות, ולכן אני מתחייב לפעמים ליותר ממה שאוכל להספיק.',
      'קל לי להישאר עם אכזבה או שעמום בלי לחפש במהירות משהו נעים יותר להתמקד בו.'
    ],
    8: [
      'כשמנסים להכתיב לי איך לפעול, אני מרגיש צורך ברור להחזיר לעצמי שליטה.',
      'אני מעדיף לומר אמת לא נוחה ישירות מאשר להרגיש שמנסים לנהל אותי בעקיפין.',
      'כשמישהו מנצל אדם קרוב אליי, אני נכנס לעימות כדי להגן עליו גם במחיר אישי.',
      'קשה לי להראות תלות או פגיעות, כי אני חושש שהדבר ייתן לאחרים כוח עליי.',
      'במצב של חוסר צדק, אני נוטה לתפוס עמדה ולהפעיל כוח כדי לשנות את המצב.',
      'נוח לי שאחרים מחזיקים בשליטה גם בהחלטות שנוגעות לי, בלי צורך לבסס את העצמאות שלי.'
    ],
    9: [
      'אני מוותר לפעמים על דבר שחשוב לי כדי לא להפר את השקט ביני לבין אחרים.',
      'קל לי להבין מה כולם רוצים, אבל קשה לי לזהות מה אני רוצה בעצמי.',
      'אני דוחה שיחה לא נעימה גם כשהדחייה משאירה בעיה לא פתורה.',
      'אני עשוי להסכים כלפי חוץ כדי למנוע מתח, אף שבתוכי יש התנגדות.',
      'כשיש מתח, אני נשאב לפעילות מוכרת ומרגיעה כדי לא לחשוב על מה שמטריד אותי.',
      'אני מבטא רצון שונה משל אחרים בקלות יחסית, גם אם הדבר יוצר מתח בינינו.'
    ]
  };
  const instinctItems = {
    sp: [
      'ביום עמוס, תשומת הלב שלי חוזרת באופן טבעי לשאלה אם אכלתי, נחתי ודאגתי לגוף שלי.',
      'כשאני בוחר מקום לשהות בו, תנאי המחיה והנוחות המעשית תופסים אצלי מקום מרכזי.',
      'אני מקדיש מחשבה קבועה לתקציב, למלאי ולמשאבים שיאפשרו לי להסתדר לאורך זמן.',
      'גם כשהכול רגוע, אני שם לב אם השגרה שלי תומכת בבריאות ובאנרגיה שלי.',
      'בזמן פנוי, אני נמשך לסידור הדברים שיתנו לי בסיס נוח ויציב לימים הבאים.',
      'כשאני נכנס למקום חדש, אני מבחין מהר בתנאים הפיזיים: טמפרטורה, אוכל ומקום לנוח.',
      'ענייני תחזוקה יומיומיים, כמו ארוחות, מנוחה ותקציב, נוטים להישאר מחוץ לתשומת הלב שלי.'
    ],
    so: [
      'בקבוצה חדשה, אני קולט מהר מי קשור למי ומה התפקיד של כל אחד.',
      'חשוב לי להבין כיצד אני משתלב במעגל הרחב יותר, גם כשאיני רוצה להיות במרכז.',
      'אני שם לב לכללים הלא כתובים שקובעים מה מקובל בקבוצה.',
      'התחושה שאני תורם למשהו משותף נותנת לי כיוון ומשמעות.',
      'אני משקיע בשמירה על קשר עם קהילה או מעגל חברתי, גם כשאין צורך מעשי מיידי.',
      'במפגש, תשומת הלב שלי נמשכת לשאלה מי שייך ומי נשאר מחוץ למעגל.',
      'המקום שלי בקבוצות והקשרים ביניהן כמעט שאינם מעסיקים אותי ביומיום.'
    ],
    sx: [
      'אני שם לב במהירות למפגש או לרעיון שמדליקים בי תחושת חיות חזקה.',
      'אני נמשך לחוויות שיש בהן ניצוץ ועוצמה, גם כשאינן מועילות או נוחות במיוחד.',
      'כשנוצר חיבור מסקרן, אני רוצה להעמיק בו ולהקדיש לו תשומת לב מרוכזת.',
      'קשר נעים אך חסר חיות משאיר אותי עם תחושה שחסר בו משהו מרכזי.',
      'אני מזהה במהירות אם יש ביני לבין אדם אחר כימיה שמושכת אותי להיכרות עמוקה יותר.',
      'אני מחפש מפגשים ועיסוקים שיכולים לסחוף אותי ולשנות משהו בי.',
      'תחושת ניצוץ או משיכה עזה כמעט שאינה משפיעה על הבחירה שלי בקשרים ובעיסוקים.'
    ]
  };
  const types = {
    1: {name:'הפרפקציוניסט', aliases:['המחוקק','מתקן העולם'], theme:'לעשות את הדבר הנכון', color:'#a95829', description:'הדפוס הזה מחפש יושרה, דיוק ואחריות. הצורך לפעול כראוי עשוי לעזור לשפר דברים, ולפעמים להפוך לביקורת פנימית שקשה להשקיט.', strength:'יכולת להבחין במה שדורש תיקון ולהשקיע בו בהתמדה.', cost:'המתח בין המצוי לרצוי עלול להשאיר מעט מקום למנוחה ולחמלה.', practice:'לבחור היום משימה אחת ולהחליט מראש מה ייחשב בה טוב מספיק.', reflection:'אם לא הייתי צריך להצדיק את עצמי, מה הייתי מרשה לעצמי עכשיו?'},
    2: {name:'המסייע', aliases:['הנותן','התומך'], theme:'להרגיש אהוב וחשוב', color:'#a34356', description:'הדפוס הזה מחפש קרבה דרך נתינה ותשומת לב לאחרים. לפעמים הצורך להיות נחוץ מקשה לזהות צורך אישי או לבקש משהו במפורש.', strength:'יכולת לזהות מצוקה, להציע עזרה וליצור חום בקשר.', cost:'נתינה ללא בקשה ברורה עלולה להתחלף באכזבה כשלא מקבלים הכרה.', practice:'לבקש היום דבר קטן ישירות, בלי להקדים לו שירות או טובה.', reflection:'מה אני צריך גם אם אף אחד לא צריך ממני דבר?'},
    3: {name:'ההישגי', aliases:['הביצועיסט','המצליחן'], theme:'להרגיש בעל ערך דרך עשייה', color:'#946021', description:'הדפוס הזה מכוון לתוצאות, להתקדמות ולהכרה. הוא יודע להתאים את עצמו למשימה, אך עשוי לקשור את תחושת הערך לאופן שבו ההישגים נראים מבחוץ.', strength:'יכולת להפוך מטרה לעשייה ולהניע תהליך קדימה.', cost:'המרדף אחר התוצאה עלול לדחוק הצידה עייפות, רגשות ורצונות אישיים.', practice:'להקדיש זמן קצר לדבר בעל ערך עבורך שאין לו תוצאה שאפשר להציג.', reflection:'מה הייתי בוחר אילו איש לא היה יודע שהצלחתי?'},
    4: {name:'האינדיבידואליסט', aliases:['הרומנטיקן','הדרמטי'], theme:'לחיות מתוך זהות ומשמעות', color:'#7b4b9c', description:'הדפוס הזה מקשיב לעולם הפנימי ומחפש ביטוי אישי אותנטי. לעיתים תשומת הלב נמשכת למה שחסר, עד שקשה לחוש את מה שכבר נוכח.', strength:'רגישות לגוונים רגשיים ויכולת לתת לחוויה משמעות אישית.', cost:'השוואה לאידיאל או לאחרים עלולה להעמיק תחושת חוסר ושונות.', practice:'לתת שם לרגש הנוכחי, ואז לעשות פעולה קטנה גם בלי לחכות למצב הרוח המתאים.', reflection:'מה בחיים שלי ראוי לתשומת לב גם כשהוא רגיל ופשוט?'},
    5: {name:'החוקר', aliases:['הצופה','המדען'], theme:'להבין ולהיות מסוגל', color:'#3c6195', description:'הדפוס הזה מחפש הבנה, עצמאות ומרחב לעיבוד. כשהדרישות נחוות כמציפות, הוא עשוי להגן על הזמן והאנרגיה באמצעות התרחקות.', strength:'יכולת להעמיק, לזהות מבנים ולחשוב באופן עצמאי.', cost:'ההמתנה למספיק ידע או אנרגיה עלולה לדחות השתתפות והתנסות.', practice:'לשתף רעיון שעדיין אינו מושלם, או להשתתף בצעד קטן לפני שהכול ברור.', reflection:'מה אפשר ללמוד דווקא מתוך מעורבות ולא רק מתוך התבוננות?'},
    6: {name:'הנאמן', aliases:['הספקן'], theme:'למצוא על מה אפשר לסמוך', color:'#287a7c', description:'הדפוס הזה בוחן אמינות, אחריות והיערכות. החיפוש אחר ביטחון עשוי להתבטא בבדיקות ובבקשת תמיכה, ולעיתים דווקא בעימות ישיר עם החשש.', strength:'יכולת לצפות קשיים, לשאול שאלות טובות ולעמוד לצד אחרים.', cost:'בדיקה נוספת ועוד אחת עלולות להרחיק מתחושת הכרעה.', practice:'בהחלטה קטנה, להגדיר מראש כמה מידע מספיק ואז לבחור.', reflection:'איזה חלק מהמצב דורש עוד מידע, ואיזה חלק דורש אמון ביכולת שלי להתמודד?'},
    7: {name:'הנלהב', aliases:['הנהנתן'], theme:'להשאיר מקום לאפשרויות', color:'#907022', description:'הדפוס הזה מחפש חופש, חיות ואפשרויות. הוא עשוי להתרחק מכאב או מתחושת הגבלה באמצעות תוכניות, רעיונות וחוויות חדשות.', strength:'יכולת לראות אפשרויות, לאלתר ולהביא התלהבות.', cost:'המעבר לדבר הבא עלול לבוא על חשבון עומק, השלמה ומפגש עם קושי.', practice:'להישאר עוד כמה דקות במשימה אחת או ברגש לא נעים, בלי לפתוח חלופה חדשה.', reflection:'מה אמצא כאן אם לא אמהר לעבור הלאה?'},
    8: {name:'המאתגר', aliases:['המנהיג','הבוס'], theme:'לשמור על עצמאות והשפעה', color:'#a14739', description:'הדפוס הזה רגיש לשליטה מבחוץ ומחפש יכולת לפעול ולהגן. הוא נוטה לפגוש קושי ישירות, אך עשוי להתקשות לחשוף צורך או פגיעות.', strength:'יכולת לתפוס עמדה, להציב גבול ולהגן על מה שחשוב.', cost:'עוצמה וישירות עלולות להשאיר פחות מקום להקשבה ולסיוע מאחרים.', practice:'לבטא צורך אחד בלי להסתיר אותו מאחורי דרישה, ולהקשיב לפני תגובה.', reflection:'איפה אפשר להישען על מישהו בלי לוותר על העצמאות שלי?'},
    9: {name:'משכין השלום', aliases:['המגשר'], theme:'לשמור על שקט וחיבור', color:'#4c7955', description:'הדפוס הזה מחפש הרמוניה ורואה כמה נקודות מבט. לפעמים הוא שומר על השקט באמצעות דחיית רצונותיו או הימנעות ממתח שדורש פעולה.', strength:'יכולת להקשיב, להכיל מורכבות וליצור מרחב נעים.', cost:'ההסתגלות לסביבה עלולה לטשטש סדרי עדיפויות ורצון אישי.', practice:'לבחור היום העדפה קטנה ולומר אותה בקול לפני שמבררים מה כולם רוצים.', reflection:'מה חשוב לי כאן, גם אם מישהו אחר יעדיף אחרת?'}
  };
  const instincts = {
    sp: {name:'שימור עצמי', code:'SP', description:'תשומת לב לגוף, לאנרגיה, למשאבים ולבסיס המעשי של החיים. זהו תחום קשב, ולא מדד לאנוכיות או לרמת החרדה.', practice:'לשים לב גם לקשר ולמשמעות, לצד הטיפול בבסיס המעשי.'},
    so: {name:'חברתי', code:'SO', description:'תשומת לב לשייכות, לתפקיד בקבוצה ולקשרים בין אנשים. אפשר להיות שקטים ומופנמים ועדיין להיות קשובים מאוד לממד הזה.', practice:'לבדוק מה נכון לך אישית, גם כשברור מה מצופה בקבוצה.'},
    sx: {name:'משיכה ועוצמה', code:'SX', description:'תשומת לב לכימיה, לניצוץ ולחוויות שיוצרות מעורבות עמוקה. זה אינו מדד לחברותיות או ליכולת לקיים קשר זוגי, וקרבה חשובה בכל שלושת האינסטינקטים.', practice:'לתת מקום גם לשגרה ולקשרים שאינם דורשים עוצמה מתמדת.'}
  };
  const wingNotes = {
    '1w9':'השאיפה לתקן עשויה לקבל גוון מתון, סבלני ומגשר, עם רצון לשפר בלי ליצור חיכוך מיותר.',
    '1w2':'השאיפה לתקן עשויה להתבטא במעורבות אישית, בליווי ובעזרה לאנשים מסוימים.',
    '2w1':'הנתינה עשויה לקבל גוון מצפוני ומאופק, עם דגש על אחריות ועל הדרך הראויה לעזור.',
    '2w3':'הנתינה עשויה להשתלב ביוזמה, בהצגת יכולות ובקידום אנשים ומטרות.',
    '3w2':'החתירה להישגים עשויה להיעזר ביצירת קשר, בעידוד אחרים וברצון להיות גם אהוב.',
    '3w4':'החתירה להישגים עשויה לקבל ביטוי אישי ומקורי, עם רצון שהתוצאה תשקף זהות ייחודית.',
    '4w3':'חיפוש הזהות עשוי להשתלב ברצון להוציא את הביטוי האישי לעולם ולקבל עליו הכרה.',
    '4w5':'חיפוש הזהות עשוי לקבל אופי פרטי וחקרני יותר, עם העמקה ברעיונות ובחוויה הפנימית.',
    '5w4':'הצורך להבין עשוי להשתלב בדמיון, ברגישות ובחיפוש אחר משמעות אישית.',
    '5w6':'הצורך להבין עשוי להתמקד בבדיקה שיטתית, באמינות ובפתרון בעיות מעשיות.',
    '6w5':'חיפוש הביטחון עשוי להישען על מחקר עצמאי, על ניתוח ועל שמירת מרחק לצורך בדיקה.',
    '6w7':'חיפוש הביטחון עשוי להשתלב בקלילות, באפשרויות חדשות ובקשר עם אנשים.',
    '7w6':'חיפוש האפשרויות עשוי להשתלב בשיתוף, במחויבות ובתשומת לב למה שיספק תמיכה.',
    '7w8':'חיפוש האפשרויות עשוי לקבל ביטוי ישיר ונחוש יותר, עם דגש על חופש פעולה.',
    '8w7':'העצמאות והישירות עשויות להשתלב בקצב מהיר, ביוזמה ובתיאבון לחוויות חדשות.',
    '8w9':'העצמאות והישירות עשויות לקבל גוון שקט ויציב יותר, עם סבלנות לפני פעולה.',
    '9w8':'השאיפה להרמוניה עשויה להשתלב בעמידה על גבולות ובהגנה על אנשים ועל מרחב אישי.',
    '9w1':'השאיפה להרמוניה עשויה להשתלב במצפוניות, באחריות וברצון לעשות את הדבר הראוי.'
  };
  // Interleave constructs to avoid consecutive blocks that reveal the scoring key.
  const questions = [];
  for (let round = 0; round < 6; round++) {
    for (let step = 0; step < 9; step++) {
      const type = ((step * 4 + round * 2) % 9) + 1;
      questions.push({id:`t${type}-${round+1}`, scale:String(type), reverse:round===5, text:typeItems[type][round]});
      if ([2,5,8].includes(step)) {
        const instinct = ['sp','so','sx'][(Math.floor(step/3)+round)%3];
        questions.push({id:`${instinct}-${round+1}`,scale:instinct,reverse:false,text:instinctItems[instinct][round]});
      }
    }
  }
  ['so','sp','sx'].forEach(key => questions.push({id:`${key}-7`,scale:key,reverse:true,text:instinctItems[key][6]}));
  // Equal exposure: two original comparisons for each adjacent pair, four per type.
  // The second item reverses option order; 3 explicitly leaves the preference open.
  const contrastItems = [
    [1,2,'כשאני שוקל להעיר לאדם קרוב, מה משפיע עליי יותר?','הרצון שהדבר ייעשה בדרך הנכונה.','הרצון לשמור על הקרבה בינינו.'],
    [2,3,'כשאני משקיע הרבה באנשים, מה חסר לי יותר אם אינו חוזר אליי?','התחושה שאני נחוץ ואהוב.','הכרה ביכולת ובהישגים שלי.'],
    [3,4,'דרך פעולה מצליחה אינה מרגישה אישית במיוחד. למה אני נוטה?','לאמץ אותה כדי להגיע לתוצאה טובה.','לחפש דרך שתבטא אותי, גם במחיר של הצלחה פחותה.'],
    [4,5,'כשקשה לי לשתף במה שעובר עליי, מה מעסיק אותי יותר?','החשש שלא יבינו את החוויה האישית שלי.','החשש שהשיחה תדרוש ממני יותר כוחות משיש לי.'],
    [5,6,'לפני משימה לא מוכרת, מה נותן לי יותר ביטחון?','הבנה שתאפשר לי להתמודד בכוחות עצמי.','תוכנית בדוקה שאפשר לסמוך עליה כשמשהו משתבש.'],
    [6,7,'כשעולה דאגה שמכבידה עליי, לאן תשומת הלב שלי פונה?','לבדיקת הסיכון ולמציאת דרך להיערך אליו.','לאפשרות מעודדת שתעזור לי לצאת מהתחושה.'],
    [7,8,'כשמגבילים את חופש הפעולה שלי, מה חשוב לי יותר להשיג?','אפשרויות אחרות שיאפשרו לי להמשיך ליהנות ולהתקדם.','יכולת לקבוע בעצמי, גם אם אצטרך להישאר בעימות.'],
    [8,9,'אדם קרוב דוחף להחלטה שאינה מתאימה לי. למה אני נוטה?','להעמיד גבול ברור, גם אם השיחה תהפוך לעימות.','להרגיע את המצב, גם אם הרצון שלי יידחק בינתיים.'],
    [9,1,'בקבוצה מתגבשת הסכמה שיש בה ליקוי. מה מושך אותי יותר?','לשמור על ההסכמה ועל האווירה הרגועה.','לעצור ולתקן את הליקוי, גם אם זה ייצור מתח.'],
    [2,1,'עזרתי במשימה והדברים לא הסתדרו. מה נשאר איתי יותר?','האכזבה שהעזרה שלי לא חיזקה את הקשר.','התחושה שלא מילאתי את האחריות שלי כראוי.'],
    [3,2,'אחרי תקופה של עשייה מוצלחת, למה אני מייחל יותר?','שיראו מה הצלחתי להשיג.','שארגיש קרוב וחשוב לאנשים שעזרתי להם.'],
    [4,3,'רגש קשה מתעורר באמצע פרויקט חשוב. למה אני נוטה?','לעצור כדי להבין מה הרגש אומר עליי.','לשים אותו בצד כדי להשלים את המשימה.'],
    [5,4,'כשאני חוזר לבד לחוויה מורכבת, מה אני מחפש יותר?','הסבר שייתן לי יכולת להתמודד איתה.','משמעות שתעזור לי להבין מי אני בתוכה.'],
    [6,5,'אחרי שאספתי מידע, מה נוטה לעכב את ההחלטה שלי?','ספק אם המידע והאנשים שמאחוריו אמינים מספיק.','תחושה שעדיין איני מבין מספיק כדי לפעול באופן עצמאי.'],
    [7,6,'לפני התחייבות ארוכה, מה מושך אותי יותר?','להשאיר פתוחות אפשרויות מעניינות שעוד עשויות להגיע.','לבסס מסגרת יציבה שאפשר להישען עליה.'],
    [8,7,'כשנוצר מאבק על הדרך שבה אפעל, למה אני נוטה?','להתעקש שלא יחליטו במקומי.','לחפש מוצא שיפתח עבורי חוויה טובה יותר.'],
    [9,8,'מתח עם אדם קרוב נמשך כמה ימים. מה התגובה הרגילה שלי?','לדחות את ההתנגשות ולקוות שהמתח יירגע.','לשים את הדברים על השולחן כדי להחזיר לעצמי השפעה.'],
    [1,9,'הדרך הפשוטה תסיים ויכוח, אבל אינה נראית לי נכונה. מה גובר אצלי?','הצורך לפעול לפי מה שאני מאמין שראוי.','הרצון להניח לוויכוח ולחזור לשקט.' ]
  ];
  contrastItems.forEach(([a,b,text,left,right],i)=>questions.push({id:`c${i+1}`,kind:'contrast',pair:[a,b],text,options:[left,right]}));
  const scaleKeys = [...Object.keys(types),...Object.keys(instincts)];
  function rank(scores, keys) { return keys.map(key=>({key,score:scores[key]})).sort((a,b)=>b.score-a.score); }
  function getWing(type, scores, primaryClear=true) {
    if (!types[type]) throw new Error('Unknown type');
    const adjacent = [type===1?9:type-1, type===9?1:type+1];
    const ranked = rank(scores, adjacent.map(String));
    const gap = ranked[0].score-ranked[1].score;
    const threshold = Math.max(WING_MIN,(scores[type]||0)*WING_RATIO);
    const eligible = ranked.filter(t=>t.score>=threshold).map(t=>Number(t.key));
    const status = !primaryClear ? 'conditional' : !eligible.length ? 'weak' : gap <= WING_GAP ? 'close' : 'suggested';
    return {adjacent,ranked,gap,threshold,eligible,status,dominant:status==='suggested'?Number(ranked[0].key):null};
  }

  function score(answers) {
    if (!Array.isArray(answers) || answers.length!==questions.length || Array.from(answers).some(v=>!Number.isInteger(v)||v<1||v>5)) {
      throw new Error(`Expected ${questions.length} integer answers between 1 and 5`);
    }
    const totals=Object.fromEntries(scaleKeys.map(k=>[k,0])),counts={...totals};
    const pairGroups={};
    questions.forEach((q,i)=>{
      if(q.kind==='contrast'){
        const [a,b]=q.pair,key=[a,b].sort((x,y)=>x-y).join('-');
        const group=pairGroups[key]||(pairGroups[key]={types:[Math.min(a,b),Math.max(a,b)],votes:[]});
        const firstScore=a===group.types[0]?(5-answers[i])*25:(answers[i]-1)*25;
        group.votes.push(firstScore);return;
      }
      totals[q.scale]+=q.reverse?6-answers[i]:answers[i];counts[q.scale]++;
    });
    const scores=Object.fromEntries(scaleKeys.map(k=>[k,(totals[k]/counts[k]-1)*25]));
    const comparisons=Object.values(pairGroups).map(({types,votes})=>{
      const mean=votes.reduce((a,b)=>a+b,0)/votes.length;
      const dominant=mean>=PAIR_MIN&&votes.every(v=>v>50)?types[0]:mean<=100-PAIR_MIN&&votes.every(v=>v<50)?types[1]:null;
      return {types,scores:{[types[0]]:mean,[types[1]]:100-mean},dominant};
    });
    const beats=(a,b)=>comparisons.some(p=>p.types.includes(a)&&p.types.includes(b)&&p.dominant===a);
    const typeRanking=rank(scores,Object.keys(types)),instinctRanking=rank(scores,Object.keys(instincts));
    const gap=typeRanking[0].score-typeRanking[1].score,uniform=answers.every(v=>v===answers[0]);
    const candidates=typeRanking.filter(t=>typeRanking[0].score-t.score<=CORE_WINDOW).map(t=>Number(t.key));
    // Start with the original ranking. Only clear comparisons between nearby
    // candidates can displace it; neutral, conflicting or distant pairs cannot veto it.
    const remaining=candidates.filter(n=>!candidates.some(other=>other!==n&&beats(other,n)));
    const primaryStatus=uniform?'undifferentiated':'suggested';
    const primary=uniform?null:(remaining[0]??Number(typeRanking[0].key));
    const instinctGap=instinctRanking[0].score-instinctRanking[1].score;
    const instinctStatus=uniform?'undifferentiated':instinctRanking[0].score<50?'weak':instinctGap<INSTINCT_GAP?'close':'suggested';
    const dominantInstinct=instinctStatus==='suggested'?instinctRanking[0].key:null;
    const stackClear=!!dominantInstinct && instinctRanking[1].score-instinctRanking[2].score>=INSTINCT_GAP;
    return {version:VERSION,scores,comparisons,typeRanking,instinctRanking,gap,primaryStatus,primary,candidates,
      wing:primary?getWing(primary,scores):null,instinctStatus,dominantInstinct,stackClear,uniform};
  }
  function validState(value) {
    if (!value || value.version!==VERSION || !Array.isArray(value.answers) || value.answers.length!==questions.length) return false;
    if (Array.from(value.answers).some(v=>v!==null&&(!Number.isInteger(v)||v<1||v>5))) return false;
    if (!Number.isInteger(value.index)||value.index<0||value.index>=questions.length) return false;
    if (!['quiz','results'].includes(value.screen)||typeof value.updatedAt!=='string'||!Number.isFinite(Date.parse(value.updatedAt))) return false;
    return value.screen!=='results'||value.answers.every(v=>v!==null);
  }
  function migrateState(value) {
    if(validState(value))return value;
    if(value?.version==='3.0.0'){
      const migrated={...value,version:VERSION};
      return validState(migrated)?migrated:null;
    }
    if(!value||value.version!=='2.0.0'||!Array.isArray(value.answers)||value.answers.length!==75)return null;
    const migrated={...value,version:VERSION,answers:[...value.answers,...Array(18).fill(null)],screen:'quiz'};
    if(!['quiz','results'].includes(value.screen)||!Number.isInteger(value.index)||value.index<0||value.index>=75)return null;
    if(value.screen==='results'&&value.answers.some(v=>v===null))return null;
    migrated.index=value.screen==='results'?75:value.index;
    return validState(migrated)?migrated:null;
  }
  const api={VERSION,CORE_WINDOW,PAIR_MIN,WING_MIN,WING_RATIO,WING_GAP,INSTINCT_GAP,questions,types,instincts,wingNotes,score,getWing,validState,migrateState};
  if(typeof module!=='undefined'&&module.exports) module.exports=api;
  else root.Enneagram=api;
})(typeof globalThis!=='undefined'?globalThis:this);
</script>
  <script>(function () {
  'use strict';
  const E=window.Enneagram;
  const $=id=>document.getElementById(id);
  const KEYS={draft:'nh-enneagram-v2-draft',result:'nh-enneagram-v2-result',prefs:'nh-enneagram-v2-prefs'};
  const chapters=['מבט פנימה','בחיי היומיום','בין אנשים','מתחת לפני השטח','התמונה מתחברת','מה מניע אותי'];
  const labels=['בכלל לא','מעט','במידה בינונית','במידה רבה','מאוד'];
  let answers=Array(E.questions.length).fill(null), index=0, currentScreen='start', result=null;
  let completedAt=null, autoSave=true, theme='light', pendingAction=null, focusBeforeDialog=null;
  let draft=null, saved=null;
  const escapeHtml=s=>String(s).replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
  const round=n=>Math.round(n);
  const dateText=s=>new Date(s).toLocaleString('he-IL',{dateStyle:'medium',timeStyle:'short'});
  function notice(message){$('notice').textContent=message;$('notice').hidden=!message;}
  function read(key){
    let text;
    try {text=localStorage.getItem(key);}
    catch {notice('לא ניתן לקרוא את השמירה המקומית. אפשר להמשיך במבחן ולהוריד דוח בסיום.');return null;}
    if(!text)return null;
    try{return JSON.parse(text);}
    catch {const removed=remove(key);notice(removed?'נתוני שמירה פגומים הוסרו. אפשר להתחיל מחדש; שמירות תקינות אחרות נשארו זמינות.':'נמצאו נתוני שמירה פגומים שלא ניתן להסיר. אפשר להתחיל מחדש ולהוריד דוח בסיום.');return null;}
  }
  function write(key,value){
    try {localStorage.setItem(key,JSON.stringify(value));return true;}
    catch {notice('השמירה במכשיר אינה זמינה. אפשר להמשיך כל עוד העמוד פתוח ולהוריד את הדוח בסיום.');return false;}
  }
  function remove(key){try{localStorage.removeItem(key);return true;}catch{return false;}}
  function getStoredState(key){const value=read(key);if(value===null)return null;if(E.validState(value))return value;const migrated=E.migrateState(value);if(migrated){write(key,migrated);notice(value.version==='2.0.0'?'התשובות הקודמות נשמרו. נוספו 18 שאלות, ויש להשלים אותן לפני חישוב תוצאה מעודכנת.':'התוצאה עודכנה לפי התשובות השמורות שלך.');return migrated;}remove(key);notice('נמצאה שמירה ישנה או לא תקינה שלא ניתן לשחזר. אפשר להתחיל מבחן חדש.');return null;}
  function snapshot(screen=currentScreen){return{version:E.VERSION,answers:[...answers],index,screen:screen==='results'?'results':'quiz',updatedAt:completedAt||new Date().toISOString()};}
  function storeDraft(){
    if(!autoSave){$('save-status').textContent='';return false;}
    const value=snapshot();const ok=write(KEYS.draft,value);
    if(ok)draft=value;
    $('save-status').textContent=ok?'':'לא נשמר. אפשר להמשיך בעמוד הזה';
    return ok;
  }
  function setScreen(name,focusId){
    currentScreen=name;
    ['start','quiz','results'].forEach(id=>$(id+'-screen').hidden=id!==name);
    $('about-panel').hidden=true;
    $('about-btn').setAttribute('aria-expanded','false');
    if(focusId)$(focusId).focus({preventScroll:true});
    window.scrollTo({top:0,behavior:'instant'});
  }
  function updateHome(){
    $('resume-box').hidden=!draft;
    if(draft){const count=draft.answers.filter(v=>v!==null).length;$('resume-text').textContent=draft.screen==='results'?'המבחן האחרון הושלם. אפשר לחזור לתוצאה.':`כבר ענית על ${count} מתוך ${E.questions.length} שאלות`;$('resume-btn').textContent=draft.screen==='results'?'לחזור לתוצאה האחרונה':'להמשיך מהמקום שעצרתי';}
    $('saved-box').hidden=!saved;
    if(saved){$('saved-text').textContent=saved.screen==='results'?`תוצאה שמורה במכשיר מ-${dateText(saved.updatedAt)}`:'התשובות מהגרסה הקודמת נשמרו';$('saved-btn').textContent=saved.screen==='results'?'לתוצאה השמורה':'להשלמת השאלות החדשות';}
  }
  function confirmAction(title,description,label,action){
    pendingAction=action;focusBeforeDialog=document.activeElement;
    $('confirm-title').textContent=title;$('confirm-description').textContent=description;$('confirm-ok').textContent=label;
    $('confirm-dialog').showModal();$('confirm-cancel').focus();
  }
  function dismissDialog(){pendingAction=null;$('confirm-dialog').close();focusBeforeDialog?.focus();}
  $('confirm-cancel').addEventListener('click',dismissDialog);
  $('confirm-dialog').addEventListener('cancel',()=>{pendingAction=null;});
  $('confirm-ok').addEventListener('click',()=>{const action=pendingAction;pendingAction=null;$('confirm-dialog').close();action?.();});
  function startFresh(){
    answers=Array(E.questions.length).fill(null);index=0;result=null;completedAt=null;draft=null;
    if(!remove(KEYS.draft))notice('לא ניתן למחוק את השמירה הקודמת כרגע. המבחן החדש פתוח ואפשר לענות עליו.');
    setScreen('quiz');showQuestion();storeDraft();
  }
  function requestNew(){
    if(draft||answers.some(v=>v!==null))confirmAction('להתחיל מבחן חדש?','ההתקדמות הנוכחית תוחלף. תוצאה ששמרת בנפרד תישאר זמינה.','להתחיל מחדש',startFresh);
    else startFresh();
  }
  function restore(value){
    if(!E.validState(value)){notice('לא ניתן לשחזר את הנתונים האלה. אפשר להתחיל מבחן חדש.');return;}
    answers=[...value.answers];index=value.index;completedAt=value.screen==='results'?value.updatedAt:null;
    if(value.screen==='results')showResults(false);else{setScreen('quiz');showQuestion();}
  }
  function renderWheel(){
    const coords={};
    for(let n=1;n<=9;n++){const angle=((n%9)*40-90)*Math.PI/180;coords[n]={x:50+38*Math.cos(angle),y:50+38*Math.sin(angle)};}
    const linePath=sequence=>sequence.map((n,i)=>`${i?'L':'M'}${coords[n].x} ${coords[n].y}`).join(' ');
    $('intro-wheel').innerHTML=`<svg viewBox="0 0 100 100" aria-hidden="true"><circle cx="50" cy="50" r="38" fill="none" stroke="currentColor" opacity=".25" stroke-width=".35"/><path d="${linePath([9,3,6,9])} ${linePath([1,4,2,8,5,7,1])}" stroke="currentColor" opacity=".2" stroke-width=".35" fill="none"/></svg><div class="wheel-center"><strong>מאחורי<br>הבחירות שלך</strong><span>מפת האניאגרמה</span></div>`;
    for(let n=1;n<=9;n++){
      const button=document.createElement('button');button.className='wheel-node';button.style.left=coords[n].x+'%';button.style.top=coords[n].y+'%';button.textContent=n;button.setAttribute('aria-label',`טיפוס ${n}, ${E.types[n].name}`);button.setAttribute('aria-pressed','false');
      button.addEventListener('click',()=>{document.querySelectorAll('.wheel-node').forEach(b=>b.setAttribute('aria-pressed',String(b===button)));$('type-preview-title').textContent=`${n} · ${E.types[n].name}`;$('type-preview-text').textContent=E.types[n].theme;});
      $('intro-wheel').appendChild(button);
    }
    $('type-preview-title').parentElement.setAttribute('aria-live','polite');
  }
  function showQuestion(){
    const question=E.questions[index];
    const chapter=Math.min(chapters.length-1,Math.floor(index/15)), answered=answers.filter(v=>v!==null).length;
    $('pause-btn').textContent=autoSave?'שמירה ויציאה':'יציאה מהמבחן';
    $('question-text').textContent=question.text;
    const paired=question.kind==='contrast';
    $('answers-form').classList.toggle('paired-question',paired);
    $('contrast-options').hidden=!paired;
    $('contrast-options').innerHTML=paired?question.options.map((text,i)=>`<div><b>${i?'ב':'א'}</b><p>${escapeHtml(text)}</p></div>`).join(''):'';
    $('answer-hint').textContent=paired?'מה מתאר אותך יותר?':'עד כמה זה מתאר אותך?';
    const currentLabels=paired?['א בבירור','יותר א','שניהם או אף אחד','יותר ב','ב בבירור']:labels;
    $('question-counter').textContent=`שאלה ${index+1} מתוך ${E.questions.length}`;
    $('chapter-name').textContent=`חלק ${chapter+1} מתוך ${chapters.length} · ${chapters[chapter]}`;
    $('progress').value=answered;$('progress').setAttribute('aria-valuetext',`${answered} מתוך ${E.questions.length} שאלות נענו`);
    $('chapter-list').innerHTML=chapters.map((name,i)=>`<li${i===chapter?' aria-current="step"':''} class="${i<chapter?'done':''}"><span>${i+1}</span>${name}</li>`).join('');
    $('answers-container').innerHTML=currentLabels.map((label,i)=>`<label class="answer-label"><input type="radio" name="answer" value="${i+1}" aria-label="${i+1}, ${label}"${answers[index]===i+1?' checked':''}><span class="answer-dot" aria-hidden="true"></span><span>${label}</span></label>`).join('');
    $('prev-btn').disabled=index===0;$('next-btn').textContent=index===E.questions.length-1?'למפה האישית שלי ←':'הבא ←';
    $('error-msg').hidden=true;
    $('question-text').focus({preventScroll:true});
  }
  $('answers-container').addEventListener('change',event=>{
    if(event.target.name!=='answer')return;
    answers[index]=Number(event.target.value);completedAt=null;result=null;$('error-msg').hidden=true;storeDraft();
    const count=answers.filter(v=>v!==null).length;$('progress').value=count;$('progress').setAttribute('aria-valuetext',`${count} מתוך ${E.questions.length} שאלות נענו`);
  });
  $('answers-form').addEventListener('submit',event=>{
    event.preventDefault();
    if(answers[index]===null){$('error-msg').hidden=false;document.querySelector('input[name=answer]').focus();return;}
    if(index<E.questions.length-1){index++;storeDraft();showQuestion();}else showResults(true);
  });
  $('prev-btn').addEventListener('click',()=>{if(index>0){index--;storeDraft();showQuestion();}});
  document.addEventListener('keydown',event=>{
    if(currentScreen!=='quiz'||$('confirm-dialog').open||!$('about-panel').hidden||event.altKey||event.ctrlKey||event.metaKey)return;
    if(event.key==='Enter'&&(document.activeElement?.matches('input[name=answer]')||document.activeElement===$('question-text'))){event.preventDefault();$('answers-form').requestSubmit();return;}
    if(/^[1-5]$/.test(event.key)){
      const radio=document.querySelector(`input[name=answer][value="${event.key}"]`);
      if(radio){event.preventDefault();radio.checked=true;radio.focus();radio.dispatchEvent(new Event('change',{bubbles:true}));}
    }
  });
  function mainTitle(r){
    if(r.primary)return`טיפוס ${r.primary} · ${E.types[r.primary].name}`;
    if(r.primaryStatus==='undifferentiated')return'עוד אין כאן כיוון מוביל';
    if(r.primaryStatus==='weak')return'ההתאמה לטיפוסים נמוכה';
    if(r.primaryStatus==='mixed')return'כדאי להבחין בין הסגנון למניע';
    if(r.primaryStatus==='unstable')return'הכיוון המוביל עדיין לא יציב';
    return'כמה כיוונים קרובים זה לזה';
  }
  function mainDescription(r){
    if(r.primary)return E.types[r.primary].description;
    if(r.primaryStatus==='undifferentiated')return'כל התשובות זהות. אפשר לחזור לשאלות או להכיר את הטיפוסים בהמשך.';
    if(r.primaryStatus==='weak')return'לא בלט טיפוס מסוים בתשובות שלך.';
    return`כדאי להשוות בין ${r.candidates.map(n=>`${n} (${E.types[n].name})`).join(', ')} ולבדוק איזה מניע מוכר לך יותר.`;
  }
  function wingTitle(r){
    if(!r.primary)return'כדאי לברר קודם את הטיפוס המוביל';
    if(r.wing.dominant)return`כנף מובילה: ${r.primary}w${r.wing.dominant}`;
    return'לא נמצאה כנף מובחנת';
  }
  function wingDescription(r){
    if(!r.primary)return'נבחר כנף רק לאחר שתתבהר ההבחנה בין הטיפוסים.';
    if(r.wing.status==='weak')return'ההתאמה לשכנים נמוכה מכדי להציג כנף בולטת.';
    if(r.wing.status==='close')return'אין העדפה ברורה בין השכנים.';
    return'';
  }
  function renderWing(r){
    let html=`<h3>${wingTitle(r)}</h3>${wingDescription(r)?`<p style="margin-top:13px">${wingDescription(r)}</p>`:''}`;
    if(r.primary&&r.wing.eligible.length)html+=`<div class="wing-choices">${r.wing.eligible.map(n=>`<div class="wing-choice ${n===r.wing.dominant?'suggested':''}"><h3><bdi>${r.primary}w${n}</bdi></h3><div class="wing-score">התאמה לטיפוס ${n}: ${round(r.scores[n])} מתוך 100</div><p>${E.wingNotes[`${r.primary}w${n}`]}</p>${n===r.wing.dominant?'<span class="result-badge">הכנף המובילה</span>':''}</div>`).join('')}</div>`;
    $('wing-result').innerHTML=html;
  }
  function instinctTitle(r){
    if(r.instinctStatus==='undifferentiated')return'אין הבחנה בין תחומי הקשב';
    if(r.instinctStatus==='weak')return'לא נמצא תחום קשב מוביל';
    if(!r.dominantInstinct)return'כמה תחומי קשב קיבלו ציונים קרובים';
    if(r.stackClear)return`סדר משוער: ${r.instinctRanking.map(t=>E.instincts[t.key].code).join(' / ')}`;
    return`הכיוון המוביל: ${E.instincts[r.dominantInstinct].name}`;
  }
  function instinctCaution(r){
    if(r.uniform)return'מענה אחיד אינו מספיק כדי לזהות העדפה.';
    if(r.instinctStatus==='weak'||!r.dominantInstinct)return'';
    if(!r.stackClear)return'שני התחומים האחרים קרובים זה לזה.';
    return'';
  }
  function renderInstincts(r){
    $('instinct-result').innerHTML=`<div class="instinct-summary">${r.stackClear?`<bdi>${instinctTitle(r)}</bdi>`:instinctTitle(r)}</div>${instinctCaution(r)?`<p style="margin-bottom:24px">${instinctCaution(r)}</p>`:''}<div class="instinct-grid">${r.instinctRanking.map(({key,score})=>{const data=E.instincts[key];return`<div class="instinct-item"><h3>${data.name} <bdi>(${data.code})</bdi></h3><div class="score-row"><div class="score-track"><div class="score-fill" style="width:${score}%"></div></div><span class="score-value">${round(score)}</span></div><p>${data.description.split('. ')[0]}.</p>${key===r.dominantInstinct?`<p><strong>נקודה להתבוננות:</strong> ${data.practice}</p>`:''}</div>`;}).join('')}</div>`;
  }
  function showType(n){
    const data=E.types[n],neighbors=[n===1?9:n-1,n===9?1:n+1];
    document.querySelectorAll('.type-tab').forEach(b=>b.setAttribute('aria-pressed',String(Number(b.dataset.type)===n)));
    $('type-detail').innerHTML=`<h3>${n} · ${data.name}: ${data.theme}</h3><p>מכונה גם: ${data.aliases.join(', ')}</p><p>${data.description}</p><div class="detail-grid"><div><h3>מה הדפוס מאפשר</h3><p>${data.strength}</p></div><div><h3>מה עלול לגבות מחיר</h3><p>${data.cost}</p></div></div><div class="practice"><h3>ניסוי קטן לשבוע הקרוב</h3><p>${data.practice}</p><p class="reflection">${data.reflection}</p></div><details style="margin-top:20px"><summary>שתי הכנפיים של טיפוס ${n}</summary>${neighbors.map(w=>`<p><strong><bdi>${n}w${w}</bdi>:</strong> ${E.wingNotes[`${n}w${w}`]}</p>`).join('')}</details>`;
  }
  function showResults(persist){
    if(answers.some(v=>v===null)){index=answers.indexOf(null);setScreen('quiz');showQuestion();notice('נשארה שאלה ללא תשובה. נשלים אותה לפני חישוב המפה.');return;}
    result=E.score(answers);completedAt=completedAt||new Date().toISOString();
    const r=result;
    $('result-date').textContent=`${E.questions.length} תשובות · ${dateText(completedAt)}`;
    $('result-summary').innerHTML=`<div class="result-number">${r.primary||'?'}<small>${r.primary?'הכיוון המוביל בתשובות':'מרחב לבדיקה נוספת'}</small></div><div><h2>${mainTitle(r)}</h2><p>${mainDescription(r)}</p></div>`;
    $('type-scores').innerHTML=r.typeRanking.map(({key,score})=>`<div class="score-row ${Number(key)===r.primary?'leading':''}"><span class="score-label"><b>${key}</b> ${E.types[key].name}</span><div class="score-track" aria-hidden="true"><div class="score-fill" style="width:${score}%"></div></div><span class="score-value" aria-label="${round(score)} מתוך 100">${round(score)}</span></div>`).join('');
    renderWing(r);renderInstincts(r);
    $('instinct-result').querySelectorAll('.score-value').forEach(node=>node.setAttribute('aria-label',`${node.textContent} מתוך 100`));
    $('explore-types').innerHTML=Object.keys(E.types).map(n=>`<button class="type-tab" data-type="${n}" aria-label="קריאה על טיפוס ${n}, ${E.types[n].name}" aria-pressed="false">${n}</button>`).join('');
    $('explore-types').querySelectorAll('button').forEach(b=>b.addEventListener('click',()=>showType(Number(b.dataset.type))));
    showType(r.primary||Number(r.typeRanking[0].key));
    $('export-status').textContent='';
    setScreen('results','results-title');if(persist)storeDraft();
  }
  function reportData(){
    return {schema:'nh-enneagram-result',version:E.VERSION,createdAt:completedAt,questionCount:E.questions.length,
      note:'כלי להתבוננות עצמית, לא אבחון פסיכולוגי. הציונים אינם הסתברויות. השאלון לא עבר תיקוף על מדגם אנושי.',
      scoring:{selection:'style-ranking-with-adjacent-comparisons',coreWindow:E.CORE_WINDOW,pairMinimum:E.PAIR_MIN,requireLeaveOneOutStability:false,wingGap:E.WING_GAP,wingMinimum:E.WING_MIN,wingRatio:E.WING_RATIO,instinctGap:E.INSTINCT_GAP},
      typeLabels:Object.fromEntries(Object.entries(E.types).map(([key,{name,aliases}])=>[key,{name,aliases}])),
      result,answers:E.questions.map((q,i)=>({id:q.id,question:q.text,...(q.options?{options:q.options,responseScale:['א בבירור','יותר א','שניהם או אף אחד','יותר ב','ב בבירור']}:{responseScale:labels}),answer:answers[i]})),
      explanations:{title:mainTitle(result),description:mainDescription(result),wing:wingTitle(result),wingExplanation:wingDescription(result),instincts:instinctTitle(result),instinctCaution:instinctCaution(result)},
      sources:['https://www.enneagraminstitute.com/how-the-enneagram-system-works/','https://www.enneagraminstitute.com/type-descriptions/','https://pubmed.ncbi.nlm.nih.gov/33332604/','https://www.enneagraminstitute.com/interpreting-your-enneagram-test-results/','https://www.pewresearch.org/writing-survey-questions/']};
  }
  function reportHtml(){
    const r=result, data=reportData();
    const typeRows=r.typeRanking.map(({key,score})=>`<tr><td>${key} · ${E.types[key].name}</td><td>${round(score)}</td></tr>`).join('');
    const wingHtml=r.primary?r.wing.eligible.map(n=>`<p><strong><bdi>${r.primary}w${n}</bdi>:</strong> ${E.wingNotes[`${r.primary}w${n}`]} (התאמה לטיפוס ${n}: ${round(r.scores[n])})</p>`).join(''):'';
    const descriptions=r.typeRanking.slice(0,3).map(({key})=>{const t=E.types[key];return`<section><h3>טיפוס ${key} · ${t.name}</h3><p>מכונה גם: ${t.aliases.join(', ')}</p><p>${t.description}</p><p><strong>משאב:</strong> ${t.strength}</p><p><strong>אתגר:</strong> ${t.cost}</p><p><strong>ניסוי קטן:</strong> ${t.practice}</p><p><strong>שאלה למחשבה:</strong> ${t.reflection}</p></section>`;}).join('');
    const limitations='הציונים בסולם 0 עד 100 מתארים התאמה לתשובות, ולא הסתברות או אחוזי ודאות. הספים הם כללי תצוגה של הכלי, לא ערכים מתוקפים מחקרית. ציוני הסגנונות הם ממוצעי שש האמירות לכל טיפוס. 18 ההשוואות מחושבות בנפרד. מתחילים מהדירוג המקורי ובוחנים מועמדים עד 15 נקודות מהמוביל. שתי העדפות עקביות של שכן מועמד, בממוצע של 75 לפחות, מסירות את הטיפוס שהפסיד מהבחירה הסופית. בוחרים את הציון המקורי הגבוה מבין הנותרים. בהיעדר הכרעה או במעגל השוואות סותר חוזרים למוביל המקורי. בתיקו מלא בציונים ובמידע ההשוואתי הסדר מספרי. כנף דורשת ציון של 62.5 לפחות ולפחות 75% מציון הטיפוס. מבין השכנים שעומדים בסף, בעל הציון הגבוה מוצג כמוביל, גם בפער קטן. בתיקו בין השכנים אין כנף מובילה. מענה אחיד אינו מוכרע. סדר מלא של אינסטינקטים דורש פער של 8 נקודות גם בין השני לשלישי. השאלון לא עבר תיקוף על מדגם אנושי. סקירת המחקר מצאה ראיות מעורבות לתוקף האניאגרמה ומעט תמיכה בכנפיים. זה אינו שאלון רשמי של Enneagram Institute.';
    return`<!DOCTYPE html><html lang="he" dir="rtl"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>המפה האישית שלי | אניאגרמה</title><style>body{font:18px/1.75 'Segoe UI',Arial,sans-serif;color:#29263d;max-width:850px;margin:35px auto;padding:0 25px;background:#fff}h1,h2,h3{line-height:1.3}h1{font-size:38px;color:#5443a8}h2{margin-top:35px}section{break-inside:avoid;border-top:1px solid #ddd;padding-top:15px;margin-top:22px}table{width:100%;border-collapse:collapse}th,td{text-align:start;border-bottom:1px solid #ddd;padding:9px}header{padding-bottom:20px;border-bottom:2px solid #5443a8}.note{font-size:15px;color:#555}a{color:#443387;overflow-wrap:anywhere}bdi{unicode-bidi:isolate}@media print{body{font-size:11pt;margin:0;padding:0}h1{font-size:26pt}h2{font-size:19pt}@page{size:A4;margin:17mm}}</style></head><body><header><h1>המפה האישית שלי</h1><p>${escapeHtml(dateText(completedAt))} · ${E.questions.length} תשובות · גרסה ${E.VERSION}</p></header><h2>${mainTitle(r)}</h2><p>${mainDescription(r)}</p><h2>הסגנונות בתשובות שלך</h2><table><thead><tr><th>טיפוס</th><th>ציון (0-100)</th></tr></thead><tbody>${typeRows}</tbody></table><section><h2>${wingTitle(r)}</h2><p>${wingDescription(r)}</p>${wingHtml}</section><section><h2>האינסטינקטים</h2><h3>${instinctTitle(r)}</h3><p>${instinctCaution(r)}</p>${r.instinctRanking.map(({key,score})=>`<h3>${E.instincts[key].name} <bdi>(${E.instincts[key].code})</bdi> · ${round(score)}</h3><p>${E.instincts[key].description}</p><p>${E.instincts[key].practice}</p>`).join('')}</section><h2>${r.primary?'כיוונים להמשך התבוננות':'תיאורים להתחלת בירור, ללא הכרעה'}</h2><p class="note">${r.primary?'שלושת הציונים הגבוהים בתשובות.':'מוצגים שלושה מתוך תשעת הטיפוסים, לפי סדר הציונים. בתיקו הסדר מספרי ואינו מעיד על התאמה עדיפה.'}</p>${descriptions}<section><details><summary>על המבחן והשיטה</summary><p class="note">${data.note} ${limitations}</p><ul>${data.sources.map((url,i)=>`<li><a href="${url}" rel="noopener noreferrer">${['מבנה האניאגרמה, כנפיים ואינסטינקטים','תשעת הטיפוסים','Hook ועמיתיו, סקירה שיטתית, 2021','פירוש תוצאות והבחנה בין טיפוס לכנף','Pew Research Center: ניסוח שאלות'][i]}</a></li>`).join('')}</ul></details></section></body></html>`;
  }
  function download(content,type,extension){
    try{
      const blob=new Blob([extension==='json'?'':'\uFEFF',content],{type});const url=URL.createObjectURL(blob);
      const link=document.createElement('a');link.href=url;link.download=`enneagram-${completedAt.slice(0,10)}.${extension}`;document.body.append(link);link.click();link.remove();
      window.setTimeout(()=>URL.revokeObjectURL(url),15000);
      $('export-status').textContent=extension==='html'?'הדוח נוצר והועבר לדפדפן להורדה. אפשר לפתוח אותו גם ללא חיבור לרשת.':'קובץ הנתונים נוצר והועבר לדפדפן להורדה. הוא כולל גם את התשובות המלאות.';
    }catch{$('export-status').textContent='ההורדה לא הצליחה. אפשר לנסות שוב או להשתמש בהדפסה / PDF.';}
  }
  $('download-btn').addEventListener('click',()=>download(reportHtml(),'text/html;charset=utf-8','html'));
  $('json-btn').addEventListener('click',()=>download(JSON.stringify(reportData(),null,2),'application/json;charset=utf-8','json'));
  $('print-btn').addEventListener('click',()=>{
    // Print the same complete, script-free report as the download, including methodology.
    const frame=document.createElement('iframe');frame.title='דוח אישי להדפסה';frame.style.cssText='position:fixed;width:1px;height:1px;left:-10000px;border:0';
    const dispose=()=>{frame.remove();};
    frame.addEventListener('load',()=>{try{frame.contentWindow.addEventListener('afterprint',dispose,{once:true});frame.contentWindow.focus();frame.contentWindow.print();}catch{dispose();$('export-status').textContent='לא ניתן לפתוח הדפסה. אפשר להוריד את הדוח ולפתוח אותו בדפדפן.';}});
    frame.srcdoc=reportHtml();document.body.append(frame);window.setTimeout(dispose,120000);
  });
  $('save-result-btn').addEventListener('click',()=>{
    const value=snapshot('results');
    if(write(KEYS.result,value)){saved=value;$('export-status').textContent='התוצאה נשמרה במכשיר הזה. אפשר לפתוח אותה שוב ממסך הפתיחה.';}
    else $('export-status').textContent='התוצאה לא נשמרה במכשיר. מומלץ להוריד את הדוח.';
  });
  $('clear-btn').addEventListener('click',()=>confirmAction('למחוק את הנתונים השמורים?','ההתקדמות והתוצאה יימחקו מהדפדפן הזה. קבצים שכבר הורדת יישארו במכשיר.','למחוק',()=>{
    const removedDraft=remove(KEYS.draft),removedResult=remove(KEYS.result);
    if(removedDraft)draft=null;if(removedResult)saved=null;
    autoSave=false;$('auto-save').checked=false;write(KEYS.prefs,{autoSave,theme});
    $('export-status').textContent=removedDraft&&removedResult?'הנתונים השמורים נמחקו והשמירה האוטומטית כובתה. התוצאה נשארת פתוחה עד סגירת העמוד.':'לא כל הנתונים נמחקו. אפשר למחוק את נתוני האתר דרך הגדרות הדפדפן.';
  }));
  $('auto-save').addEventListener('change',()=>{
    autoSave=$('auto-save').checked;write(KEYS.prefs,{autoSave,theme});
    if(!autoSave){if(remove(KEYS.draft)){draft=null;updateHome();notice('השמירה האוטומטית כובתה וההתקדמות השמורה נמחקה. תוצאה שנשמרה בנפרד נשארת זמינה.');}else notice('השמירה כובתה, אך לא ניתן למחוק את ההתקדמות שכבר נשמרה. אפשר למחוק נתוני אתר בהגדרות הדפדפן.');}
  });
  function applyTheme(){document.documentElement.dataset.theme=theme;$('theme-btn').setAttribute('aria-label',theme==='dark'?'מעבר לתצוגה בהירה':'מעבר לתצוגה כהה');}
  $('theme-btn').addEventListener('click',()=>{theme=theme==='dark'?'light':'dark';applyTheme();write(KEYS.prefs,{autoSave,theme});});
  $('start-btn').addEventListener('click',requestNew);$('restart-btn').addEventListener('click',requestNew);
  $('resume-btn').addEventListener('click',()=>restore(draft));$('saved-btn').addEventListener('click',()=>restore(saved));
  $('edit-btn').addEventListener('click',()=>{index=0;completedAt=null;setScreen('quiz');showQuestion();storeDraft();});
  function goHome(){updateHome();setScreen('start','start-title');}
  function pause(){
    if(autoSave&&storeDraft()){goHome();notice('ההתקדמות נשמרה. אפשר לחזור דרך כפתור ההמשך.');}
    else confirmAction('לצאת למסך הפתיחה?','השמירה המקומית אינה פעילה או אינה זמינה. נשמור את התשובות בזיכרון של העמוד הזה בלבד, עד לסגירה או לרענון.','לחזור לפתיחה',()=>{draft=snapshot();goHome();});
  }
  $('pause-btn').addEventListener('click',pause);
  $('home-link').addEventListener('click',event=>{event.preventDefault();if(currentScreen==='quiz')pause();else goHome();});
  $('about-btn').setAttribute('aria-expanded','false');$('about-btn').setAttribute('aria-controls','about-panel');
  $('about-btn').addEventListener('click',()=>{$('about-panel').hidden=!$('about-panel').hidden;$('about-btn').setAttribute('aria-expanded',String(!$('about-panel').hidden));if(!$('about-panel').hidden){$('about-title').focus();$('about-panel').scrollIntoView({block:'start'});}});
  $('close-about-btn').addEventListener('click',()=>{$('about-panel').hidden=true;$('about-btn').setAttribute('aria-expanded','false');$('about-btn').focus();});
  window.addEventListener('beforeunload',event=>{if(currentScreen==='quiz'&&answers.some(v=>v!==null)&&(!autoSave||!storeDraft())){event.preventDefault();event.returnValue='';}});
  const prefs=read(KEYS.prefs);
  if(prefs&&typeof prefs.autoSave==='boolean')autoSave=prefs.autoSave;
  theme=prefs&&['light','dark'].includes(prefs.theme)?prefs.theme:window.matchMedia('(prefers-color-scheme: dark)').matches?'dark':'light';
  $('auto-save').checked=autoSave;applyTheme();draft=getStoredState(KEYS.draft);saved=getStoredState(KEYS.result);renderWheel();updateHome();
})();
</script>
</body>
</html>
"; +window.NHLocalDownloads["the_enneagram"] = "<!DOCTYPE html>
<html lang="he" dir="rtl">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="theme-color" content="#f5f5fa">
  <link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 40 40'%3E%3Crect width='40' height='40' rx='10' fill='%235443a8'/%3E%3Ccircle cx='20' cy='20' r='13' stroke='%23e3f0af' fill='none' stroke-width='2'/%3E%3Cpath d='M20 7 31 27H9Z' stroke='%23e3f0af' fill='none' stroke-width='2'/%3E%3C/svg%3E">
  <style>/* Embedded Assistant font license:
Copyright 2020 The Assistant Project Authors (https://github.com/hafontia/Assistant).
Copyright 2010 The Source Sans Pro Authors (https://github.com/adobe-fonts/source-sans-pro), with Reserved Font Name 'Source'.
Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries.

This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at:
http://scripts.sil.org/OFL


-----------------------------------------------------------
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------

PREAMBLE
The goals of the Open Font License (OFL) are to stimulate worldwide
development of collaborative font projects, to support the font creation
efforts of academic and linguistic communities, and to provide a free and
open framework in which fonts may be shared and improved in partnership
with others.

The OFL allows the licensed fonts to be used, studied, modified and
redistributed freely as long as they are not sold by themselves. The
fonts, including any derivative works, can be bundled, embedded,
redistributed and/or sold with any software provided that any reserved
names are not used by derivative works. The fonts and derivatives,
however, cannot be released under any other type of license. The
requirement for fonts to remain under this license does not apply
to any document created using the fonts or their derivatives.

DEFINITIONS
"Font Software" refers to the set of files released by the Copyright
Holder(s) under this license and clearly marked as such. This may
include source files, build scripts and documentation.

"Reserved Font Name" refers to any names specified as such after the
copyright statement(s).

"Original Version" refers to the collection of Font Software components as
distributed by the Copyright Holder(s).

"Modified Version" refers to any derivative made by adding to, deleting,
or substituting -- in part or in whole -- any of the components of the
Original Version, by changing formats or by porting the Font Software to a
new environment.

"Author" refers to any designer, engineer, programmer, technical
writer or other person who contributed to the Font Software.

PERMISSION & CONDITIONS
Permission is hereby granted, free of charge, to any person obtaining
a copy of the Font Software, to use, study, copy, merge, embed, modify,
redistribute, and sell modified and unmodified copies of the Font
Software, subject to the following conditions:

1) Neither the Font Software nor any of its individual components,
in Original or Modified Versions, may be sold by itself.

2) Original or Modified Versions of the Font Software may be bundled,
redistributed and/or sold with any software, provided that each copy
contains the above copyright notice and this license. These can be
included either as stand-alone text files, human-readable headers or
in the appropriate machine-readable metadata fields within text or
binary files as long as those fields can be easily viewed by the user.

3) No Modified Version of the Font Software may use the Reserved Font
Name(s) unless explicit written permission is granted by the corresponding
Copyright Holder. This restriction only applies to the primary font name as
presented to the users.

4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
Software shall not be used to promote, endorse or advertise any
Modified Version, except to acknowledge the contribution(s) of the
Copyright Holder(s) and the Author(s) or with their explicit written
permission.

5) The Font Software, modified or unmodified, in part or in whole,
must be distributed entirely under this license, and must not be
distributed under any other license. The requirement for fonts to
remain under this license does not apply to any document created
using the Font Software.

TERMINATION
This license becomes null and void if any of the above conditions are
not met.

DISCLAIMER
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
OTHER DEALINGS IN THE FONT SOFTWARE.
*/
@font-face{font-family:Assistant;src:url('data:font/ttf;base64,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') format('truetype');font-weight:200 800;font-display:swap}
:root{color-scheme:light;--paper:#f5f5fa;--surface:#fff;--ink:#29263d;--muted:#625e75;--line:#d4d1df;--accent:#5443a8;--on-accent:#fff;--soft:#ebe7fa;--map:#e5eecb;--map-ink:#35462c;--mint:#e5f0ed;--danger:#ab3042;--radius:16px;--ease:cubic-bezier(.16,1,.3,1)}
:root[data-theme=dark]{color-scheme:dark;--paper:#1c1b27;--surface:#282633;--ink:#f1effa;--muted:#bfb9d0;--line:#504b61;--accent:#b9a6ff;--on-accent:#211741;--soft:#373048;--map:#303d28;--map-ink:#e1eebe;--mint:#283d38;--danger:#ffb0b9}
*{box-sizing:border-box}body{margin:0;background:var(--paper);color:var(--ink);font:18px/1.65 Assistant,'Segoe UI',Arial,sans-serif}button,input{font:inherit}button,a,label,input{touch-action:manipulation}button{cursor:pointer}button,a{-webkit-tap-highlight-color:transparent}button{color:inherit}a{color:var(--accent);text-underline-offset:4px}p,h1,h2,h3{margin:0}h1,h2,h3{line-height:1.2;text-wrap:balance}h1{font-size:clamp(38px,4.5vw,62px);font-weight:800;letter-spacing:-.035em}h2{font-size:28px;font-weight:750}h3{font-size:23px;font-weight:700}p+p{margin-block-start:12px}[hidden]{display:none!important}:focus-visible{outline:3px solid var(--accent);outline-offset:5px}button:disabled{cursor:not-allowed;opacity:.42}svg{display:block}fieldset{border:0;padding:0;margin:0;min-inline-size:0}legend{padding:0}button{border:0}main{max-width:1160px;margin:auto;padding:0 34px;outline:none}.site-header{max-width:1228px;padding:25px 34px;margin:auto;display:flex;align-items:center;justify-content:space-between;gap:20px}.brand{display:flex;gap:12px;align-items:center;text-decoration:none;color:var(--ink);font-size:25px;font-weight:800;line-height:1.15}.brand svg{fill:none;stroke:var(--accent);stroke-width:1.6}.brand-note{display:block;font-size:13px;font-weight:500;color:var(--muted);margin-block-start:5px}.header-actions{display:flex;gap:20px;align-items:center}.icon-btn{background:var(--surface);border:1px solid var(--line);width:42px;height:42px;border-radius:50%;display:grid;place-items:center}.icon-btn svg{fill:none;stroke:currentColor;stroke-width:1.7}.text-btn{background:none;padding:9px 0;color:var(--accent);font-weight:700;min-height:44px;line-height:1.35;text-decoration:underline;text-decoration-color:transparent;text-underline-offset:5px}.text-btn:hover{text-decoration-color:currentColor}.button{display:inline-flex;justify-content:center;align-items:center;gap:25px;min-height:50px;padding:11px 23px;font-weight:750;border-radius:9px;transition:background .15s,transform .15s var(--ease);line-height:1.4}.button:hover:not(:disabled){transform:translateY(-2px)}.primary{background:var(--accent);color:var(--on-accent)}.secondary{background:var(--surface);border:1px solid var(--line)}.large{min-height:58px;font-size:21px;padding-inline:28px}.small{font-size:14px;line-height:1.55}.muted{color:var(--muted)}.skip-link{position:fixed;top:-70px;right:16px;z-index:20;background:var(--surface);padding:12px}.skip-link:focus{top:12px}.intro-grid{display:grid;grid-template-columns:1.03fr 1fr;gap:64px;align-items:center;padding:53px 0 44px}.intro-copy h1 span{color:var(--accent)}.lead{font-size:21px;line-height:1.6;max-width:40ch;margin-top:25px}.quiz-facts{display:flex;flex-wrap:wrap;gap:0;margin:26px 0 25px;font-size:16px;font-weight:650}.quiz-facts span+span{border-inline-start:1px solid var(--line);margin-inline-start:15px;padding-inline-start:15px}.intro-note{color:var(--muted);margin-top:17px;max-width:41ch}.map-panel{background:var(--map);color:var(--map-ink);border-radius:26px;padding:23px 26px 24px;align-self:stretch;display:flex;flex-direction:column;justify-content:center}.map-caption{display:flex;justify-content:space-between;align-items:center;font-size:17px;font-weight:650}.map-caption>span:last-child{font-size:28px}.wheel{position:relative;aspect-ratio:1;max-width:375px;width:100%;margin:8px auto}.wheel>svg{width:100%;height:100%;position:absolute;inset:0;overflow:visible}.wheel-node{position:absolute;transform:translate(-50%,-50%);width:45px;height:45px;padding:0;border-radius:50%;font-size:21px;line-height:1;font-weight:750;background:var(--surface);color:var(--ink);border:1px solid transparent;transition:background .2s,color .2s,scale .2s var(--ease)}.wheel-node:hover,.wheel-node[aria-pressed=true]{background:var(--accent);color:var(--on-accent);scale:1.1}.wheel-center{position:absolute;inset:36% 22%;display:flex;flex-direction:column;justify-content:center;text-align:center;pointer-events:none}.wheel-center strong{font-size:27px;line-height:1.2}.wheel-center span{font-size:14px;margin-top:6px}.map-explainer{min-height:95px;border-top:1px solid color-mix(in srgb,var(--map-ink) 25%,transparent);padding-top:18px}.map-explainer strong{font-size:21px}.map-explainer p{font-size:16px;line-height:1.5;margin-top:6px}.intro-bottom{display:grid;grid-template-columns:1fr 1fr;gap:64px;border-top:1px solid var(--line);padding-top:29px;margin-bottom:24px}.intro-bottom h2{font-size:22px;margin-bottom:10px}.intro-bottom p{font-size:17px;color:var(--muted);max-width:53ch}.save-choice{display:flex;align-items:center;gap:10px;font-size:16px;cursor:pointer;min-height:44px}.save-choice input{accent-color:var(--accent);width:19px;height:19px}.resume-box{margin-top:21px;padding:13px 17px;background:var(--soft);border-radius:10px;font-size:16px}.resume-box .text-btn{padding-bottom:1px}.site-footer{max-width:1160px;margin:45px auto 0;padding:23px 34px;border-top:1px solid var(--line);display:flex;justify-content:space-between;gap:20px;color:var(--muted);font-size:13px}.quiz-layout{display:grid;grid-template-columns:230px 1fr;gap:75px;padding:50px 0;min-height:630px}.journey{border-inline-end:1px solid var(--line);padding-inline-end:30px}.journey h2{font-size:31px}.journey>p{font-size:16px;color:var(--muted);margin:16px 0 27px}.journey ol{list-style:none;padding:0;margin:0 0 20px}.journey li{display:flex;align-items:center;gap:13px;padding:12px 0;font-size:16px;color:var(--muted)}.journey li span{display:grid;place-items:center;width:29px;height:29px;border-radius:50%;border:1px solid var(--line);font-size:13px}.journey li[aria-current=step]{color:var(--accent);font-weight:750}.journey li[aria-current=step] span{background:var(--accent);color:var(--on-accent);border-color:transparent}.journey li.done span{background:var(--soft);border-color:transparent}.journey #save-status{margin:6px 0}.progress-caption{display:flex;justify-content:space-between;gap:15px;font-size:15px;color:var(--muted);margin-bottom:14px}.progress-caption>span:first-child{color:var(--accent);font-weight:750}progress{appearance:none;border:0;width:100%;height:6px;display:block;background:var(--line);border-radius:3px;overflow:hidden}progress::-webkit-progress-bar{background:var(--line)}progress::-webkit-progress-value{background:var(--accent)}progress::-moz-progress-bar{background:var(--accent)}#answers-form{margin-top:49px}#question-text{font-size:clamp(27px,2.9vw,37px);font-weight:700;line-height:1.42;letter-spacing:-.012em;min-height:157px;max-width:29ch;outline:none}#answer-hint{font-size:16px;margin:14px 0 22px}.answers{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:10px}.answer-label{position:relative;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:15px;min-height:121px;padding:15px 8px;border:1px solid var(--line);border-radius:12px;background:var(--surface);cursor:pointer;transition:background .15s,border-color .15s;line-height:1.35;text-align:center;font-size:16px;font-weight:600}.answer-label:hover{border-color:var(--accent);background:var(--soft)}.answer-label:has(input:checked){border:2px solid var(--accent);padding:14px 7px;background:var(--soft);color:var(--accent)}.answer-label:has(input:focus-visible){outline:3px solid var(--accent);outline-offset:4px}.answer-label input{position:absolute;opacity:0;width:1px;height:1px}.answer-dot{width:25px;height:25px;border:1.5px solid var(--muted);border-radius:50%;display:grid;place-items:center}.answer-label input:checked+.answer-dot{border-color:var(--accent);background:var(--accent)}.answer-label input:checked+.answer-dot:after{content:'';width:9px;height:9px;background:var(--on-accent);border-radius:50%}.quiz-nav{display:flex;justify-content:space-between;margin-top:33px;gap:15px}.keyboard-hint{text-align:center;color:var(--muted);margin-top:22px}.chapter-message{margin-top:25px;font-size:16px;color:var(--accent);text-align:center;min-height:27px}.error{font-size:16px;color:var(--danger);margin-top:15px}.result-heading{display:flex;justify-content:space-between;align-items:center;gap:24px;margin:34px 0 28px}.result-heading h1{font-size:42px}.result-heading p{margin-top:8px;font-size:15px}.result-summary{display:grid;grid-template-columns:200px 1fr;gap:40px;padding:36px;background:var(--soft);border-radius:20px;align-items:center}.result-number{font-size:110px;font-weight:800;line-height:1;text-align:center;color:var(--accent);border-inline-end:1px solid var(--line);padding-inline-end:30px}.result-number small{display:block;font-size:17px;font-weight:600;margin-top:15px;line-height:1.4}.result-summary h2{font-size:34px;margin-bottom:13px}.result-summary p{max-width:66ch}.result-summary .result-caution{font-size:15px;color:var(--muted);margin-top:15px}.result-columns{display:grid;grid-template-columns:1fr 1fr;gap:65px}.result-section{padding-block:37px}.result-section h2{margin-bottom:13px}.result-section>p{font-size:16px}.score-list{margin-top:24px}.score-row{display:grid;grid-template-columns:145px 1fr 40px;align-items:center;gap:13px;margin:13px 0;font-size:16px}.score-track{height:8px;background:var(--line);border-radius:4px;overflow:hidden}.score-fill{height:100%;background:var(--accent);border-radius:4px}.score-value{text-align:end;font-size:15px;font-variant-numeric:tabular-nums}.score-label{white-space:nowrap}.score-label b{display:inline-block;min-width:20px;color:var(--accent)}.score-row.leading .score-label{font-weight:750}.wing-choices{display:grid;grid-template-columns:1fr 1fr;gap:20px;margin-top:22px}.wing-choice{padding-top:15px;border-top:2px solid var(--line)}.wing-choice.suggested{border-color:var(--accent)}.wing-choice h3{font-size:22px}.wing-choice p{font-size:16px;margin-top:8px}.wing-score{font-size:15px;color:var(--muted);margin-top:7px}.result-badge{display:inline-block;background:var(--surface);border-radius:6px;padding:3px 9px;font-size:14px;color:var(--accent);margin-top:10px}.instinct-section{background:var(--mint);padding:30px 34px;border-radius:20px;margin:0 0 4px}.section-intro{display:grid;grid-template-columns:1fr 1.5fr;gap:35px;margin-bottom:25px}.section-intro p{font-size:17px}.instinct-summary{font-size:23px;font-weight:700;margin-bottom:18px}.instinct-grid{display:grid;grid-template-columns:repeat(3,1fr);gap:27px}.instinct-item{border-top:1px solid var(--line);padding-top:20px}.instinct-item h3{font-size:22px;margin-bottom:10px}.instinct-item p{font-size:16px}.instinct-item .score-row{grid-template-columns:1fr 40px}.type-tabs{display:flex;flex-wrap:wrap;gap:9px;margin:22px 0}.type-tab{height:43px;min-width:43px;padding:0 13px;border-radius:8px;background:var(--surface);border:1px solid var(--line);font-weight:700}.type-tab[aria-pressed=true]{background:var(--accent);color:var(--on-accent);border-color:transparent}.type-detail{border-top:1px solid var(--line);padding-top:24px}.type-detail>p{max-width:75ch;margin-top:13px}.detail-grid{display:grid;grid-template-columns:1fr 1fr;gap:30px;margin-top:24px}.detail-grid h3{font-size:19px;margin-bottom:7px}.detail-grid p{font-size:17px}.practice{background:var(--soft);border-radius:12px;padding:20px 25px;margin-top:24px}.practice h3{font-size:21px;margin-bottom:8px}.practice .reflection{font-size:17px;margin-top:10px;font-weight:650}.export-panel{background:var(--surface);border:1px solid var(--line);border-radius:16px;padding:27px 30px}.export-panel h2{font-size:26px;margin-bottom:8px}.export-panel p{font-size:16px;color:var(--muted)}.export-actions{display:flex;flex-wrap:wrap;gap:12px;margin-top:22px}.export-actions .button{font-size:16px;padding-inline:17px}.export-panel #export-status{margin-top:15px}.result-footer{display:flex;justify-content:space-between;gap:20px;margin-top:17px;font-size:16px}.about-panel{border-top:1px solid var(--line);padding:35px 0;margin-top:35px;max-width:80ch}.about-panel h2{margin-bottom:18px}.about-panel p{font-size:17px}.about-panel details{margin-top:15px;border-bottom:1px solid var(--line);padding-bottom:15px}.about-panel summary{font-weight:700;cursor:pointer;padding:10px 0;min-height:44px}.about-panel details p{margin-top:13px}.sources{padding-inline-start:22px;font-size:16px}.sources li{margin-top:9px}.notice{background:var(--soft);padding:15px 20px;margin:20px auto;border-radius:10px;font-size:16px;max-width:75ch}dialog{background:var(--surface);color:var(--ink);border:1px solid var(--line);border-radius:16px;padding:30px;max-width:460px;width:calc(100% - 35px)}dialog::backdrop{background:rgb(20 18 32 / .5)}dialog h2{margin-bottom:15px}dialog p{font-size:17px}.dialog-actions{display:flex;justify-content:flex-end;gap:12px;margin-top:25px}
@media(max-width:900px){.intro-grid{gap:30px}.map-panel{padding-inline:20px}.wheel-node{width:39px;height:39px}.quiz-layout{grid-template-columns:175px 1fr;gap:35px}.journey{padding-inline-end:18px}.journey h2{font-size:26px}.result-columns{gap:30px}.score-row{grid-template-columns:135px 1fr 35px}.result-summary{grid-template-columns:140px 1fr;gap:25px}.result-number{font-size:90px;padding-inline-end:20px}}
@media(max-width:650px){body{font-size:17px}main{padding:0 22px}.site-header{padding:18px 22px}.brand{font-size:22px}.brand-note{font-size:12px}.header-actions{gap:17px;font-size:15px}.intro-grid{grid-template-columns:1fr;padding:27px 0 30px;gap:31px}.intro-copy h1{font-size:43px}.lead{font-size:19px;margin-top:20px}.quiz-facts{margin-block:20px;font-size:15px}.intro-copy .large{width:100%;justify-content:space-between}.intro-note{max-width:none}.map-panel{padding:20px 24px}.wheel{max-width:305px}.wheel-node{width:40px;height:40px}.map-explainer{min-height:92px}.intro-bottom{grid-template-columns:1fr;gap:25px;padding-top:26px}.intro-bottom h2{font-size:23px}.site-footer{padding:22px;margin-top:32px;flex-direction:column;gap:6px}.quiz-layout{display:block;padding:15px 0 20px;min-height:0}.journey{border:0;padding:0;display:flex;justify-content:space-between;align-items:center;gap:12px;margin-bottom:24px}.journey h2,.journey>p,.journey ol{display:none}.journey #save-status{display:block;font-size:12px}.journey .text-btn{font-size:15px}.progress-caption{font-size:14px}#answers-form{margin-top:26px}#question-text{font-size:28px;min-height:0;line-height:1.42;max-width:none}#answer-hint{margin:20px 0 17px;font-size:15px}.answers{grid-template-columns:1fr;gap:9px}.answer-label{min-height:55px;flex-direction:row;justify-content:flex-start;padding:13px 17px;gap:16px;text-align:start;font-size:17px}.answer-label:has(input:checked){padding:12px 16px}.answer-dot{width:22px;height:22px;flex-shrink:0}.quiz-nav{margin-top:23px}.quiz-nav .button{flex:1;min-height:49px}.keyboard-hint{display:none}.chapter-message{font-size:15px;margin-top:20px}.result-heading{margin:24px 0;align-items:flex-start}.result-heading h1{font-size:33px}.result-heading .text-btn{font-size:14px}.result-summary{grid-template-columns:1fr;padding:26px;gap:22px}.result-number{border:0;border-bottom:1px solid var(--line);padding:0 0 18px;text-align:start;font-size:72px;display:flex;align-items:center;gap:20px}.result-number small{font-size:16px;margin:0;max-width:16ch}.result-summary h2{font-size:29px}.result-summary p{font-size:17px}.result-columns{grid-template-columns:1fr;gap:0}.result-section{padding-block:28px}.result-section h2{font-size:25px}.result-columns .result-section+.result-section{border-top:1px solid var(--line)}.score-row{grid-template-columns:135px 1fr 32px;gap:10px;font-size:15px}.instinct-section{padding:25px 23px}.section-intro{display:block}.section-intro h2{font-size:26px;margin-bottom:15px}.instinct-grid{grid-template-columns:1fr;gap:25px}.instinct-summary{font-size:21px}.instinct-item{padding-top:18px}.detail-grid{grid-template-columns:1fr;gap:20px}.export-panel{padding:23px}.export-actions{flex-direction:column;gap:10px}.export-actions .button{width:100%}.result-footer{font-size:15px}.practice{padding:20px}.wing-choices{gap:18px}.wing-choice h3{font-size:20px}}
@media(prefers-reduced-motion:no-preference){.map-panel{animation:reveal-map .7s var(--ease) both}@keyframes reveal-map{from{clip-path:inset(0 0 12% 0 round 26px);transform:translateY(8px)}to{clip-path:inset(0 0 0 0 round 26px);transform:translateY(0)}}}
@media(prefers-reduced-motion:reduce){*,*::before,*::after{animation:none!important;transition:none!important;scroll-behavior:auto!important}}
@media print{:root,:root[data-theme=dark]{color-scheme:light;--paper:white;--surface:white;--ink:#222;--muted:#555;--line:#ccc;--accent:#44377d;--on-accent:white;--soft:#f4f1fa;--mint:#f0f6f3}body{font-size:11pt;background:white}.site-header,.site-footer,.export-panel,.result-footer,.type-tabs,#edit-btn,#about-panel,#notice,.skip-link,dialog{display:none!important}main{max-width:none;padding:0}.result-heading{margin-top:0}.result-heading h1{font-size:27pt}.result-summary{padding:20px;border:1px solid #ddd}.result-summary h2{font-size:22pt}.result-number{font-size:64pt}.result-columns{gap:30px}.result-section{padding-block:22px}.result-section h2,.section-intro h2{font-size:19pt}.instinct-section{padding:22px;border:1px solid #ddd}.score-row{margin:8px 0}.result-summary,.wing-choice,.instinct-item,.practice,.detail-grid>div{break-inside:avoid}.score-track,.score-fill{print-color-adjust:exact;-webkit-print-color-adjust:exact}a{color:inherit}#quiz-screen,#start-screen{display:none!important}@page{size:A4;margin:16mm}}

/* Keep the task surface quiet; explanations live in About. */
.save-choice{margin-top:16px}.map-explainer{min-height:78px}.journey ol{margin-top:24px}#save-status:empty,#export-status:empty{display:none}main{padding-bottom:34px}

.wing-choices:has(>.wing-choice:only-child){grid-template-columns:1fr}

.contrast-options{display:grid;grid-template-columns:1fr 1fr;gap:16px;margin-top:20px}.contrast-options>div{display:flex;align-items:flex-start;gap:12px;background:var(--soft);padding:18px;border-radius:12px}.contrast-options b{color:var(--accent);font-size:23px}.contrast-options p{font-size:19px;line-height:1.55}.paired-question #question-text{min-height:0}.instinct-section .section-intro{display:block}.instinct-section .section-intro h2{max-width:none}@media(max-width:650px){.contrast-options{grid-template-columns:1fr;gap:10px}.contrast-options>div{padding:13px}.contrast-options p{font-size:18px}}
</style>
<!-- catalog metadata:start -->
<title>מבחן אישיות אניאגרמה | ארגז הכלים של NH Local</title>
    <meta name="description" content="כלי לבדיקת אישיות מבוסס האניאגרמה - שיטה עתיקה המחלקת את העולם ל-9 טיפוסים מרכזיים.">
    <link rel="canonical" href="https://tools.ze-kal.top/tools/the_enneagram.html">
    <meta property="og:type" content="website">
    <meta property="og:locale" content="he_IL">
    <meta property="og:site_name" content="ארגז הכלים של NH Local">
    <meta property="og:title" content="מבחן אישיות אניאגרמה | ארגז הכלים של NH Local">
    <meta property="og:description" content="כלי לבדיקת אישיות מבוסס האניאגרמה - שיטה עתיקה המחלקת את העולם ל-9 טיפוסים מרכזיים.">
    <meta property="og:url" content="https://tools.ze-kal.top/tools/the_enneagram.html">
    <meta property="og:image" content="https://tools.ze-kal.top/assets/social-card.png">
    <meta property="og:image:width" content="1200"><meta property="og:image:height" content="630">
    <meta property="og:image:alt" content="ארגז הכלים של NH Local: סקילים, כלי דפדפן, סקריפטים ותוספי כרום">
    <meta name="twitter:card" content="summary_large_image">
    <script type="application/ld+json">{"@context": "https://schema.org", "@graph": [{"@type": "WebSite", "@id": "https://tools.ze-kal.top/#website", "url": "https://tools.ze-kal.top/", "name": "ארגז הכלים של NH Local", "inLanguage": "he"}, {"@type": "WebPage", "@id": "https://tools.ze-kal.top/tools/the_enneagram.html", "url": "https://tools.ze-kal.top/tools/the_enneagram.html", "name": "מבחן אישיות אניאגרמה | ארגז הכלים של NH Local", "description": "כלי לבדיקת אישיות מבוסס האניאגרמה - שיטה עתיקה המחלקת את העולם ל-9 טיפוסים מרכזיים.", "inLanguage": "he", "isPartOf": {"@id": "https://tools.ze-kal.top/#website"}}]}</script>
<!-- catalog metadata:end -->
</head>
<body>
  <a class="skip-link" href="#main">דילוג לתוכן</a>
  <header class="site-header">
    <a class="brand" href="#" id="home-link" aria-label="מבחן אניאגרמה, למסך הפתיחה">
      <svg viewBox="0 0 40 40" width="36" height="36" aria-hidden="true"><circle cx="20" cy="20" r="17"/><path d="M20 3 35 28H5ZM31 7 37 20 9 33 9 7 37 20 31 33Z"/></svg>
      <span>אניאגרמה</span>
    </a>
    <div class="header-actions"><button id="about-btn" class="text-btn">על המבחן</button><button id="theme-btn" class="icon-btn" aria-label="מעבר לתצוגה כהה" title="שינוי תצוגה"><svg viewBox="0 0 24 24" width="21" height="21" aria-hidden="true"><path d="M20 15.4A8.5 8.5 0 0 1 8.6 4 8.5 8.5 0 1 0 20 15.4Z"/></svg></button></div>
  </header>
  <main id="main" tabindex="-1">
    <section id="start-screen" class="screen" aria-labelledby="start-title">
      <div class="intro-grid">
        <div class="intro-copy">
          <h1 id="start-title" tabindex="-1">יש יותר מדרך אחת<br>להיות <span>עצמך.</span></h1>
          <p class="lead">מה מניע אותך? מגלים את הטיפוס, הכנפיים והאינסטינקטים במפה אישית אחת.</p>
          <div class="quiz-facts"><span>93 שאלות</span><span>כ-12 דקות</span><span>בקצב שלך</span></div>
          <button id="start-btn" class="button primary large">מתחילים להכיר <span aria-hidden="true">←</span></button>
          <label class="save-choice"><input type="checkbox" id="auto-save" checked> שמירת התקדמות במכשיר</label>
          <div id="resume-box" class="resume-box" hidden><p id="resume-text"></p><button id="resume-btn" class="text-btn">להמשיך מהמקום שעצרתי</button></div>
          <div id="saved-box" class="resume-box" hidden><p id="saved-text">יש במכשיר הזה תוצאה שמורה</p><button id="saved-btn" class="text-btn">לפתוח את התוצאה</button></div>
        </div>
        <div class="map-panel">
          <div id="intro-wheel" class="wheel"></div>
          <div class="map-explainer"><strong id="type-preview-title">מגלים את תשעת הטיפוסים</strong><p id="type-preview-text"></p></div>
        </div>
      </div>
    </section>

    <section id="quiz-screen" class="screen" aria-labelledby="question-text" hidden>
      <div class="quiz-layout">
        <aside class="journey" aria-label="התקדמות במבחן"><h2>הדרך שלך</h2><ol id="chapter-list"></ol><button id="pause-btn" class="text-btn">שמירה ויציאה</button><p id="save-status" class="small" role="status"></p></aside>
        <div class="question-area">
          <div class="progress-caption"><span id="chapter-name"></span><span id="question-counter"></span></div>
          <progress id="progress" value="0" max="93" aria-label="מספר השאלות שנענו"></progress>
          <form id="answers-form">
            <fieldset><legend id="question-text" tabindex="-1"></legend><div id="contrast-options" class="contrast-options" hidden></div><p id="answer-hint" class="muted">עד כמה זה מתאר אותך?</p><div id="answers-container" class="answers" aria-describedby="answer-hint"></div></fieldset>
            <p id="error-msg" class="error" role="alert" hidden>כדי להמשיך, צריך לבחור תשובה אחת.</p>
            <div class="quiz-nav"><button type="button" id="prev-btn" class="button secondary">→ הקודם</button><button type="submit" id="next-btn" class="button primary">הבא ←</button></div>
          </form>
        </div>
      </div>
    </section>

    <section id="results-screen" class="screen" aria-labelledby="results-title" hidden>
      <div class="result-heading"><div><h1 id="results-title" tabindex="-1">המפה האישית שלך</h1><p id="result-date" class="muted"></p></div><button id="edit-btn" class="text-btn">חזרה לתשובות</button></div>
      <div id="result-summary" class="result-summary"></div>
      <div class="result-columns"><section class="result-section" aria-labelledby="scores-title"><h2 id="scores-title">הסגנונות בתשובות שלך</h2><div id="type-scores" class="score-list"></div></section><section class="result-section" aria-labelledby="wing-heading"><h2 id="wing-heading">הגוונים שלצד הטיפוס</h2><div id="wing-result"></div></section></div>
      <section class="instinct-section" aria-labelledby="instinct-heading"><div class="section-intro"><h2 id="instinct-heading">לאן תשומת הלב הולכת?</h2></div><div id="instinct-result"></div></section>
      <section class="result-section" aria-labelledby="explore-heading"><h2 id="explore-heading">להכיר את תשעת הטיפוסים</h2><div id="explore-types" class="type-tabs" role="group" aria-label="בחירת טיפוס לקריאה"></div><div id="type-detail" class="type-detail" aria-live="polite"></div></section>
      <div class="export-panel"><div><h2>לקחת את התובנות איתך</h2><p>דוח אישי לקריאה חוזרת, לשמירה או להדפסה.</p></div><div class="export-actions"><button id="save-result-btn" class="button primary">שמירת התוצאה במכשיר</button><button id="download-btn" class="button secondary">הורדת דוח אישי</button><button id="print-btn" class="button secondary">הדפסה / PDF</button><button id="json-btn" class="text-btn">הורדת נתונים (JSON)</button></div><p id="export-status" class="small" role="status"></p></div>
      <div class="result-footer"><button id="restart-btn" class="text-btn">להתחיל מבחן חדש</button><button id="clear-btn" class="text-btn">מחיקת הנתונים מהמכשיר</button></div>
    </section>

    <section id="about-panel" class="about-panel" hidden aria-labelledby="about-title"><h2 id="about-title" tabindex="-1">על המבחן והשיטה</h2><p>זהו כלי להתבוננות עצמית, לא אבחון פסיכולוגי. כדאי לענות לפי הדפוסים שלך לאורך זמן. אפשר לבחור תשובה עם המקשים 1 עד 5 ולהמשיך עם Enter.</p><details><summary>שמירה ופרטיות</summary><p>התשובות מעובדות בדפדפן ואינן נשלחות לשרת. השמירה האוטומטית נעשית במכשיר הזה, ואפשר לבטל אותה במסך הפתיחה. במכשיר משותף כדאי לבטל שמירה או למחוק את הנתונים בסיום. קובצי דוח שהורדו אינם נמחקים במחיקת נתוני האתר.</p></details><p>האניאגרמה מציעה תשעה דפוסי מוטיבציה. לכל טיפוס שני שכנים במעגל, הנקראים כנפיים. כנף היא השפעה אפשרית של שכן, ולא בהכרח הטיפוס שבמקום השני בתוצאה.</p><p>השאלון כולל 54 אמירות על הטיפוסים, שש לכל טיפוס, 21 אמירות על אינסטינקטים ו-18 השוואות בין מניעים. כל טיפוס משתתף בארבע השוואות, שתיים מול כל שכן. השאלות נכתבו מחדש והורחבו בעברית מקורית. זה אינו שאלון RHETI או IVQ ואינו תרגום או גרסה רשמית שלהם.</p><p>שלושת תחומי הקשב הם שימור עצמי (SP), חברתי (SO), ומשיכה ועוצמה (SX). המינוח והפרשנות משתנים בין אסכולות. כאן לא מסיקים חברותיות מהאינסטינקט החברתי, ולא מסיקים את האינסטינקט מהטיפוס או מכישורים בין אישיים.</p><details><summary>איך מחושב הציון?</summary><p>כל תשובה מדורגת מ-1 עד 5. בכל סולם יש גם אמירה בכיוון ההפוך, שהניקוד שלה מתהפך. ממוצע התשובות מומר לסולם 0 עד 100. לכל סולם משקל עצמאי ושווה בין השאלות שבו.</p><p>הטיפוס המוביל נבחר לפי ציוני הסגנון. ההשוואות מחדדות בין מועמדים שמרוחקים עד 15 נקודות מהמוביל: שתי העדפות עקביות של שכן מועמד, בממוצע של 75 לפחות, מסירות את הטיפוס שהפסיד מהבחירה הסופית. מבין הנותרים נבחר בעל הציון המקורי הגבוה. תשובות ניטרליות או סותרות אינן חוסמות תוצאה; אם כל המועמדים נפסלו בהשוואות, חוזרים למוביל המקורי. בתיקו מלא הסדר מספרי. כנף נבחנת רק בין שני השכנים, ודורשת ציון של 62.5 לפחות ולפחות 75% מציון הטיפוס. השכן החזק יותר מוצג ככנף מובילה גם כשהפער קטן. בתיקו בין השכנים אין כנף מובילה. חישוב האינסטינקטים נותר נפרד וללא שינוי.</p><p>אלה כללי תצוגה זהירים שנבחרו עבור הכלי, לא ספים שנקבעו במחקר פסיכומטרי. שאלון זה לא עבר תיקוף על מדגם אנושי. מענה אחיד לכל השאלות נשאר ללא טיפוס מוביל.</p></details><details><summary>מה המחקר אומר, ועל מה התבססנו?</summary><p>סקירה שיטתית של 104 מדגמים מצאה ראיות מעורבות למהימנות ולתוקף האניאגרמה, ומעט מחקר שתומך בהיבטים כמו כנפיים. השימוש כאן הוא לסקרנות ולהתבוננות, ולא לקבלת החלטות טיפוליות או תעסוקתיות.</p><ul class="sources"><li><a href="https://www.enneagraminstitute.com/how-the-enneagram-system-works/" target="_blank" rel="noopener noreferrer">Enneagram Institute: מבנה המודל, כנפיים ואינסטינקטים</a></li><li><a href="https://www.enneagraminstitute.com/type-descriptions/" target="_blank" rel="noopener noreferrer">Enneagram Institute: תשעת הטיפוסים</a></li><li><a href="https://pubmed.ncbi.nlm.nih.gov/33332604/" target="_blank" rel="noopener noreferrer">Hook ועמיתיו, 2021: סקירת המחקר</a></li></ul><p>ניסוח השאלות נבדק מול <a href="https://www.pewresearch.org/writing-survey-questions/" target="_blank" rel="noopener noreferrer">הנחיות Pew</a> ו<a href="https://www.frontiersin.org/journals/public-health/articles/10.3389/fpubh.2018.00149/full" target="_blank" rel="noopener noreferrer">סקירת שיטות לפיתוח שאלונים</a>. זמן המילוי הוא הערכה.</p><p class="small">נבדק בספטמבר 2026. סימולציות של סוכני AI משמשות לבדיקת ניסוח ולוגיקה בלבד ואינן ראיה לתוקף פסיכולוגי.</p></details><button id="close-about-btn" class="text-btn">סגירת ההסבר</button></section>
    <p id="notice" class="notice" role="status" hidden></p>
  </main>
  <dialog id="confirm-dialog" aria-labelledby="confirm-title" aria-describedby="confirm-description"><h2 id="confirm-title">להתחיל מחדש?</h2><p id="confirm-description"></p><div class="dialog-actions"><button id="confirm-cancel" class="button secondary">ביטול</button><button id="confirm-ok" class="button primary">אישור</button></div></dialog>
  <noscript><p class="notice">כדי לענות על המבחן ולחשב תוצאות, יש להפעיל JavaScript בדפדפן.</p></noscript>
  <script id="enneagram-engine">/* Original Hebrew reflection questionnaire. No third-party test items are reproduced. */
(function (root) {
  'use strict';
  const VERSION = '3.1.0';
  const CORE_WINDOW = 15;
  const PAIR_MIN = 75;
  const WING_MIN = 62.5;
  const WING_RATIO = 0.75;
  const WING_GAP = 0;
  const INSTINCT_GAP = 8;
  const typeItems = {
    1: [
      'גם כשאיש לא ידע, חשוב לי לפעול לפי מה שבעיניי נכון וראוי.',
      'כשמשהו נעשה באופן לקוי, קשה לי להניח לו בלי לנסות לתקן.',
      'אחרי טעות קטנה, הביקורת הפנימית שלי ממשיכה לעבוד גם כשהסביבה כבר המשיכה הלאה.',
      'במשימה משותפת, חשוב לי שהדרך תהיה ראויה ויסודית, גם אם קיצור דרך ייתן תוצאה מרשימה.',
      'כשמישהו מתנער מאחריות, מתעורר בי מתח שקשה לי לשחרר.',
      'קל לי לקבל עבודה לא מושלמת בלי להרגיש צורך לתקן אותה.'
    ],
    2: [
      'כשאני עוזר למישהו, התחושה שצריכים אותי מחזקת את תחושת הערך שלי.',
      'אני מבחין בצרכים של אחרים מהר יותר מכפי שאני נותן מקום לצרכים שלי.',
      'קשה לי לסרב לבקשת עזרה כשאני חושש שהסירוב ירחיק ממני אדם חשוב.',
      'אם נתתי מעצמי ולא שמו לב לכך, אני נפגע יותר ממה שאני מראה.',
      'במערכת יחסים חדשה, אני מנסה להתקרב דרך תמיכה, מחוות ועשייה למען הצד השני.',
      'אני מרגיש אהוב גם כשאיני מועיל לאף אחד, ולא צריך להרוויח קרבה באמצעות נתינה.'
    ],
    3: [
      'כשאני לא עומד ביעד, קשה לי להפריד בין התוצאה לבין הערך שלי כאדם.',
      'אני מתאים את האופן שבו אני מציג את עצמי למה שהסביבה מחשיבה להצלחה.',
      'חשוב לי שאנשים יראו בי אדם מצליח, גם כשאני לא אומר זאת בקול.',
      'בפרויקט חדש, אני מחפש במהירות מה יביא לתוצאה שאפשר להציג.',
      'גם בזמן פנוי, אני מתקשה לנוח אם אין לי תחושה שהתקדמתי או השגתי משהו.',
      'גם בתקופה ללא הישגים, תחושת הערך שלי נשארת יציבה למדי.'
    ],
    4: [
      'חשוב לי שהבחירות שלי יבטאו מי אני, גם אם הן שונות ממה שמקובל סביבי.',
      'כשחוויה מרגישה שטחית או לא אותנטית, קשה לי להתחבר אליה גם אם היא נעימה.',
      'אני חוזר לרגשות שלי כדי להבין מה הם מגלים על הזהות שלי.',
      'כשאני משווה את חיי לחיי אחרים, אני שם לב במיוחד לדבר המשמעותי שחסר לי.',
      'כשלא מבינים את העולם הפנימי שלי, מתעוררת בי תחושה עמוקה שאני שונה.',
      'לא מפריע לי במיוחד להיות דומה לאחרים; אין לי צורך שהבחירות שלי יבטאו זהות ייחודית.'
    ],
    5: [
      'לפני שאני נרתם לדבר חדש, אני בודק כמה זמן ואנרגיה יישארו לי לעצמי.',
      'אני דוחה לפעמים השתתפות עד שארגיש שיש לי מספיק ידע כדי להתמודד בכוחות עצמי.',
      'כשדורשים ממני הרבה זמינות, אני מצמצם קשר כדי לשמור על המשאבים שלי.',
      'מול מצב טעון, התגובה הראשונה שלי היא להתרחק מעט ולנסות להבין אותו.',
      'אני מעדיף להבין נושא לעומק בעצמי לפני שאחשוף לאחרים את מה שאני חושב עליו.',
      'קל לי להיכנס לעשייה בלי להבין הרבה מראש, גם אם אצטרך להיעזר באחרים לאורך הדרך.'
    ],
    6: [
      'לפני החלטה חשובה, אני מחפש מה עלול להשתבש ולמי אפשר לפנות אם זה יקרה.',
      'חשוב לי לבדוק אם אפשר לסמוך על אדם, גם כשהוא משדר ביטחון וסמכות.',
      'גם אחרי שקיבלתי עצה טובה, אני עשוי להמשיך לבדוק אם היא באמת אמינה.',
      'אני מכין חלופות מראש כי קשה לי להישען על ההנחה שהכול יסתדר.',
      'כשאני חושש ממשהו, אני מרגיש צורך לבדוק אותו היטב או להתעמת איתו כדי לדעת היכן אני עומד.',
      'לאחר החלטה בתנאי אי ודאות, בדרך כלל קל לי להפסיק לבדוק אם פספסתי סכנה.'
    ],
    7: [
      'הידיעה שיש עוד אפשרויות וחוויות בהמשך נותנת לי אנרגיה גם ביום קשה.',
      'כשעולה בי תחושה לא נעימה, אני מחפש מהר עיסוק או רעיון שיחזיר לי מצב רוח טוב.',
      'כשהמציאות מכבידה, המחשבות שלי נודדות לתוכניות מרגשות יותר.',
      'אחרי אכזבה, אני ממהר למצוא את ההזדמנות החדשה שבה כדי לא להישאר עם הכאב.',
      'קשה לי לוותר על אפשרויות מעניינות, ולכן אני מתחייב לפעמים ליותר ממה שאוכל להספיק.',
      'קל לי להישאר עם אכזבה או שעמום בלי לחפש במהירות משהו נעים יותר להתמקד בו.'
    ],
    8: [
      'כשמנסים להכתיב לי איך לפעול, אני מרגיש צורך ברור להחזיר לעצמי שליטה.',
      'אני מעדיף לומר אמת לא נוחה ישירות מאשר להרגיש שמנסים לנהל אותי בעקיפין.',
      'כשמישהו מנצל אדם קרוב אליי, אני נכנס לעימות כדי להגן עליו גם במחיר אישי.',
      'קשה לי להראות תלות או פגיעות, כי אני חושש שהדבר ייתן לאחרים כוח עליי.',
      'במצב של חוסר צדק, אני נוטה לתפוס עמדה ולהפעיל כוח כדי לשנות את המצב.',
      'נוח לי שאחרים מחזיקים בשליטה גם בהחלטות שנוגעות לי, בלי צורך לבסס את העצמאות שלי.'
    ],
    9: [
      'אני מוותר לפעמים על דבר שחשוב לי כדי לא להפר את השקט ביני לבין אחרים.',
      'קל לי להבין מה כולם רוצים, אבל קשה לי לזהות מה אני רוצה בעצמי.',
      'אני דוחה שיחה לא נעימה גם כשהדחייה משאירה בעיה לא פתורה.',
      'אני עשוי להסכים כלפי חוץ כדי למנוע מתח, אף שבתוכי יש התנגדות.',
      'כשיש מתח, אני נשאב לפעילות מוכרת ומרגיעה כדי לא לחשוב על מה שמטריד אותי.',
      'אני מבטא רצון שונה משל אחרים בקלות יחסית, גם אם הדבר יוצר מתח בינינו.'
    ]
  };
  const instinctItems = {
    sp: [
      'ביום עמוס, תשומת הלב שלי חוזרת באופן טבעי לשאלה אם אכלתי, נחתי ודאגתי לגוף שלי.',
      'כשאני בוחר מקום לשהות בו, תנאי המחיה והנוחות המעשית תופסים אצלי מקום מרכזי.',
      'אני מקדיש מחשבה קבועה לתקציב, למלאי ולמשאבים שיאפשרו לי להסתדר לאורך זמן.',
      'גם כשהכול רגוע, אני שם לב אם השגרה שלי תומכת בבריאות ובאנרגיה שלי.',
      'בזמן פנוי, אני נמשך לסידור הדברים שיתנו לי בסיס נוח ויציב לימים הבאים.',
      'כשאני נכנס למקום חדש, אני מבחין מהר בתנאים הפיזיים: טמפרטורה, אוכל ומקום לנוח.',
      'ענייני תחזוקה יומיומיים, כמו ארוחות, מנוחה ותקציב, נוטים להישאר מחוץ לתשומת הלב שלי.'
    ],
    so: [
      'בקבוצה חדשה, אני קולט מהר מי קשור למי ומה התפקיד של כל אחד.',
      'חשוב לי להבין כיצד אני משתלב במעגל הרחב יותר, גם כשאיני רוצה להיות במרכז.',
      'אני שם לב לכללים הלא כתובים שקובעים מה מקובל בקבוצה.',
      'התחושה שאני תורם למשהו משותף נותנת לי כיוון ומשמעות.',
      'אני משקיע בשמירה על קשר עם קהילה או מעגל חברתי, גם כשאין צורך מעשי מיידי.',
      'במפגש, תשומת הלב שלי נמשכת לשאלה מי שייך ומי נשאר מחוץ למעגל.',
      'המקום שלי בקבוצות והקשרים ביניהן כמעט שאינם מעסיקים אותי ביומיום.'
    ],
    sx: [
      'אני שם לב במהירות למפגש או לרעיון שמדליקים בי תחושת חיות חזקה.',
      'אני נמשך לחוויות שיש בהן ניצוץ ועוצמה, גם כשאינן מועילות או נוחות במיוחד.',
      'כשנוצר חיבור מסקרן, אני רוצה להעמיק בו ולהקדיש לו תשומת לב מרוכזת.',
      'קשר נעים אך חסר חיות משאיר אותי עם תחושה שחסר בו משהו מרכזי.',
      'אני מזהה במהירות אם יש ביני לבין אדם אחר כימיה שמושכת אותי להיכרות עמוקה יותר.',
      'אני מחפש מפגשים ועיסוקים שיכולים לסחוף אותי ולשנות משהו בי.',
      'תחושת ניצוץ או משיכה עזה כמעט שאינה משפיעה על הבחירה שלי בקשרים ובעיסוקים.'
    ]
  };
  const types = {
    1: {name:'הפרפקציוניסט', aliases:['המחוקק','מתקן העולם'], theme:'לעשות את הדבר הנכון', color:'#a95829', description:'הדפוס הזה מחפש יושרה, דיוק ואחריות. הצורך לפעול כראוי עשוי לעזור לשפר דברים, ולפעמים להפוך לביקורת פנימית שקשה להשקיט.', strength:'יכולת להבחין במה שדורש תיקון ולהשקיע בו בהתמדה.', cost:'המתח בין המצוי לרצוי עלול להשאיר מעט מקום למנוחה ולחמלה.', practice:'לבחור היום משימה אחת ולהחליט מראש מה ייחשב בה טוב מספיק.', reflection:'אם לא הייתי צריך להצדיק את עצמי, מה הייתי מרשה לעצמי עכשיו?'},
    2: {name:'המסייע', aliases:['הנותן','התומך'], theme:'להרגיש אהוב וחשוב', color:'#a34356', description:'הדפוס הזה מחפש קרבה דרך נתינה ותשומת לב לאחרים. לפעמים הצורך להיות נחוץ מקשה לזהות צורך אישי או לבקש משהו במפורש.', strength:'יכולת לזהות מצוקה, להציע עזרה וליצור חום בקשר.', cost:'נתינה ללא בקשה ברורה עלולה להתחלף באכזבה כשלא מקבלים הכרה.', practice:'לבקש היום דבר קטן ישירות, בלי להקדים לו שירות או טובה.', reflection:'מה אני צריך גם אם אף אחד לא צריך ממני דבר?'},
    3: {name:'ההישגי', aliases:['הביצועיסט','המצליחן'], theme:'להרגיש בעל ערך דרך עשייה', color:'#946021', description:'הדפוס הזה מכוון לתוצאות, להתקדמות ולהכרה. הוא יודע להתאים את עצמו למשימה, אך עשוי לקשור את תחושת הערך לאופן שבו ההישגים נראים מבחוץ.', strength:'יכולת להפוך מטרה לעשייה ולהניע תהליך קדימה.', cost:'המרדף אחר התוצאה עלול לדחוק הצידה עייפות, רגשות ורצונות אישיים.', practice:'להקדיש זמן קצר לדבר בעל ערך עבורך שאין לו תוצאה שאפשר להציג.', reflection:'מה הייתי בוחר אילו איש לא היה יודע שהצלחתי?'},
    4: {name:'האינדיבידואליסט', aliases:['הרומנטיקן','הדרמטי'], theme:'לחיות מתוך זהות ומשמעות', color:'#7b4b9c', description:'הדפוס הזה מקשיב לעולם הפנימי ומחפש ביטוי אישי אותנטי. לעיתים תשומת הלב נמשכת למה שחסר, עד שקשה לחוש את מה שכבר נוכח.', strength:'רגישות לגוונים רגשיים ויכולת לתת לחוויה משמעות אישית.', cost:'השוואה לאידיאל או לאחרים עלולה להעמיק תחושת חוסר ושונות.', practice:'לתת שם לרגש הנוכחי, ואז לעשות פעולה קטנה גם בלי לחכות למצב הרוח המתאים.', reflection:'מה בחיים שלי ראוי לתשומת לב גם כשהוא רגיל ופשוט?'},
    5: {name:'החוקר', aliases:['הצופה','המדען'], theme:'להבין ולהיות מסוגל', color:'#3c6195', description:'הדפוס הזה מחפש הבנה, עצמאות ומרחב לעיבוד. כשהדרישות נחוות כמציפות, הוא עשוי להגן על הזמן והאנרגיה באמצעות התרחקות.', strength:'יכולת להעמיק, לזהות מבנים ולחשוב באופן עצמאי.', cost:'ההמתנה למספיק ידע או אנרגיה עלולה לדחות השתתפות והתנסות.', practice:'לשתף רעיון שעדיין אינו מושלם, או להשתתף בצעד קטן לפני שהכול ברור.', reflection:'מה אפשר ללמוד דווקא מתוך מעורבות ולא רק מתוך התבוננות?'},
    6: {name:'הנאמן', aliases:['הספקן'], theme:'למצוא על מה אפשר לסמוך', color:'#287a7c', description:'הדפוס הזה בוחן אמינות, אחריות והיערכות. החיפוש אחר ביטחון עשוי להתבטא בבדיקות ובבקשת תמיכה, ולעיתים דווקא בעימות ישיר עם החשש.', strength:'יכולת לצפות קשיים, לשאול שאלות טובות ולעמוד לצד אחרים.', cost:'בדיקה נוספת ועוד אחת עלולות להרחיק מתחושת הכרעה.', practice:'בהחלטה קטנה, להגדיר מראש כמה מידע מספיק ואז לבחור.', reflection:'איזה חלק מהמצב דורש עוד מידע, ואיזה חלק דורש אמון ביכולת שלי להתמודד?'},
    7: {name:'הנלהב', aliases:['הנהנתן'], theme:'להשאיר מקום לאפשרויות', color:'#907022', description:'הדפוס הזה מחפש חופש, חיות ואפשרויות. הוא עשוי להתרחק מכאב או מתחושת הגבלה באמצעות תוכניות, רעיונות וחוויות חדשות.', strength:'יכולת לראות אפשרויות, לאלתר ולהביא התלהבות.', cost:'המעבר לדבר הבא עלול לבוא על חשבון עומק, השלמה ומפגש עם קושי.', practice:'להישאר עוד כמה דקות במשימה אחת או ברגש לא נעים, בלי לפתוח חלופה חדשה.', reflection:'מה אמצא כאן אם לא אמהר לעבור הלאה?'},
    8: {name:'המאתגר', aliases:['המנהיג','הבוס'], theme:'לשמור על עצמאות והשפעה', color:'#a14739', description:'הדפוס הזה רגיש לשליטה מבחוץ ומחפש יכולת לפעול ולהגן. הוא נוטה לפגוש קושי ישירות, אך עשוי להתקשות לחשוף צורך או פגיעות.', strength:'יכולת לתפוס עמדה, להציב גבול ולהגן על מה שחשוב.', cost:'עוצמה וישירות עלולות להשאיר פחות מקום להקשבה ולסיוע מאחרים.', practice:'לבטא צורך אחד בלי להסתיר אותו מאחורי דרישה, ולהקשיב לפני תגובה.', reflection:'איפה אפשר להישען על מישהו בלי לוותר על העצמאות שלי?'},
    9: {name:'משכין השלום', aliases:['המגשר'], theme:'לשמור על שקט וחיבור', color:'#4c7955', description:'הדפוס הזה מחפש הרמוניה ורואה כמה נקודות מבט. לפעמים הוא שומר על השקט באמצעות דחיית רצונותיו או הימנעות ממתח שדורש פעולה.', strength:'יכולת להקשיב, להכיל מורכבות וליצור מרחב נעים.', cost:'ההסתגלות לסביבה עלולה לטשטש סדרי עדיפויות ורצון אישי.', practice:'לבחור היום העדפה קטנה ולומר אותה בקול לפני שמבררים מה כולם רוצים.', reflection:'מה חשוב לי כאן, גם אם מישהו אחר יעדיף אחרת?'}
  };
  const instincts = {
    sp: {name:'שימור עצמי', code:'SP', description:'תשומת לב לגוף, לאנרגיה, למשאבים ולבסיס המעשי של החיים. זהו תחום קשב, ולא מדד לאנוכיות או לרמת החרדה.', practice:'לשים לב גם לקשר ולמשמעות, לצד הטיפול בבסיס המעשי.'},
    so: {name:'חברתי', code:'SO', description:'תשומת לב לשייכות, לתפקיד בקבוצה ולקשרים בין אנשים. אפשר להיות שקטים ומופנמים ועדיין להיות קשובים מאוד לממד הזה.', practice:'לבדוק מה נכון לך אישית, גם כשברור מה מצופה בקבוצה.'},
    sx: {name:'משיכה ועוצמה', code:'SX', description:'תשומת לב לכימיה, לניצוץ ולחוויות שיוצרות מעורבות עמוקה. זה אינו מדד לחברותיות או ליכולת לקיים קשר זוגי, וקרבה חשובה בכל שלושת האינסטינקטים.', practice:'לתת מקום גם לשגרה ולקשרים שאינם דורשים עוצמה מתמדת.'}
  };
  const wingNotes = {
    '1w9':'השאיפה לתקן עשויה לקבל גוון מתון, סבלני ומגשר, עם רצון לשפר בלי ליצור חיכוך מיותר.',
    '1w2':'השאיפה לתקן עשויה להתבטא במעורבות אישית, בליווי ובעזרה לאנשים מסוימים.',
    '2w1':'הנתינה עשויה לקבל גוון מצפוני ומאופק, עם דגש על אחריות ועל הדרך הראויה לעזור.',
    '2w3':'הנתינה עשויה להשתלב ביוזמה, בהצגת יכולות ובקידום אנשים ומטרות.',
    '3w2':'החתירה להישגים עשויה להיעזר ביצירת קשר, בעידוד אחרים וברצון להיות גם אהוב.',
    '3w4':'החתירה להישגים עשויה לקבל ביטוי אישי ומקורי, עם רצון שהתוצאה תשקף זהות ייחודית.',
    '4w3':'חיפוש הזהות עשוי להשתלב ברצון להוציא את הביטוי האישי לעולם ולקבל עליו הכרה.',
    '4w5':'חיפוש הזהות עשוי לקבל אופי פרטי וחקרני יותר, עם העמקה ברעיונות ובחוויה הפנימית.',
    '5w4':'הצורך להבין עשוי להשתלב בדמיון, ברגישות ובחיפוש אחר משמעות אישית.',
    '5w6':'הצורך להבין עשוי להתמקד בבדיקה שיטתית, באמינות ובפתרון בעיות מעשיות.',
    '6w5':'חיפוש הביטחון עשוי להישען על מחקר עצמאי, על ניתוח ועל שמירת מרחק לצורך בדיקה.',
    '6w7':'חיפוש הביטחון עשוי להשתלב בקלילות, באפשרויות חדשות ובקשר עם אנשים.',
    '7w6':'חיפוש האפשרויות עשוי להשתלב בשיתוף, במחויבות ובתשומת לב למה שיספק תמיכה.',
    '7w8':'חיפוש האפשרויות עשוי לקבל ביטוי ישיר ונחוש יותר, עם דגש על חופש פעולה.',
    '8w7':'העצמאות והישירות עשויות להשתלב בקצב מהיר, ביוזמה ובתיאבון לחוויות חדשות.',
    '8w9':'העצמאות והישירות עשויות לקבל גוון שקט ויציב יותר, עם סבלנות לפני פעולה.',
    '9w8':'השאיפה להרמוניה עשויה להשתלב בעמידה על גבולות ובהגנה על אנשים ועל מרחב אישי.',
    '9w1':'השאיפה להרמוניה עשויה להשתלב במצפוניות, באחריות וברצון לעשות את הדבר הראוי.'
  };
  // Interleave constructs to avoid consecutive blocks that reveal the scoring key.
  const questions = [];
  for (let round = 0; round < 6; round++) {
    for (let step = 0; step < 9; step++) {
      const type = ((step * 4 + round * 2) % 9) + 1;
      questions.push({id:`t${type}-${round+1}`, scale:String(type), reverse:round===5, text:typeItems[type][round]});
      if ([2,5,8].includes(step)) {
        const instinct = ['sp','so','sx'][(Math.floor(step/3)+round)%3];
        questions.push({id:`${instinct}-${round+1}`,scale:instinct,reverse:false,text:instinctItems[instinct][round]});
      }
    }
  }
  ['so','sp','sx'].forEach(key => questions.push({id:`${key}-7`,scale:key,reverse:true,text:instinctItems[key][6]}));
  // Equal exposure: two original comparisons for each adjacent pair, four per type.
  // The second item reverses option order; 3 explicitly leaves the preference open.
  const contrastItems = [
    [1,2,'כשאני שוקל להעיר לאדם קרוב, מה משפיע עליי יותר?','הרצון שהדבר ייעשה בדרך הנכונה.','הרצון לשמור על הקרבה בינינו.'],
    [2,3,'כשאני משקיע הרבה באנשים, מה חסר לי יותר אם אינו חוזר אליי?','התחושה שאני נחוץ ואהוב.','הכרה ביכולת ובהישגים שלי.'],
    [3,4,'דרך פעולה מצליחה אינה מרגישה אישית במיוחד. למה אני נוטה?','לאמץ אותה כדי להגיע לתוצאה טובה.','לחפש דרך שתבטא אותי, גם במחיר של הצלחה פחותה.'],
    [4,5,'כשקשה לי לשתף במה שעובר עליי, מה מעסיק אותי יותר?','החשש שלא יבינו את החוויה האישית שלי.','החשש שהשיחה תדרוש ממני יותר כוחות משיש לי.'],
    [5,6,'לפני משימה לא מוכרת, מה נותן לי יותר ביטחון?','הבנה שתאפשר לי להתמודד בכוחות עצמי.','תוכנית בדוקה שאפשר לסמוך עליה כשמשהו משתבש.'],
    [6,7,'כשעולה דאגה שמכבידה עליי, לאן תשומת הלב שלי פונה?','לבדיקת הסיכון ולמציאת דרך להיערך אליו.','לאפשרות מעודדת שתעזור לי לצאת מהתחושה.'],
    [7,8,'כשמגבילים את חופש הפעולה שלי, מה חשוב לי יותר להשיג?','אפשרויות אחרות שיאפשרו לי להמשיך ליהנות ולהתקדם.','יכולת לקבוע בעצמי, גם אם אצטרך להישאר בעימות.'],
    [8,9,'אדם קרוב דוחף להחלטה שאינה מתאימה לי. למה אני נוטה?','להעמיד גבול ברור, גם אם השיחה תהפוך לעימות.','להרגיע את המצב, גם אם הרצון שלי יידחק בינתיים.'],
    [9,1,'בקבוצה מתגבשת הסכמה שיש בה ליקוי. מה מושך אותי יותר?','לשמור על ההסכמה ועל האווירה הרגועה.','לעצור ולתקן את הליקוי, גם אם זה ייצור מתח.'],
    [2,1,'עזרתי במשימה והדברים לא הסתדרו. מה נשאר איתי יותר?','האכזבה שהעזרה שלי לא חיזקה את הקשר.','התחושה שלא מילאתי את האחריות שלי כראוי.'],
    [3,2,'אחרי תקופה של עשייה מוצלחת, למה אני מייחל יותר?','שיראו מה הצלחתי להשיג.','שארגיש קרוב וחשוב לאנשים שעזרתי להם.'],
    [4,3,'רגש קשה מתעורר באמצע פרויקט חשוב. למה אני נוטה?','לעצור כדי להבין מה הרגש אומר עליי.','לשים אותו בצד כדי להשלים את המשימה.'],
    [5,4,'כשאני חוזר לבד לחוויה מורכבת, מה אני מחפש יותר?','הסבר שייתן לי יכולת להתמודד איתה.','משמעות שתעזור לי להבין מי אני בתוכה.'],
    [6,5,'אחרי שאספתי מידע, מה נוטה לעכב את ההחלטה שלי?','ספק אם המידע והאנשים שמאחוריו אמינים מספיק.','תחושה שעדיין איני מבין מספיק כדי לפעול באופן עצמאי.'],
    [7,6,'לפני התחייבות ארוכה, מה מושך אותי יותר?','להשאיר פתוחות אפשרויות מעניינות שעוד עשויות להגיע.','לבסס מסגרת יציבה שאפשר להישען עליה.'],
    [8,7,'כשנוצר מאבק על הדרך שבה אפעל, למה אני נוטה?','להתעקש שלא יחליטו במקומי.','לחפש מוצא שיפתח עבורי חוויה טובה יותר.'],
    [9,8,'מתח עם אדם קרוב נמשך כמה ימים. מה התגובה הרגילה שלי?','לדחות את ההתנגשות ולקוות שהמתח יירגע.','לשים את הדברים על השולחן כדי להחזיר לעצמי השפעה.'],
    [1,9,'הדרך הפשוטה תסיים ויכוח, אבל אינה נראית לי נכונה. מה גובר אצלי?','הצורך לפעול לפי מה שאני מאמין שראוי.','הרצון להניח לוויכוח ולחזור לשקט.' ]
  ];
  contrastItems.forEach(([a,b,text,left,right],i)=>questions.push({id:`c${i+1}`,kind:'contrast',pair:[a,b],text,options:[left,right]}));
  const scaleKeys = [...Object.keys(types),...Object.keys(instincts)];
  function rank(scores, keys) { return keys.map(key=>({key,score:scores[key]})).sort((a,b)=>b.score-a.score); }
  function getWing(type, scores, primaryClear=true) {
    if (!types[type]) throw new Error('Unknown type');
    const adjacent = [type===1?9:type-1, type===9?1:type+1];
    const ranked = rank(scores, adjacent.map(String));
    const gap = ranked[0].score-ranked[1].score;
    const threshold = Math.max(WING_MIN,(scores[type]||0)*WING_RATIO);
    const eligible = ranked.filter(t=>t.score>=threshold).map(t=>Number(t.key));
    const status = !primaryClear ? 'conditional' : !eligible.length ? 'weak' : gap <= WING_GAP ? 'close' : 'suggested';
    return {adjacent,ranked,gap,threshold,eligible,status,dominant:status==='suggested'?Number(ranked[0].key):null};
  }

  function score(answers) {
    if (!Array.isArray(answers) || answers.length!==questions.length || Array.from(answers).some(v=>!Number.isInteger(v)||v<1||v>5)) {
      throw new Error(`Expected ${questions.length} integer answers between 1 and 5`);
    }
    const totals=Object.fromEntries(scaleKeys.map(k=>[k,0])),counts={...totals};
    const pairGroups={};
    questions.forEach((q,i)=>{
      if(q.kind==='contrast'){
        const [a,b]=q.pair,key=[a,b].sort((x,y)=>x-y).join('-');
        const group=pairGroups[key]||(pairGroups[key]={types:[Math.min(a,b),Math.max(a,b)],votes:[]});
        const firstScore=a===group.types[0]?(5-answers[i])*25:(answers[i]-1)*25;
        group.votes.push(firstScore);return;
      }
      totals[q.scale]+=q.reverse?6-answers[i]:answers[i];counts[q.scale]++;
    });
    const scores=Object.fromEntries(scaleKeys.map(k=>[k,(totals[k]/counts[k]-1)*25]));
    const comparisons=Object.values(pairGroups).map(({types,votes})=>{
      const mean=votes.reduce((a,b)=>a+b,0)/votes.length;
      const dominant=mean>=PAIR_MIN&&votes.every(v=>v>50)?types[0]:mean<=100-PAIR_MIN&&votes.every(v=>v<50)?types[1]:null;
      return {types,scores:{[types[0]]:mean,[types[1]]:100-mean},dominant};
    });
    const beats=(a,b)=>comparisons.some(p=>p.types.includes(a)&&p.types.includes(b)&&p.dominant===a);
    const typeRanking=rank(scores,Object.keys(types)),instinctRanking=rank(scores,Object.keys(instincts));
    const gap=typeRanking[0].score-typeRanking[1].score,uniform=answers.every(v=>v===answers[0]);
    const candidates=typeRanking.filter(t=>typeRanking[0].score-t.score<=CORE_WINDOW).map(t=>Number(t.key));
    // Start with the original ranking. Only clear comparisons between nearby
    // candidates can displace it; neutral, conflicting or distant pairs cannot veto it.
    const remaining=candidates.filter(n=>!candidates.some(other=>other!==n&&beats(other,n)));
    const primaryStatus=uniform?'undifferentiated':'suggested';
    const primary=uniform?null:(remaining[0]??Number(typeRanking[0].key));
    const instinctGap=instinctRanking[0].score-instinctRanking[1].score;
    const instinctStatus=uniform?'undifferentiated':instinctRanking[0].score<50?'weak':instinctGap<INSTINCT_GAP?'close':'suggested';
    const dominantInstinct=instinctStatus==='suggested'?instinctRanking[0].key:null;
    const stackClear=!!dominantInstinct && instinctRanking[1].score-instinctRanking[2].score>=INSTINCT_GAP;
    return {version:VERSION,scores,comparisons,typeRanking,instinctRanking,gap,primaryStatus,primary,candidates,
      wing:primary?getWing(primary,scores):null,instinctStatus,dominantInstinct,stackClear,uniform};
  }
  function validState(value) {
    if (!value || value.version!==VERSION || !Array.isArray(value.answers) || value.answers.length!==questions.length) return false;
    if (Array.from(value.answers).some(v=>v!==null&&(!Number.isInteger(v)||v<1||v>5))) return false;
    if (!Number.isInteger(value.index)||value.index<0||value.index>=questions.length) return false;
    if (!['quiz','results'].includes(value.screen)||typeof value.updatedAt!=='string'||!Number.isFinite(Date.parse(value.updatedAt))) return false;
    return value.screen!=='results'||value.answers.every(v=>v!==null);
  }
  function migrateState(value) {
    if(validState(value))return value;
    if(value?.version==='3.0.0'){
      const migrated={...value,version:VERSION};
      return validState(migrated)?migrated:null;
    }
    if(!value||value.version!=='2.0.0'||!Array.isArray(value.answers)||value.answers.length!==75)return null;
    const migrated={...value,version:VERSION,answers:[...value.answers,...Array(18).fill(null)],screen:'quiz'};
    if(!['quiz','results'].includes(value.screen)||!Number.isInteger(value.index)||value.index<0||value.index>=75)return null;
    if(value.screen==='results'&&value.answers.some(v=>v===null))return null;
    migrated.index=value.screen==='results'?75:value.index;
    return validState(migrated)?migrated:null;
  }
  const api={VERSION,CORE_WINDOW,PAIR_MIN,WING_MIN,WING_RATIO,WING_GAP,INSTINCT_GAP,questions,types,instincts,wingNotes,score,getWing,validState,migrateState};
  if(typeof module!=='undefined'&&module.exports) module.exports=api;
  else root.Enneagram=api;
})(typeof globalThis!=='undefined'?globalThis:this);
</script>
  <script>(function () {
  'use strict';
  const E=window.Enneagram;
  const $=id=>document.getElementById(id);
  const KEYS={draft:'nh-enneagram-v2-draft',result:'nh-enneagram-v2-result',prefs:'nh-enneagram-v2-prefs'};
  const chapters=['מבט פנימה','בחיי היומיום','בין אנשים','מתחת לפני השטח','התמונה מתחברת','מה מניע אותי'];
  const labels=['בכלל לא','מעט','במידה בינונית','במידה רבה','מאוד'];
  let answers=Array(E.questions.length).fill(null), index=0, currentScreen='start', result=null;
  let completedAt=null, autoSave=true, theme='light', pendingAction=null, focusBeforeDialog=null;
  let draft=null, saved=null;
  const escapeHtml=s=>String(s).replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
  const round=n=>Math.round(n);
  const dateText=s=>new Date(s).toLocaleString('he-IL',{dateStyle:'medium',timeStyle:'short'});
  function notice(message){$('notice').textContent=message;$('notice').hidden=!message;}
  function read(key){
    let text;
    try {text=localStorage.getItem(key);}
    catch {notice('לא ניתן לקרוא את השמירה המקומית. אפשר להמשיך במבחן ולהוריד דוח בסיום.');return null;}
    if(!text)return null;
    try{return JSON.parse(text);}
    catch {const removed=remove(key);notice(removed?'נתוני שמירה פגומים הוסרו. אפשר להתחיל מחדש; שמירות תקינות אחרות נשארו זמינות.':'נמצאו נתוני שמירה פגומים שלא ניתן להסיר. אפשר להתחיל מחדש ולהוריד דוח בסיום.');return null;}
  }
  function write(key,value){
    try {localStorage.setItem(key,JSON.stringify(value));return true;}
    catch {notice('השמירה במכשיר אינה זמינה. אפשר להמשיך כל עוד העמוד פתוח ולהוריד את הדוח בסיום.');return false;}
  }
  function remove(key){try{localStorage.removeItem(key);return true;}catch{return false;}}
  function getStoredState(key){const value=read(key);if(value===null)return null;if(E.validState(value))return value;const migrated=E.migrateState(value);if(migrated){write(key,migrated);notice(value.version==='2.0.0'?'התשובות הקודמות נשמרו. נוספו 18 שאלות, ויש להשלים אותן לפני חישוב תוצאה מעודכנת.':'התוצאה עודכנה לפי התשובות השמורות שלך.');return migrated;}remove(key);notice('נמצאה שמירה ישנה או לא תקינה שלא ניתן לשחזר. אפשר להתחיל מבחן חדש.');return null;}
  function snapshot(screen=currentScreen){return{version:E.VERSION,answers:[...answers],index,screen:screen==='results'?'results':'quiz',updatedAt:completedAt||new Date().toISOString()};}
  function storeDraft(){
    if(!autoSave){$('save-status').textContent='';return false;}
    const value=snapshot();const ok=write(KEYS.draft,value);
    if(ok)draft=value;
    $('save-status').textContent=ok?'':'לא נשמר. אפשר להמשיך בעמוד הזה';
    return ok;
  }
  function setScreen(name,focusId){
    currentScreen=name;
    ['start','quiz','results'].forEach(id=>$(id+'-screen').hidden=id!==name);
    $('about-panel').hidden=true;
    $('about-btn').setAttribute('aria-expanded','false');
    if(focusId)$(focusId).focus({preventScroll:true});
    window.scrollTo({top:0,behavior:'instant'});
  }
  function updateHome(){
    $('resume-box').hidden=!draft;
    if(draft){const count=draft.answers.filter(v=>v!==null).length;$('resume-text').textContent=draft.screen==='results'?'המבחן האחרון הושלם. אפשר לחזור לתוצאה.':`כבר ענית על ${count} מתוך ${E.questions.length} שאלות`;$('resume-btn').textContent=draft.screen==='results'?'לחזור לתוצאה האחרונה':'להמשיך מהמקום שעצרתי';}
    $('saved-box').hidden=!saved;
    if(saved){$('saved-text').textContent=saved.screen==='results'?`תוצאה שמורה במכשיר מ-${dateText(saved.updatedAt)}`:'התשובות מהגרסה הקודמת נשמרו';$('saved-btn').textContent=saved.screen==='results'?'לתוצאה השמורה':'להשלמת השאלות החדשות';}
  }
  function confirmAction(title,description,label,action){
    pendingAction=action;focusBeforeDialog=document.activeElement;
    $('confirm-title').textContent=title;$('confirm-description').textContent=description;$('confirm-ok').textContent=label;
    $('confirm-dialog').showModal();$('confirm-cancel').focus();
  }
  function dismissDialog(){pendingAction=null;$('confirm-dialog').close();focusBeforeDialog?.focus();}
  $('confirm-cancel').addEventListener('click',dismissDialog);
  $('confirm-dialog').addEventListener('cancel',()=>{pendingAction=null;});
  $('confirm-ok').addEventListener('click',()=>{const action=pendingAction;pendingAction=null;$('confirm-dialog').close();action?.();});
  function startFresh(){
    answers=Array(E.questions.length).fill(null);index=0;result=null;completedAt=null;draft=null;
    if(!remove(KEYS.draft))notice('לא ניתן למחוק את השמירה הקודמת כרגע. המבחן החדש פתוח ואפשר לענות עליו.');
    setScreen('quiz');showQuestion();storeDraft();
  }
  function requestNew(){
    if(draft||answers.some(v=>v!==null))confirmAction('להתחיל מבחן חדש?','ההתקדמות הנוכחית תוחלף. תוצאה ששמרת בנפרד תישאר זמינה.','להתחיל מחדש',startFresh);
    else startFresh();
  }
  function restore(value){
    if(!E.validState(value)){notice('לא ניתן לשחזר את הנתונים האלה. אפשר להתחיל מבחן חדש.');return;}
    answers=[...value.answers];index=value.index;completedAt=value.screen==='results'?value.updatedAt:null;
    if(value.screen==='results')showResults(false);else{setScreen('quiz');showQuestion();}
  }
  function renderWheel(){
    const coords={};
    for(let n=1;n<=9;n++){const angle=((n%9)*40-90)*Math.PI/180;coords[n]={x:50+38*Math.cos(angle),y:50+38*Math.sin(angle)};}
    const linePath=sequence=>sequence.map((n,i)=>`${i?'L':'M'}${coords[n].x} ${coords[n].y}`).join(' ');
    $('intro-wheel').innerHTML=`<svg viewBox="0 0 100 100" aria-hidden="true"><circle cx="50" cy="50" r="38" fill="none" stroke="currentColor" opacity=".25" stroke-width=".35"/><path d="${linePath([9,3,6,9])} ${linePath([1,4,2,8,5,7,1])}" stroke="currentColor" opacity=".2" stroke-width=".35" fill="none"/></svg><div class="wheel-center"><strong>מאחורי<br>הבחירות שלך</strong><span>מפת האניאגרמה</span></div>`;
    for(let n=1;n<=9;n++){
      const button=document.createElement('button');button.className='wheel-node';button.style.left=coords[n].x+'%';button.style.top=coords[n].y+'%';button.textContent=n;button.setAttribute('aria-label',`טיפוס ${n}, ${E.types[n].name}`);button.setAttribute('aria-pressed','false');
      button.addEventListener('click',()=>{document.querySelectorAll('.wheel-node').forEach(b=>b.setAttribute('aria-pressed',String(b===button)));$('type-preview-title').textContent=`${n} · ${E.types[n].name}`;$('type-preview-text').textContent=E.types[n].theme;});
      $('intro-wheel').appendChild(button);
    }
    $('type-preview-title').parentElement.setAttribute('aria-live','polite');
  }
  function showQuestion(){
    const question=E.questions[index];
    const chapter=Math.min(chapters.length-1,Math.floor(index/15)), answered=answers.filter(v=>v!==null).length;
    $('pause-btn').textContent=autoSave?'שמירה ויציאה':'יציאה מהמבחן';
    $('question-text').textContent=question.text;
    const paired=question.kind==='contrast';
    $('answers-form').classList.toggle('paired-question',paired);
    $('contrast-options').hidden=!paired;
    $('contrast-options').innerHTML=paired?question.options.map((text,i)=>`<div><b>${i?'ב':'א'}</b><p>${escapeHtml(text)}</p></div>`).join(''):'';
    $('answer-hint').textContent=paired?'מה מתאר אותך יותר?':'עד כמה זה מתאר אותך?';
    const currentLabels=paired?['א בבירור','יותר א','שניהם או אף אחד','יותר ב','ב בבירור']:labels;
    $('question-counter').textContent=`שאלה ${index+1} מתוך ${E.questions.length}`;
    $('chapter-name').textContent=`חלק ${chapter+1} מתוך ${chapters.length} · ${chapters[chapter]}`;
    $('progress').value=answered;$('progress').setAttribute('aria-valuetext',`${answered} מתוך ${E.questions.length} שאלות נענו`);
    $('chapter-list').innerHTML=chapters.map((name,i)=>`<li${i===chapter?' aria-current="step"':''} class="${i<chapter?'done':''}"><span>${i+1}</span>${name}</li>`).join('');
    $('answers-container').innerHTML=currentLabels.map((label,i)=>`<label class="answer-label"><input type="radio" name="answer" value="${i+1}" aria-label="${i+1}, ${label}"${answers[index]===i+1?' checked':''}><span class="answer-dot" aria-hidden="true"></span><span>${label}</span></label>`).join('');
    $('prev-btn').disabled=index===0;$('next-btn').textContent=index===E.questions.length-1?'למפה האישית שלי ←':'הבא ←';
    $('error-msg').hidden=true;
    $('question-text').focus({preventScroll:true});
  }
  $('answers-container').addEventListener('change',event=>{
    if(event.target.name!=='answer')return;
    answers[index]=Number(event.target.value);completedAt=null;result=null;$('error-msg').hidden=true;storeDraft();
    const count=answers.filter(v=>v!==null).length;$('progress').value=count;$('progress').setAttribute('aria-valuetext',`${count} מתוך ${E.questions.length} שאלות נענו`);
  });
  $('answers-form').addEventListener('submit',event=>{
    event.preventDefault();
    if(answers[index]===null){$('error-msg').hidden=false;document.querySelector('input[name=answer]').focus();return;}
    if(index<E.questions.length-1){index++;storeDraft();showQuestion();}else showResults(true);
  });
  $('prev-btn').addEventListener('click',()=>{if(index>0){index--;storeDraft();showQuestion();}});
  document.addEventListener('keydown',event=>{
    if(currentScreen!=='quiz'||$('confirm-dialog').open||!$('about-panel').hidden||event.altKey||event.ctrlKey||event.metaKey)return;
    if(event.key==='Enter'&&(document.activeElement?.matches('input[name=answer]')||document.activeElement===$('question-text'))){event.preventDefault();$('answers-form').requestSubmit();return;}
    if(/^[1-5]$/.test(event.key)){
      const radio=document.querySelector(`input[name=answer][value="${event.key}"]`);
      if(radio){event.preventDefault();radio.checked=true;radio.focus();radio.dispatchEvent(new Event('change',{bubbles:true}));}
    }
  });
  function mainTitle(r){
    if(r.primary)return`טיפוס ${r.primary} · ${E.types[r.primary].name}`;
    if(r.primaryStatus==='undifferentiated')return'עוד אין כאן כיוון מוביל';
    if(r.primaryStatus==='weak')return'ההתאמה לטיפוסים נמוכה';
    if(r.primaryStatus==='mixed')return'כדאי להבחין בין הסגנון למניע';
    if(r.primaryStatus==='unstable')return'הכיוון המוביל עדיין לא יציב';
    return'כמה כיוונים קרובים זה לזה';
  }
  function mainDescription(r){
    if(r.primary)return E.types[r.primary].description;
    if(r.primaryStatus==='undifferentiated')return'כל התשובות זהות. אפשר לחזור לשאלות או להכיר את הטיפוסים בהמשך.';
    if(r.primaryStatus==='weak')return'לא בלט טיפוס מסוים בתשובות שלך.';
    return`כדאי להשוות בין ${r.candidates.map(n=>`${n} (${E.types[n].name})`).join(', ')} ולבדוק איזה מניע מוכר לך יותר.`;
  }
  function wingTitle(r){
    if(!r.primary)return'כדאי לברר קודם את הטיפוס המוביל';
    if(r.wing.dominant)return`כנף מובילה: ${r.primary}w${r.wing.dominant}`;
    return'לא נמצאה כנף מובחנת';
  }
  function wingDescription(r){
    if(!r.primary)return'נבחר כנף רק לאחר שתתבהר ההבחנה בין הטיפוסים.';
    if(r.wing.status==='weak')return'ההתאמה לשכנים נמוכה מכדי להציג כנף בולטת.';
    if(r.wing.status==='close')return'אין העדפה ברורה בין השכנים.';
    return'';
  }
  function renderWing(r){
    let html=`<h3>${wingTitle(r)}</h3>${wingDescription(r)?`<p style="margin-top:13px">${wingDescription(r)}</p>`:''}`;
    if(r.primary&&r.wing.eligible.length)html+=`<div class="wing-choices">${r.wing.eligible.map(n=>`<div class="wing-choice ${n===r.wing.dominant?'suggested':''}"><h3><bdi>${r.primary}w${n}</bdi></h3><div class="wing-score">התאמה לטיפוס ${n}: ${round(r.scores[n])} מתוך 100</div><p>${E.wingNotes[`${r.primary}w${n}`]}</p>${n===r.wing.dominant?'<span class="result-badge">הכנף המובילה</span>':''}</div>`).join('')}</div>`;
    $('wing-result').innerHTML=html;
  }
  function instinctTitle(r){
    if(r.instinctStatus==='undifferentiated')return'אין הבחנה בין תחומי הקשב';
    if(r.instinctStatus==='weak')return'לא נמצא תחום קשב מוביל';
    if(!r.dominantInstinct)return'כמה תחומי קשב קיבלו ציונים קרובים';
    if(r.stackClear)return`סדר משוער: ${r.instinctRanking.map(t=>E.instincts[t.key].code).join(' / ')}`;
    return`הכיוון המוביל: ${E.instincts[r.dominantInstinct].name}`;
  }
  function instinctCaution(r){
    if(r.uniform)return'מענה אחיד אינו מספיק כדי לזהות העדפה.';
    if(r.instinctStatus==='weak'||!r.dominantInstinct)return'';
    if(!r.stackClear)return'שני התחומים האחרים קרובים זה לזה.';
    return'';
  }
  function renderInstincts(r){
    $('instinct-result').innerHTML=`<div class="instinct-summary">${r.stackClear?`<bdi>${instinctTitle(r)}</bdi>`:instinctTitle(r)}</div>${instinctCaution(r)?`<p style="margin-bottom:24px">${instinctCaution(r)}</p>`:''}<div class="instinct-grid">${r.instinctRanking.map(({key,score})=>{const data=E.instincts[key];return`<div class="instinct-item"><h3>${data.name} <bdi>(${data.code})</bdi></h3><div class="score-row"><div class="score-track"><div class="score-fill" style="width:${score}%"></div></div><span class="score-value">${round(score)}</span></div><p>${data.description.split('. ')[0]}.</p>${key===r.dominantInstinct?`<p><strong>נקודה להתבוננות:</strong> ${data.practice}</p>`:''}</div>`;}).join('')}</div>`;
  }
  function showType(n){
    const data=E.types[n],neighbors=[n===1?9:n-1,n===9?1:n+1];
    document.querySelectorAll('.type-tab').forEach(b=>b.setAttribute('aria-pressed',String(Number(b.dataset.type)===n)));
    $('type-detail').innerHTML=`<h3>${n} · ${data.name}: ${data.theme}</h3><p>מכונה גם: ${data.aliases.join(', ')}</p><p>${data.description}</p><div class="detail-grid"><div><h3>מה הדפוס מאפשר</h3><p>${data.strength}</p></div><div><h3>מה עלול לגבות מחיר</h3><p>${data.cost}</p></div></div><div class="practice"><h3>ניסוי קטן לשבוע הקרוב</h3><p>${data.practice}</p><p class="reflection">${data.reflection}</p></div><details style="margin-top:20px"><summary>שתי הכנפיים של טיפוס ${n}</summary>${neighbors.map(w=>`<p><strong><bdi>${n}w${w}</bdi>:</strong> ${E.wingNotes[`${n}w${w}`]}</p>`).join('')}</details>`;
  }
  function showResults(persist){
    if(answers.some(v=>v===null)){index=answers.indexOf(null);setScreen('quiz');showQuestion();notice('נשארה שאלה ללא תשובה. נשלים אותה לפני חישוב המפה.');return;}
    result=E.score(answers);completedAt=completedAt||new Date().toISOString();
    const r=result;
    $('result-date').textContent=`${E.questions.length} תשובות · ${dateText(completedAt)}`;
    $('result-summary').innerHTML=`<div class="result-number">${r.primary||'?'}<small>${r.primary?'הכיוון המוביל בתשובות':'מרחב לבדיקה נוספת'}</small></div><div><h2>${mainTitle(r)}</h2><p>${mainDescription(r)}</p></div>`;
    $('type-scores').innerHTML=r.typeRanking.map(({key,score})=>`<div class="score-row ${Number(key)===r.primary?'leading':''}"><span class="score-label"><b>${key}</b> ${E.types[key].name}</span><div class="score-track" aria-hidden="true"><div class="score-fill" style="width:${score}%"></div></div><span class="score-value" aria-label="${round(score)} מתוך 100">${round(score)}</span></div>`).join('');
    renderWing(r);renderInstincts(r);
    $('instinct-result').querySelectorAll('.score-value').forEach(node=>node.setAttribute('aria-label',`${node.textContent} מתוך 100`));
    $('explore-types').innerHTML=Object.keys(E.types).map(n=>`<button class="type-tab" data-type="${n}" aria-label="קריאה על טיפוס ${n}, ${E.types[n].name}" aria-pressed="false">${n}</button>`).join('');
    $('explore-types').querySelectorAll('button').forEach(b=>b.addEventListener('click',()=>showType(Number(b.dataset.type))));
    showType(r.primary||Number(r.typeRanking[0].key));
    $('export-status').textContent='';
    setScreen('results','results-title');if(persist)storeDraft();
  }
  function reportData(){
    return {schema:'nh-enneagram-result',version:E.VERSION,createdAt:completedAt,questionCount:E.questions.length,
      note:'כלי להתבוננות עצמית, לא אבחון פסיכולוגי. הציונים אינם הסתברויות. השאלון לא עבר תיקוף על מדגם אנושי.',
      scoring:{selection:'style-ranking-with-adjacent-comparisons',coreWindow:E.CORE_WINDOW,pairMinimum:E.PAIR_MIN,requireLeaveOneOutStability:false,wingGap:E.WING_GAP,wingMinimum:E.WING_MIN,wingRatio:E.WING_RATIO,instinctGap:E.INSTINCT_GAP},
      typeLabels:Object.fromEntries(Object.entries(E.types).map(([key,{name,aliases}])=>[key,{name,aliases}])),
      result,answers:E.questions.map((q,i)=>({id:q.id,question:q.text,...(q.options?{options:q.options,responseScale:['א בבירור','יותר א','שניהם או אף אחד','יותר ב','ב בבירור']}:{responseScale:labels}),answer:answers[i]})),
      explanations:{title:mainTitle(result),description:mainDescription(result),wing:wingTitle(result),wingExplanation:wingDescription(result),instincts:instinctTitle(result),instinctCaution:instinctCaution(result)},
      sources:['https://www.enneagraminstitute.com/how-the-enneagram-system-works/','https://www.enneagraminstitute.com/type-descriptions/','https://pubmed.ncbi.nlm.nih.gov/33332604/','https://www.enneagraminstitute.com/interpreting-your-enneagram-test-results/','https://www.pewresearch.org/writing-survey-questions/']};
  }
  function reportHtml(){
    const r=result, data=reportData();
    const typeRows=r.typeRanking.map(({key,score})=>`<tr><td>${key} · ${E.types[key].name}</td><td>${round(score)}</td></tr>`).join('');
    const wingHtml=r.primary?r.wing.eligible.map(n=>`<p><strong><bdi>${r.primary}w${n}</bdi>:</strong> ${E.wingNotes[`${r.primary}w${n}`]} (התאמה לטיפוס ${n}: ${round(r.scores[n])})</p>`).join(''):'';
    const descriptions=r.typeRanking.slice(0,3).map(({key})=>{const t=E.types[key];return`<section><h3>טיפוס ${key} · ${t.name}</h3><p>מכונה גם: ${t.aliases.join(', ')}</p><p>${t.description}</p><p><strong>משאב:</strong> ${t.strength}</p><p><strong>אתגר:</strong> ${t.cost}</p><p><strong>ניסוי קטן:</strong> ${t.practice}</p><p><strong>שאלה למחשבה:</strong> ${t.reflection}</p></section>`;}).join('');
    const limitations='הציונים בסולם 0 עד 100 מתארים התאמה לתשובות, ולא הסתברות או אחוזי ודאות. הספים הם כללי תצוגה של הכלי, לא ערכים מתוקפים מחקרית. ציוני הסגנונות הם ממוצעי שש האמירות לכל טיפוס. 18 ההשוואות מחושבות בנפרד. מתחילים מהדירוג המקורי ובוחנים מועמדים עד 15 נקודות מהמוביל. שתי העדפות עקביות של שכן מועמד, בממוצע של 75 לפחות, מסירות את הטיפוס שהפסיד מהבחירה הסופית. בוחרים את הציון המקורי הגבוה מבין הנותרים. בהיעדר הכרעה או במעגל השוואות סותר חוזרים למוביל המקורי. בתיקו מלא בציונים ובמידע ההשוואתי הסדר מספרי. כנף דורשת ציון של 62.5 לפחות ולפחות 75% מציון הטיפוס. מבין השכנים שעומדים בסף, בעל הציון הגבוה מוצג כמוביל, גם בפער קטן. בתיקו בין השכנים אין כנף מובילה. מענה אחיד אינו מוכרע. סדר מלא של אינסטינקטים דורש פער של 8 נקודות גם בין השני לשלישי. השאלון לא עבר תיקוף על מדגם אנושי. סקירת המחקר מצאה ראיות מעורבות לתוקף האניאגרמה ומעט תמיכה בכנפיים. זה אינו שאלון רשמי של Enneagram Institute.';
    return`<!DOCTYPE html><html lang="he" dir="rtl"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>המפה האישית שלי | אניאגרמה</title><style>body{font:18px/1.75 'Segoe UI',Arial,sans-serif;color:#29263d;max-width:850px;margin:35px auto;padding:0 25px;background:#fff}h1,h2,h3{line-height:1.3}h1{font-size:38px;color:#5443a8}h2{margin-top:35px}section{break-inside:avoid;border-top:1px solid #ddd;padding-top:15px;margin-top:22px}table{width:100%;border-collapse:collapse}th,td{text-align:start;border-bottom:1px solid #ddd;padding:9px}header{padding-bottom:20px;border-bottom:2px solid #5443a8}.note{font-size:15px;color:#555}a{color:#443387;overflow-wrap:anywhere}bdi{unicode-bidi:isolate}@media print{body{font-size:11pt;margin:0;padding:0}h1{font-size:26pt}h2{font-size:19pt}@page{size:A4;margin:17mm}}</style></head><body><header><h1>המפה האישית שלי</h1><p>${escapeHtml(dateText(completedAt))} · ${E.questions.length} תשובות · גרסה ${E.VERSION}</p></header><h2>${mainTitle(r)}</h2><p>${mainDescription(r)}</p><h2>הסגנונות בתשובות שלך</h2><table><thead><tr><th>טיפוס</th><th>ציון (0-100)</th></tr></thead><tbody>${typeRows}</tbody></table><section><h2>${wingTitle(r)}</h2><p>${wingDescription(r)}</p>${wingHtml}</section><section><h2>האינסטינקטים</h2><h3>${instinctTitle(r)}</h3><p>${instinctCaution(r)}</p>${r.instinctRanking.map(({key,score})=>`<h3>${E.instincts[key].name} <bdi>(${E.instincts[key].code})</bdi> · ${round(score)}</h3><p>${E.instincts[key].description}</p><p>${E.instincts[key].practice}</p>`).join('')}</section><h2>${r.primary?'כיוונים להמשך התבוננות':'תיאורים להתחלת בירור, ללא הכרעה'}</h2><p class="note">${r.primary?'שלושת הציונים הגבוהים בתשובות.':'מוצגים שלושה מתוך תשעת הטיפוסים, לפי סדר הציונים. בתיקו הסדר מספרי ואינו מעיד על התאמה עדיפה.'}</p>${descriptions}<section><details><summary>על המבחן והשיטה</summary><p class="note">${data.note} ${limitations}</p><ul>${data.sources.map((url,i)=>`<li><a href="${url}" rel="noopener noreferrer">${['מבנה האניאגרמה, כנפיים ואינסטינקטים','תשעת הטיפוסים','Hook ועמיתיו, סקירה שיטתית, 2021','פירוש תוצאות והבחנה בין טיפוס לכנף','Pew Research Center: ניסוח שאלות'][i]}</a></li>`).join('')}</ul></details></section></body></html>`;
  }
  function download(content,type,extension){
    try{
      const blob=new Blob([extension==='json'?'':'\uFEFF',content],{type});const url=URL.createObjectURL(blob);
      const link=document.createElement('a');link.href=url;link.download=`enneagram-${completedAt.slice(0,10)}.${extension}`;document.body.append(link);link.click();link.remove();
      window.setTimeout(()=>URL.revokeObjectURL(url),15000);
      $('export-status').textContent=extension==='html'?'הדוח נוצר והועבר לדפדפן להורדה. אפשר לפתוח אותו גם ללא חיבור לרשת.':'קובץ הנתונים נוצר והועבר לדפדפן להורדה. הוא כולל גם את התשובות המלאות.';
    }catch{$('export-status').textContent='ההורדה לא הצליחה. אפשר לנסות שוב או להשתמש בהדפסה / PDF.';}
  }
  $('download-btn').addEventListener('click',()=>download(reportHtml(),'text/html;charset=utf-8','html'));
  $('json-btn').addEventListener('click',()=>download(JSON.stringify(reportData(),null,2),'application/json;charset=utf-8','json'));
  $('print-btn').addEventListener('click',()=>{
    // Print the same complete, script-free report as the download, including methodology.
    const frame=document.createElement('iframe');frame.title='דוח אישי להדפסה';frame.style.cssText='position:fixed;width:1px;height:1px;left:-10000px;border:0';
    const dispose=()=>{frame.remove();};
    frame.addEventListener('load',()=>{try{frame.contentWindow.addEventListener('afterprint',dispose,{once:true});frame.contentWindow.focus();frame.contentWindow.print();}catch{dispose();$('export-status').textContent='לא ניתן לפתוח הדפסה. אפשר להוריד את הדוח ולפתוח אותו בדפדפן.';}});
    frame.srcdoc=reportHtml();document.body.append(frame);window.setTimeout(dispose,120000);
  });
  $('save-result-btn').addEventListener('click',()=>{
    const value=snapshot('results');
    if(write(KEYS.result,value)){saved=value;$('export-status').textContent='התוצאה נשמרה במכשיר הזה. אפשר לפתוח אותה שוב ממסך הפתיחה.';}
    else $('export-status').textContent='התוצאה לא נשמרה במכשיר. מומלץ להוריד את הדוח.';
  });
  $('clear-btn').addEventListener('click',()=>confirmAction('למחוק את הנתונים השמורים?','ההתקדמות והתוצאה יימחקו מהדפדפן הזה. קבצים שכבר הורדת יישארו במכשיר.','למחוק',()=>{
    const removedDraft=remove(KEYS.draft),removedResult=remove(KEYS.result);
    if(removedDraft)draft=null;if(removedResult)saved=null;
    autoSave=false;$('auto-save').checked=false;write(KEYS.prefs,{autoSave,theme});
    $('export-status').textContent=removedDraft&&removedResult?'הנתונים השמורים נמחקו והשמירה האוטומטית כובתה. התוצאה נשארת פתוחה עד סגירת העמוד.':'לא כל הנתונים נמחקו. אפשר למחוק את נתוני האתר דרך הגדרות הדפדפן.';
  }));
  $('auto-save').addEventListener('change',()=>{
    autoSave=$('auto-save').checked;write(KEYS.prefs,{autoSave,theme});
    if(!autoSave){if(remove(KEYS.draft)){draft=null;updateHome();notice('השמירה האוטומטית כובתה וההתקדמות השמורה נמחקה. תוצאה שנשמרה בנפרד נשארת זמינה.');}else notice('השמירה כובתה, אך לא ניתן למחוק את ההתקדמות שכבר נשמרה. אפשר למחוק נתוני אתר בהגדרות הדפדפן.');}
  });
  function applyTheme(){document.documentElement.dataset.theme=theme;$('theme-btn').setAttribute('aria-label',theme==='dark'?'מעבר לתצוגה בהירה':'מעבר לתצוגה כהה');}
  $('theme-btn').addEventListener('click',()=>{theme=theme==='dark'?'light':'dark';applyTheme();write(KEYS.prefs,{autoSave,theme});});
  $('start-btn').addEventListener('click',requestNew);$('restart-btn').addEventListener('click',requestNew);
  $('resume-btn').addEventListener('click',()=>restore(draft));$('saved-btn').addEventListener('click',()=>restore(saved));
  $('edit-btn').addEventListener('click',()=>{index=0;completedAt=null;setScreen('quiz');showQuestion();storeDraft();});
  function goHome(){updateHome();setScreen('start','start-title');}
  function pause(){
    if(autoSave&&storeDraft()){goHome();notice('ההתקדמות נשמרה. אפשר לחזור דרך כפתור ההמשך.');}
    else confirmAction('לצאת למסך הפתיחה?','השמירה המקומית אינה פעילה או אינה זמינה. נשמור את התשובות בזיכרון של העמוד הזה בלבד, עד לסגירה או לרענון.','לחזור לפתיחה',()=>{draft=snapshot();goHome();});
  }
  $('pause-btn').addEventListener('click',pause);
  $('home-link').addEventListener('click',event=>{event.preventDefault();if(currentScreen==='quiz')pause();else goHome();});
  $('about-btn').setAttribute('aria-expanded','false');$('about-btn').setAttribute('aria-controls','about-panel');
  $('about-btn').addEventListener('click',()=>{$('about-panel').hidden=!$('about-panel').hidden;$('about-btn').setAttribute('aria-expanded',String(!$('about-panel').hidden));if(!$('about-panel').hidden){$('about-title').focus();$('about-panel').scrollIntoView({block:'start'});}});
  $('close-about-btn').addEventListener('click',()=>{$('about-panel').hidden=true;$('about-btn').setAttribute('aria-expanded','false');$('about-btn').focus();});
  window.addEventListener('beforeunload',event=>{if(currentScreen==='quiz'&&answers.some(v=>v!==null)&&(!autoSave||!storeDraft())){event.preventDefault();event.returnValue='';}});
  const prefs=read(KEYS.prefs);
  if(prefs&&typeof prefs.autoSave==='boolean')autoSave=prefs.autoSave;
  theme=prefs&&['light','dark'].includes(prefs.theme)?prefs.theme:window.matchMedia('(prefers-color-scheme: dark)').matches?'dark':'light';
  $('auto-save').checked=autoSave;applyTheme();draft=getStoredState(KEYS.draft);saved=getStoredState(KEYS.result);renderWheel();updateHome();
})();
</script>
</body>
</html>
"; diff --git a/assets/illustrations/16-types/ENFJ.svg b/assets/illustrations/16-types/ENFJ.svg index c48eabc..076e53c 100644 --- a/assets/illustrations/16-types/ENFJ.svg +++ b/assets/illustrations/16-types/ENFJ.svg @@ -1,3 +1,57 @@ -ENFJ: a welcoming bearded male guide connecting people and ideas - + +ENFJ: The guide welcoming connection +A smiling bearded male guide in a teal jacket opens both hands in welcome. A small heart in a speech bubble reinforces empathy and connection. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/ENFP.svg b/assets/illustrations/16-types/ENFP.svg index 9b4beb9..ab4b174 100644 --- a/assets/illustrations/16-types/ENFP.svg +++ b/assets/illustrations/16-types/ENFP.svg @@ -1,3 +1,58 @@ -ENFP: an enthusiastic male explorer lifting a geometric kite - + +ENFP: The explorer lifting a kite +An enthusiastic male explorer in a golden jacket moves forward while lifting a diamond-shaped kite. A clearly connected string and a light tail echo his lively pose. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/ENTJ.svg b/assets/illustrations/16-types/ENTJ.svg index 3289767..ee7e720 100644 --- a/assets/illustrations/16-types/ENTJ.svg +++ b/assets/illustrations/16-types/ENTJ.svg @@ -1,3 +1,56 @@ -ENTJ: a confident male leader pointing toward the next step - + +ENTJ: The leader indicating the next step +A confident moustached male leader wears a burgundy suit. One foot is on a low step and one hand points forward and upward along a clear staircase. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/ENTP.svg b/assets/illustrations/16-types/ENTP.svg index e01ec7c..41891f9 100644 --- a/assets/illustrations/16-types/ENTP.svg +++ b/assets/illustrations/16-types/ENTP.svg @@ -1,3 +1,58 @@ -ENTP: an expressive male inventor comparing two geometric ideas - + +ENTP: The inventor comparing two ideas +An expressive male inventor in a rust jacket compares a blue cube and a golden geometric solid. Open palms and an asymmetric stance suggest lively curiosity. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/ESFJ.svg b/assets/illustrations/16-types/ESFJ.svg index 0059d61..a95055b 100644 --- a/assets/illustrations/16-types/ESFJ.svg +++ b/assets/illustrations/16-types/ESFJ.svg @@ -1,3 +1,61 @@ -ESFJ: a warm moustached male host offering two cups and a welcome - + +ESFJ: The host offering a warm welcome +A warm moustached male host in a terracotta waistcoat balances a tray with two steaming cups. His free hand opens in a relaxed gesture of welcome. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/ESFP.svg b/assets/illustrations/16-types/ESFP.svg index fe59c71..50b39e5 100644 --- a/assets/illustrations/16-types/ESFP.svg +++ b/assets/illustrations/16-types/ESFP.svg @@ -1,3 +1,60 @@ -ESFP: an expressive male performer dancing with a microphone - + +ESFP: The performer dancing with a microphone +An expressive moustached male performer in a magenta jacket dances in light sneakers. A clearly held microphone, a loose cable and an open raised hand complete the movement. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/ESTJ.svg b/assets/illustrations/16-types/ESTJ.svg index eb9a4f6..78a4409 100644 --- a/assets/illustrations/16-types/ESTJ.svg +++ b/assets/illustrations/16-types/ESTJ.svg @@ -1,3 +1,65 @@ -ESTJ: a silver-haired male organiser arranging a clear series of steps - + +ESTJ: The organiser arranging clear steps +A silver-haired male organiser in a blue suit arranges three ascending blocks on a small wooden table. His glasses and measured gesture emphasise practical structure. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/ESTP.svg b/assets/illustrations/16-types/ESTP.svg index f2a6642..e2f8c47 100644 --- a/assets/illustrations/16-types/ESTP.svg +++ b/assets/illustrations/16-types/ESTP.svg @@ -1,3 +1,65 @@ -ESTP: a confident male adventurer stepping onto a rock with a camera - + +ESTP: The adventurer stepping onto a rock +A confident male adventurer in an ochre jacket rests one foot on a rock. Sunglasses, a wristwatch and a camera on a connected neck strap convey readiness to explore. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/INFJ.svg b/assets/illustrations/16-types/INFJ.svg index e1d5ad6..884727a 100644 --- a/assets/illustrations/16-types/INFJ.svg +++ b/assets/illustrations/16-types/INFJ.svg @@ -1,3 +1,63 @@ -INFJ: a thoughtful bearded male guide carrying a warm lantern - + +INFJ: The guide carrying a lantern +A contemplative bearded male guide in a forest-green coat carries a warm lantern by its handle. A quiet stance and a small flame suggest insight and guidance. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/INFP.svg b/assets/illustrations/16-types/INFP.svg index 572f435..46fc0e5 100644 --- a/assets/illustrations/16-types/INFP.svg +++ b/assets/illustrations/16-types/INFP.svg @@ -1,3 +1,59 @@ -INFP: a contemplative male reader with an open book - + +INFP: The reader absorbed in a book +A gentle male reader in an olive jacket sits on a small cushion. He leans toward an open book, with both hands resting naturally on the page edges. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/INTJ.svg b/assets/illustrations/16-types/INTJ.svg index e2b89e6..bb8abc4 100644 --- a/assets/illustrations/16-types/INTJ.svg +++ b/assets/illustrations/16-types/INTJ.svg @@ -1,3 +1,64 @@ -INTJ: a thoughtful male architect with a folded blueprint - + +INTJ: The architect with a folded blueprint +A bespectacled male architect in an indigo jacket studies a three-panel architectural plan. His balanced stance and precise drawing convey quiet planning. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/INTP.svg b/assets/illustrations/16-types/INTP.svg index ffe9b3c..c3bd350 100644 --- a/assets/illustrations/16-types/INTP.svg +++ b/assets/illustrations/16-types/INTP.svg @@ -1,3 +1,67 @@ -INTP: a bearded male thinker studying an orbital model - + +INTP: The thinker with an orbital model +A curly-haired, bearded male thinker in a lavender jacket sits on a wooden stool. He studies a small orbital model held carefully at eye level. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/ISFJ.svg b/assets/illustrations/16-types/ISFJ.svg index 1953742..2be4c6e 100644 --- a/assets/illustrations/16-types/ISFJ.svg +++ b/assets/illustrations/16-types/ISFJ.svg @@ -1,3 +1,62 @@ -ISFJ: a kindly bearded male gardener protecting a young plant - + +ISFJ: The gardener protecting a young plant +A kindly balding, bearded male gardener in a rose cardigan cups a terracotta pot in both hands. Two fresh green leaves are the gentle focal point. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/ISFP.svg b/assets/illustrations/16-types/ISFP.svg index 82047f6..ee0214c 100644 --- a/assets/illustrations/16-types/ISFP.svg +++ b/assets/illustrations/16-types/ISFP.svg @@ -1,3 +1,69 @@ -ISFP: a bearded male artist painting at a small easel - + +ISFP: The artist painting at an easel +A bearded male artist in a lilac sweater sits at a wooden easel. He holds a small palette and touches a brush to a quiet mountain-and-sun landscape. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/ISTJ.svg b/assets/illustrations/16-types/ISTJ.svg index 76805a2..dce331b 100644 --- a/assets/illustrations/16-types/ISTJ.svg +++ b/assets/illustrations/16-types/ISTJ.svg @@ -1,3 +1,65 @@ -ISTJ: a meticulous moustached man checking a clipboard - + +ISTJ: The organiser checking a clipboard +A meticulous moustached man in a slate-blue waistcoat checks a three-item clipboard with a pencil. Clear marks, neat sleeves and a steady posture convey care and order. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/ISTP.svg b/assets/illustrations/16-types/ISTP.svg index c009147..0df9b1f 100644 --- a/assets/illustrations/16-types/ISTP.svg +++ b/assets/illustrations/16-types/ISTP.svg @@ -1,3 +1,58 @@ -ISTP: a bearded male maker kneeling with a wrench - + +ISTP: The maker kneeling with a wrench +A bearded male maker in a green work shirt and cap kneels with a steel open-ended wrench. Rolled sleeves, two pockets and a grounded pose keep the scene practical. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/catalog/web.html b/catalog/web.html index 9f6db51..254d8f5 100644 --- a/catalog/web.html +++ b/catalog/web.html @@ -84,11 +84,11 @@

כלי דפדפן

פותחים בדפדפן ומתחילים ליצו

מבחן אישיות אניאגרמה

כלי לבדיקת אישיות מבוסס האניאגרמה - שיטה עתיקה המחלקת את העולם ל-9 טיפוסים מרכזיים.

-
+
HTML
-

מבחן 16 הטיפוסים

שאלון עצמאי בעברית בהשראת MBTI, עם 64 שאלות, שמירת התקדמות ותוצאה מפורטת. פועל גם ללא חיבור לרשת.

+

מבחן 16 הטיפוסים

שאלון עצמאי בעברית בהשראת MBTI, עם 56 שאלות, שמירת התקדמות ותוצאה מפורטת. פועל גם ללא חיבור לרשת.

diff --git a/index.html b/index.html index ae5a855..edd701f 100644 --- a/index.html +++ b/index.html @@ -99,11 +99,11 @@

כלים קטנים.
אפשרויות גדולות.

מבחן אישיות אניאגרמה

כלי לבדיקת אישיות מבוסס האניאגרמה - שיטה עתיקה המחלקת את העולם ל-9 טיפוסים מרכזיים.

-
+
HTML
-

מבחן 16 הטיפוסים

שאלון עצמאי בעברית בהשראת MBTI, עם 64 שאלות, שמירת התקדמות ותוצאה מפורטת. פועל גם ללא חיבור לרשת.

+

מבחן 16 הטיפוסים

שאלון עצמאי בעברית בהשראת MBTI, עם 56 שאלות, שמירת התקדמות ותוצאה מפורטת. פועל גם ללא חיבור לרשת.

סקריפטים02

diff --git a/tools/the_16_types.html b/tools/the_16_types.html index 7fa4635..6f018af 100644 --- a/tools/the_16_types.html +++ b/tools/the_16_types.html @@ -481,19 +481,19 @@ מבחן 16 הטיפוסים | ארגז הכלים של NH Local - + - + - + @@ -564,7 +564,7 @@

למחוק את התשובות?

התשובות והתוצאה השמורות בדפדפן הזה יימחקו. אפשר לבטל ולהמשיך מהמצב הקיים.

+מבחן אישיות אניאגרמה | ארגז הכלים של NH Local + + + + + + + + + + + + + From f86236f1c56b97229af9c7b5f8fe9b1fe43a2172 Mon Sep 17 00:00:00 2001 From: NHLOCAL Date: Thu, 17 Sep 2026 02:20:57 +0300 Subject: [PATCH 4/9] Verify the rebuilt illustrations in the real test on desktop and mobile --- .github/workflows/rebuild-16-type-artwork.yml | 155 ++++++++++++------ 1 file changed, 102 insertions(+), 53 deletions(-) diff --git a/.github/workflows/rebuild-16-type-artwork.yml b/.github/workflows/rebuild-16-type-artwork.yml index a951013..93dee99 100644 --- a/.github/workflows/rebuild-16-type-artwork.yml +++ b/.github/workflows/rebuild-16-type-artwork.yml @@ -1,4 +1,4 @@ -name: Rebuild 16-type artwork (one-off) +name: Verify redesigned 16-type artwork (one-off) on: pull_request: @@ -8,10 +8,10 @@ on: - .github/workflows/rebuild-16-type-artwork.yml permissions: - contents: write + contents: read jobs: - rebuild: + verify: if: >- github.event.pull_request.head.repo.full_name == 'NHLOCAL/tools' && github.event.pull_request.head.ref == 'codex/redesign-16-type-illustrations' @@ -26,62 +26,111 @@ jobs: - uses: actions/setup-node@v4 with: node-version: '22' - - name: Install the existing site build dependency - run: python -m pip install -r requirements.txt - - name: Identify already-stale generated outputs before changing artwork - run: | - python build.py - python - <<'PY' - import difflib, hashlib, json, pathlib, subprocess - changed = subprocess.check_output(['git', 'diff', '--name-only'], text=True).splitlines() - baseline = {} - for name in changed: - data = pathlib.Path(name).read_bytes() - baseline[name] = hashlib.sha256(data).hexdigest() - print('Pre-existing generated difference:', name) - if name.startswith('tools/') and name.endswith('.html'): - before = subprocess.check_output(['git', 'show', 'HEAD:' + name]).decode() - after = data.decode() - assert before.partition('')[2] == after.partition('')[2], name + ': body changed unexpectedly' - for line in difflib.unified_diff(before.splitlines(), after.splitlines(), n=2): - print(line[:300]) - pathlib.Path('/tmp/preexisting-generated.json').write_text(json.dumps(baseline)) - PY - git restore . - - name: Regenerate artwork and its standalone consumers + - name: Install temporary verification dependencies + run: python -m pip install -r requirements.txt playwright + - name: Validate contracts, scoring and exact build reproducibility run: | + python -m unittest discover -s tests -v + node --test resources/the_16_types/scoring.test.cjs python scripts/redraw_16_type_illustrations.py node resources/the_16_types/build.cjs python build.py - - name: Validate the artwork and existing site contracts - run: | - python -m unittest discover -s tests -v - node --test resources/the_16_types/scoring.test.cjs node resources/the_16_types/build.cjs --check - - name: Provide the exact built page for browser inspection + git diff --exit-code + - name: Exercise the real test and all 16 profile illustrations in Chromium + run: | + python - <<'PY' + import base64, functools, http.server, json, pathlib, shutil, threading + from playwright.sync_api import sync_playwright + root = pathlib.Path.cwd() + evidence = pathlib.Path('/tmp/16-type-review') + evidence.mkdir(exist_ok=True) + class QuietHandler(http.server.SimpleHTTPRequestHandler): + def log_message(self, *args): pass + handler = functools.partial(QuietHandler, directory=str(root)) + server = http.server.ThreadingHTTPServer(('127.0.0.1', 0), handler) + threading.Thread(target=server.serve_forever, daemon=True).start() + url = f'http://127.0.0.1:{server.server_port}/tools/the_16_types.html' + expected = {p.stem: 'data:image/svg+xml;base64,' + base64.b64encode(p.read_bytes()).decode() for p in (root/'assets/illustrations/16-types').glob('*.svg')} + report = [] + with sync_playwright() as p: + executable = shutil.which('google-chrome') or shutil.which('chromium') or shutil.which('chromium-browser') + assert executable, 'A Chromium browser must be available on the runner' + browser = p.chromium.launch(executable_path=executable, headless=True, args=['--no-sandbox']) + print('Browser:', browser.version, executable) + for label, width, height in [('desktop',1280,900), ('mobile',390,844)]: + context = browser.new_context(viewport={'width':width,'height':height}, color_scheme='light', reduced_motion='reduce') + page = context.new_page() + page.set_default_timeout(10000) + errors = [] + page.on('pageerror', lambda error: errors.append(str(error))) + page.on('console', lambda message: errors.append(message.text) if message.type=='error' else None) + page.goto(url, wait_until='networkidle') + assert '16' in page.title() + assert page.locator('#welcome').is_visible() + page.locator('#start').click() + page.locator('input[name=answer][value="2"]').check() + page.locator('#next').click() + assert '2' in page.locator('#question-counter').inner_text() + code = page.evaluate('''() => { + for (let seed=1;seed<=200;seed++) { + const answers=MBTI_DATA.questions.map((q,i)=>1+((i*i+seed*i+seed)%5)); + const result=MBTI.score(MBTI_DATA.questions,answers); + if (!result.code.includes('X')) { + localStorage.setItem('nhlocal.16-types.v1',JSON.stringify({version:MBTI_DATA.revision,answers,current:0})); + return result.code; + } + } + throw new Error('No deterministic complete fixture found'); + }''') + page.reload(wait_until='networkidle') + page.locator('#resume').click() + assert page.locator('#results').is_visible() + hero = page.locator('#profile-card .profile-character') + assert hero.get_attribute('src') == expected[code] + page.locator('.explore > summary').click() + assert page.locator('#type-picker [data-type]').count()==16 + for theme in ('light','dark'): + if page.locator('html').get_attribute('data-theme') != theme: + page.locator('#theme-toggle').click() + assert page.locator('html').get_attribute('data-theme')==theme + for name, src in expected.items(): + button = page.locator(f'#type-picker [data-type="{name}"]') + button.click() + assert button.get_attribute('aria-pressed')=='true' + assert page.locator('#type-preview .type-code').inner_text()==name + image = page.locator('#type-preview .profile-character') + assert image.get_attribute('src')==src + image.evaluate('(image) => image.decode()') + assert image.evaluate('(image) => image.complete && image.naturalWidth>0') + page.locator('#type-picker [data-type="INTP"]').click() + page.locator('#type-preview').scroll_into_view_if_needed() + assert page.evaluate('document.documentElement.scrollWidth <= innerWidth + 1'), 'Horizontal overflow' + page.screenshot(path=str(evidence/f'{label}-{theme}.png')) + sizes=page.locator('#type-preview .profile-character').evaluate('(e) => ({width:e.getBoundingClientRect().width,height:e.getBoundingClientRect().height})') + report.append({'viewport':label,'theme':theme,'profiles':16,'imageSize':sizes,'errors':list(errors)}) + print('Verified:', report[-1]) + assert not errors, errors + context.close() + browser.close() + server.shutdown() + (evidence/'report.json').write_text(json.dumps(report,indent=2)) + print('PASS: welcome, answer selection, question navigation, saved-result resume, 64 type previews, both themes, desktop/mobile, no horizontal overflow or browser errors.') + PY + - name: Preserve browser evidence + if: always() + uses: actions/upload-artifact@v4 + with: + name: 16-type-browser-review + retention-days: 7 + path: /tmp/16-type-review + - name: Provide the editable SVG set without fonts or application bundles uses: actions/upload-artifact@v4 with: - name: 16-type-artwork-validation - retention-days: 3 + name: 16-types-editable-svg + retention-days: 7 path: | - tools/the_16_types.html assets/illustrations/16-types/*.svg - - name: Commit generated assets to this feature branch only - run: | - git config user.name 'github-actions[bot]' - git config user.email '41898282+github-actions[bot]@users.noreply.github.com' - git add assets/illustrations/16-types/*.svg tools/the_16_types.html assets/downloads/the_16_types.js catalog - python - <<'PY' - import hashlib, json, pathlib, subprocess - baseline = json.loads(pathlib.Path('/tmp/preexisting-generated.json').read_text()) - remaining = subprocess.check_output(['git', 'diff', '--name-only'], text=True).splitlines() - for name in remaining: - actual = hashlib.sha256(pathlib.Path(name).read_bytes()).hexdigest() - assert baseline.get(name) == actual, 'Unexpected non-artwork change: ' + name - print('Synchronizing unchanged pre-existing generated output:', name) - subprocess.run(['git', 'add', '--', name], check=True) - PY - if ! git diff --quiet; then exit 1; fi - if git diff --cached --quiet; then exit 0; fi - git commit -m 'Rebuild all 16 SVG illustrations and synchronize generated outputs' - git push origin HEAD:refs/heads/codex/redesign-16-type-illustrations + assets/illustrations/16-types/palettes.json + scripts/redraw_16_type_illustrations.py + tests/test_type_illustrations.py From 2f488ee380dee649fbc1d750e5a878f60b232dde Mon Sep 17 00:00:00 2001 From: NHLOCAL Date: Thu, 17 Sep 2026 02:23:23 +0300 Subject: [PATCH 5/9] Use the questionnaire's orientation keys for the browser test fixture --- .github/workflows/rebuild-16-type-artwork.yml | 22 ++++++++++--------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/.github/workflows/rebuild-16-type-artwork.yml b/.github/workflows/rebuild-16-type-artwork.yml index 93dee99..61f16b7 100644 --- a/.github/workflows/rebuild-16-type-artwork.yml +++ b/.github/workflows/rebuild-16-type-artwork.yml @@ -47,6 +47,12 @@ jobs: evidence.mkdir(exist_ok=True) class QuietHandler(http.server.SimpleHTTPRequestHandler): def log_message(self, *args): pass + def do_GET(self): + if self.path == '/favicon.ico': + self.send_response(204) + self.end_headers() + return + super().do_GET() handler = functools.partial(QuietHandler, directory=str(root)) server = http.server.ThreadingHTTPServer(('127.0.0.1', 0), handler) threading.Thread(target=server.serve_forever, daemon=True).start() @@ -69,19 +75,15 @@ jobs: assert '16' in page.title() assert page.locator('#welcome').is_visible() page.locator('#start').click() - page.locator('input[name=answer][value="2"]').check() + page.locator('.answer-choice').nth(1).click() page.locator('#next').click() assert '2' in page.locator('#question-counter').inner_text() code = page.evaluate('''() => { - for (let seed=1;seed<=200;seed++) { - const answers=MBTI_DATA.questions.map((q,i)=>1+((i*i+seed*i+seed)%5)); - const result=MBTI.score(MBTI_DATA.questions,answers); - if (!result.code.includes('X')) { - localStorage.setItem('nhlocal.16-types.v1',JSON.stringify({version:MBTI_DATA.revision,answers,current:0})); - return result.code; - } - } - throw new Error('No deterministic complete fixture found'); + const answers = MBTI_DATA.questions.map(q => 'INTP'.includes(q.aPole) ? 1 : 5); + const result = MBTI.score(MBTI_DATA.questions, answers); + if (result.code !== 'INTP') throw new Error('Invalid oriented INTP fixture'); + localStorage.setItem('nhlocal.16-types.v1',JSON.stringify({version:MBTI_DATA.revision,answers,current:0})); + return result.code; }''') page.reload(wait_until='networkidle') page.locator('#resume').click() From 5f791d8885118de2d1631508e388e079ce1e2a4e Mon Sep 17 00:00:00 2001 From: NHLOCAL Date: Thu, 17 Sep 2026 02:25:29 +0300 Subject: [PATCH 6/9] Remove the one-off artwork build and browser verification workflow --- .github/workflows/rebuild-16-type-artwork.yml | 138 ------------------ 1 file changed, 138 deletions(-) delete mode 100644 .github/workflows/rebuild-16-type-artwork.yml diff --git a/.github/workflows/rebuild-16-type-artwork.yml b/.github/workflows/rebuild-16-type-artwork.yml deleted file mode 100644 index 61f16b7..0000000 --- a/.github/workflows/rebuild-16-type-artwork.yml +++ /dev/null @@ -1,138 +0,0 @@ -name: Verify redesigned 16-type artwork (one-off) - -on: - pull_request: - types: [opened, synchronize, reopened] - paths: - - scripts/redraw_16_type_illustrations.py - - .github/workflows/rebuild-16-type-artwork.yml - -permissions: - contents: read - -jobs: - verify: - if: >- - github.event.pull_request.head.repo.full_name == 'NHLOCAL/tools' && - github.event.pull_request.head.ref == 'codex/redesign-16-type-illustrations' - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - with: - ref: ${{ github.event.pull_request.head.sha }} - - uses: actions/setup-python@v5 - with: - python-version: '3.12' - - uses: actions/setup-node@v4 - with: - node-version: '22' - - name: Install temporary verification dependencies - run: python -m pip install -r requirements.txt playwright - - name: Validate contracts, scoring and exact build reproducibility - run: | - python -m unittest discover -s tests -v - node --test resources/the_16_types/scoring.test.cjs - python scripts/redraw_16_type_illustrations.py - node resources/the_16_types/build.cjs - python build.py - node resources/the_16_types/build.cjs --check - git diff --exit-code - - name: Exercise the real test and all 16 profile illustrations in Chromium - run: | - python - <<'PY' - import base64, functools, http.server, json, pathlib, shutil, threading - from playwright.sync_api import sync_playwright - root = pathlib.Path.cwd() - evidence = pathlib.Path('/tmp/16-type-review') - evidence.mkdir(exist_ok=True) - class QuietHandler(http.server.SimpleHTTPRequestHandler): - def log_message(self, *args): pass - def do_GET(self): - if self.path == '/favicon.ico': - self.send_response(204) - self.end_headers() - return - super().do_GET() - handler = functools.partial(QuietHandler, directory=str(root)) - server = http.server.ThreadingHTTPServer(('127.0.0.1', 0), handler) - threading.Thread(target=server.serve_forever, daemon=True).start() - url = f'http://127.0.0.1:{server.server_port}/tools/the_16_types.html' - expected = {p.stem: 'data:image/svg+xml;base64,' + base64.b64encode(p.read_bytes()).decode() for p in (root/'assets/illustrations/16-types').glob('*.svg')} - report = [] - with sync_playwright() as p: - executable = shutil.which('google-chrome') or shutil.which('chromium') or shutil.which('chromium-browser') - assert executable, 'A Chromium browser must be available on the runner' - browser = p.chromium.launch(executable_path=executable, headless=True, args=['--no-sandbox']) - print('Browser:', browser.version, executable) - for label, width, height in [('desktop',1280,900), ('mobile',390,844)]: - context = browser.new_context(viewport={'width':width,'height':height}, color_scheme='light', reduced_motion='reduce') - page = context.new_page() - page.set_default_timeout(10000) - errors = [] - page.on('pageerror', lambda error: errors.append(str(error))) - page.on('console', lambda message: errors.append(message.text) if message.type=='error' else None) - page.goto(url, wait_until='networkidle') - assert '16' in page.title() - assert page.locator('#welcome').is_visible() - page.locator('#start').click() - page.locator('.answer-choice').nth(1).click() - page.locator('#next').click() - assert '2' in page.locator('#question-counter').inner_text() - code = page.evaluate('''() => { - const answers = MBTI_DATA.questions.map(q => 'INTP'.includes(q.aPole) ? 1 : 5); - const result = MBTI.score(MBTI_DATA.questions, answers); - if (result.code !== 'INTP') throw new Error('Invalid oriented INTP fixture'); - localStorage.setItem('nhlocal.16-types.v1',JSON.stringify({version:MBTI_DATA.revision,answers,current:0})); - return result.code; - }''') - page.reload(wait_until='networkidle') - page.locator('#resume').click() - assert page.locator('#results').is_visible() - hero = page.locator('#profile-card .profile-character') - assert hero.get_attribute('src') == expected[code] - page.locator('.explore > summary').click() - assert page.locator('#type-picker [data-type]').count()==16 - for theme in ('light','dark'): - if page.locator('html').get_attribute('data-theme') != theme: - page.locator('#theme-toggle').click() - assert page.locator('html').get_attribute('data-theme')==theme - for name, src in expected.items(): - button = page.locator(f'#type-picker [data-type="{name}"]') - button.click() - assert button.get_attribute('aria-pressed')=='true' - assert page.locator('#type-preview .type-code').inner_text()==name - image = page.locator('#type-preview .profile-character') - assert image.get_attribute('src')==src - image.evaluate('(image) => image.decode()') - assert image.evaluate('(image) => image.complete && image.naturalWidth>0') - page.locator('#type-picker [data-type="INTP"]').click() - page.locator('#type-preview').scroll_into_view_if_needed() - assert page.evaluate('document.documentElement.scrollWidth <= innerWidth + 1'), 'Horizontal overflow' - page.screenshot(path=str(evidence/f'{label}-{theme}.png')) - sizes=page.locator('#type-preview .profile-character').evaluate('(e) => ({width:e.getBoundingClientRect().width,height:e.getBoundingClientRect().height})') - report.append({'viewport':label,'theme':theme,'profiles':16,'imageSize':sizes,'errors':list(errors)}) - print('Verified:', report[-1]) - assert not errors, errors - context.close() - browser.close() - server.shutdown() - (evidence/'report.json').write_text(json.dumps(report,indent=2)) - print('PASS: welcome, answer selection, question navigation, saved-result resume, 64 type previews, both themes, desktop/mobile, no horizontal overflow or browser errors.') - PY - - name: Preserve browser evidence - if: always() - uses: actions/upload-artifact@v4 - with: - name: 16-type-browser-review - retention-days: 7 - path: /tmp/16-type-review - - name: Provide the editable SVG set without fonts or application bundles - uses: actions/upload-artifact@v4 - with: - name: 16-types-editable-svg - retention-days: 7 - path: | - assets/illustrations/16-types/*.svg - assets/illustrations/16-types/palettes.json - scripts/redraw_16_type_illustrations.py - tests/test_type_illustrations.py From c640ddd4acb2e229b1cb6b877100ae5b538608ee Mon Sep 17 00:00:00 2001 From: NHLOCAL Date: Thu, 17 Sep 2026 02:55:21 +0300 Subject: [PATCH 7/9] Refine leg and shoe geometry for all 16 type illustrations --- .github/workflows/rebuild-16-type-leg-fix.yml | 55 ++++++++++++ scripts/redraw_16_type_illustrations.py | 90 ++++++++++++++----- tests/test_type_illustration_legs.py | 56 ++++++++++++ 3 files changed, 181 insertions(+), 20 deletions(-) create mode 100644 .github/workflows/rebuild-16-type-leg-fix.yml create mode 100644 tests/test_type_illustration_legs.py diff --git a/.github/workflows/rebuild-16-type-leg-fix.yml b/.github/workflows/rebuild-16-type-leg-fix.yml new file mode 100644 index 0000000..66dd416 --- /dev/null +++ b/.github/workflows/rebuild-16-type-leg-fix.yml @@ -0,0 +1,55 @@ +name: Rebuild 16-type leg fix (one-off) + +on: + push: + branches: [codex/redesign-16-type-illustrations] + paths: + - scripts/redraw_16_type_illustrations.py + - tests/test_type_illustration_legs.py + - .github/workflows/rebuild-16-type-leg-fix.yml + +permissions: + contents: write + +jobs: + rebuild: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + - uses: actions/setup-node@v4 + with: + node-version: '22' + - name: Install existing build dependency + run: python -m pip install -r requirements.txt + - name: Rebuild the SVG set and standalone consumers + run: | + python scripts/redraw_16_type_illustrations.py + node resources/the_16_types/build.cjs + python build.py + - name: Verify geometry, full test suite and deterministic build + run: | + python -m unittest discover -s tests -v + node --test resources/the_16_types/scoring.test.cjs + node resources/the_16_types/build.cjs --check + git diff --name-only + - name: Commit only generated illustration outputs + shell: bash + run: | + allowed='^(assets/illustrations/16-types/[^/]+\.svg|tools/the_16_types\.html|assets/downloads/the_16_types\.js)$' + changed="$(git diff --name-only)" + while IFS= read -r file; do + [ -z "$file" ] && continue + if ! printf '%s\n' "$file" | grep -Eq "$allowed"; then + echo "Unexpected generated change: $file" + exit 1 + fi + done <<< "$changed" + git config user.name 'github-actions[bot]' + git config user.email '41898282+github-actions[bot]@users.noreply.github.com' + git add assets/illustrations/16-types/*.svg tools/the_16_types.html assets/downloads/the_16_types.js + if git diff --cached --quiet; then exit 0; fi + git commit -m 'Fix leg and shoe geometry across all 16 type illustrations' + git push origin HEAD:refs/heads/codex/redesign-16-type-illustrations diff --git a/scripts/redraw_16_type_illustrations.py b/scripts/redraw_16_type_illustrations.py index 2e30b28..5d0c106 100644 --- a/scripts/redraw_16_type_illustrations.py +++ b/scripts/redraw_16_type_illustrations.py @@ -7,6 +7,7 @@ from pathlib import Path from html import escape import json +import math import xml.etree.ElementTree as ET OUT = Path(__file__).resolve().parents[1] / 'assets' / 'illustrations' / '16-types' @@ -23,8 +24,51 @@ def rect(x,y,w,h,r,fill,**attrs): return el('rect',x=x,y=y,width=w,height=h,rx=r def g(content, **attrs): return ''+content+'' def limb(d, color, width=14): return p(d,stroke=INK,stroke_width=width+2.6)+p(d,stroke=color,stroke_width=width) -def shoe(x,y,flip=False,color=INK,angle=0): - return g(p('M0 0H14Q18 4 26 5Q30 6 29 11H-1Q-4 8 0 0Z',color)+p('M0 9H27',stroke=PAPER if color==INK else INK,stroke_width=1,opacity='.38'),transform=f'translate({x} {y}) rotate({angle}) scale({-1 if flip else 1} 1)') +def point(value): + """Small, stable coordinates; rounding is shared by both cuff endpoints.""" + return ' '.join(f'{v:.2f}'.rstrip('0').rstrip('.') if v else '0' for v in value) + +def ankle_edges(x, y, width=15, angle=0): + """World-space ends of the hem, rotated about the ankle, not the heel.""" + theta = math.radians(angle) + dx, dy = width * math.cos(theta) / 2, width * math.sin(theta) / 2 + return (x - dx, y - dy), (x + dx, y + dy) + +def shoe(x, y, flip=False, color=INK, angle=0, cuff=15, sole=None): + """An ankle-centred shoe. Its collar extends 3 units under the trousers. + + Reflection changes only the toe direction: the collar remains centred. + Paint the matching trousers after the shoe to hide the rear collar seam. + """ + half = cuff / 2 + body = (f'M{-half:g} -3H{half:g}' + f'Q{half:g} 0 {half + 2:g} 2L17 4.5' + f'Q21 5.5 21 8V10H{-half:g}' + f'Q{-half - 1:g} 10 {-half - 1:g} 7Z') + line = sole or (PAPER if color == INK else INK) + art = p(body, color) + art += p(f'M{-half + 1:g} 8H19', stroke=line, stroke_width=1, + opacity='.32' if color == INK else '.7') + if color == PAPER: + art += p('M7 2 10 3M5 4 8 5', stroke=line, stroke_width=1) + return g(art, data_part='shoe', + transform=f'translate({x} {y}) rotate({angle}) scale({-1 if flip else 1} 1)') + +def leg(outline, ankle, color, *, flip=False, angle=0, cuff=15, + shoe_color=INK, sole=None): + """One continuous trouser leg and shoe with an exact shared hem. + + L/R are the endpoints of the ankle cross-section, not arbitrary anchors. + Each pose owns its thigh and knee curves; only the join is shared. + """ + if outline.count('{L}') != 1 or outline.count('{R}') != 1: + raise ValueError('A leg outline must include each cuff endpoint once') + left, right = ankle_edges(*ankle, cuff, angle) + trousers = p(outline.format(L=point(left), R=point(right)), color, + data_part='trousers') + return g(shoe(*ankle, flip=flip, color=shoe_color, angle=angle, + cuff=cuff, sole=sole) + trousers, data_part='leg') + def hand(x,y,skin=0,angle=0,kind='grip'): s,sh=SKINS[skin] if kind=='open': @@ -52,7 +96,6 @@ def head(x,y,skin=0,hair='#594335',style='sweep',beard=False,moustache=False,gla if style=='silver':out+=p('M-10-20Q-4-23 2-21',stroke=PAPER,stroke_width=1.4,opacity='.65') if beard: out+=p('M-15 6-10 10-5 10 0 8 6 10 11 9 15 5 13 16Q8 24 0 24Q-10 22-14 15Z',hair,stroke=hair) - # Faces deliberately use few, legible marks rather than tiny stacked details. brow='M-11-2Q-7-4-3-2M4-2Q8-4 12-2' if mood!='thought' else 'M-11-2-4-3M4-3 11-1' out+=p(brow,stroke=hair,stroke_width=1.4) out+=c(-7,3,1.15,INK,stroke='none')+c(8,3,1.15,INK,stroke='none') @@ -87,7 +130,11 @@ def torso(x,color,shade=None,kind='jacket',angle=0): return g(art,transform=f'translate({x} 0) rotate({angle} 0 126)') def standing(x=116, pants=INK, shade='#415363', spread=0): - return g(p('M-23 153H1L-4 201H-20Z',pants)+p(f'M1 153H24L{30+spread} 200 {14+spread} 203 4 174Z',shade)+shoe(-22,200,True)+shoe(13+spread,201),transform=f'translate({x} 0)') + left = leg('M-23 152H2Q1 168-3 180L{R} L{L}Q-23 181-23 152Z', + (-13, 204), pants, flip=True) + right = leg('M1 152H23Q24 170 25 184L{R} L{L}Q8 184 3 173L-1 166Z', + (21 + spread, 204), shade) + return g(left + right, transform=f'translate({x} 0)') def compact_inherited_styles(svg): """Remove only redundant inherited presentation attributes, not geometry.""" @@ -103,7 +150,6 @@ def visit(node, inherited): for child in node: visit(child, current) root = ET.fromstring(svg) - # Whitespace between shapes is irrelevant and is reapplied consistently below. for node in root.iter(): if node.text is not None and not node.text.strip(): node.text = None node.tail = None @@ -116,7 +162,6 @@ def write(code,title,desc,body): start=f'\n{code}: {escape(title)}\n{escape(desc)}\n' bg=c(120,122,84,soft)+el('ellipse',cx=120,cy=216,rx=65,ry=3,fill=INK,opacity='.08') svg=start+bg+'\n'+g(body,fill='none',stroke=INK,stroke_width='1.4',stroke_linecap='round',stroke_linejoin='round')+'\n\n' - # Keep each SVG readable while avoiding redundant attributes and giant path lines. svg=compact_inherited_styles(svg) (OUT/f'{code}.svg').write_text(svg, encoding='utf-8', newline='\n') return svg @@ -126,7 +171,6 @@ def intj(): art=standing(117,INK,'#344B5E') art+=limb('M94 107Q83 116 77 140',a)+limb('M139 107Q151 119 157 139',a) art+=torso(117,a,'#364673')+head(117,67,skin,INK,glasses=True,angle=-5,mood='thought') - # An actual folded three-panel plan, gripped at both outside edges. art+=g(p('M72 135 99 130 127 135 157 128V165L128 172 99 167 72 172Z','#B9CFDE')+p('M99 130 127 135 128 172 99 167Z','#DCE7EF',stroke='none')+p('M99 134V164M127 139V168',stroke=a,opacity='.45')+p('M79 145 91 142V155H85V161M106 159V143L120 146V163M134 159V145L149 141V156',stroke=a,stroke_width=1.5)+p('M108 150 119 152M141 145V157',stroke=a,stroke_width=1),stroke=a) art+=hand(73,149,skin,-8)+hand(156,146,skin,14) write('INTJ','The architect with a folded blueprint','A bespectacled male architect in an indigo jacket studies a three-panel architectural plan. His balanced stance and precise drawing convey quiet planning.',art) @@ -134,9 +178,8 @@ def intj(): def intp(): a,s=PALETTES['INTP'];skin=0 art=rect(67,165,63,7,3,'#B8A28E')+p('M74 173 69 212M122 173 131 212',stroke='#A28A75',stroke_width=4) - art+=p('M97 152Q123 150 139 167L152 191 139 198 120 176 94 175Z','#384954') - art+=p('M79 153H106L100 180 85 196 106 202 102 215 72 207Q64 204 70 193L83 174Z',INK) - art+=shoe(101,207)+shoe(140,194,angle=13) + art+=leg('M101 153Q126 149 142 165Q150 172 149 183L{R} L{L}L135 185Q133 180 122 177L99 174Z', (143,204), '#384954', cuff=14) + art+=leg('M80 153L102 154Q109 164 115 173Q121 180 115 187L{R} L{L}Q94 196 100 183Q88 178 81 168Z', (100,204), INK, cuff=14) art+=limb('M82 107Q64 127 78 144L105 146',a) art+=limb('M128 107 142 126Q146 129 152 123L165 102',a) art+=torso(106,a,'#9680AA')+limb('M77 141Q86 146 103 146',a,12)+hand(106,145,skin,83) @@ -149,7 +192,8 @@ def intp(): def entj(): a,s=PALETTES['ENTJ'];skin=3 art=p('M139 215V192H166V172H192V150H214V215Z','#E8C8CE',stroke='none')+p('M166 191H191M192 171H212',stroke=a,opacity='.25') - art+=p('M84 152H108L104 202H86Z',INK)+p('M108 151 131 149Q142 150 151 160L154 180H138L136 170 114 174Z','#374A57')+shoe(85,201,True)+shoe(139,181) + art+=leg('M84 151H109Q109 170 106 184L{R} L{L}Q84 183 84 151Z', (95,204), INK, flip=True) + art+=leg('M107 151Q127 145 140 153Q152 158 152 168L{R} L{L}L135 171Q122 175 110 174L105 164Z', (144,182), '#374A57', cuff=14) art+=limb('M87 107 72 133Q70 143 93 147',a)+limb('M133 107 152 122Q156 123 160 115L177 88',a) art+=torso(108,a,'#7B3549')+p('M106 106 111 106 115 132 111 138 106 132Z',GOLD,stroke='none') art+=limb('M73 136Q76 144 91 146',a,12)+hand(95,145,skin,75)+head(108,66,skin,INK,'short',moustache=True,angle=-4) @@ -158,7 +202,8 @@ def entj(): def entp(): a,s=PALETTES['ENTP'];skin=1 - art=p('M97 153 120 156 109 184 90 207 77 199 94 172Z',INK)+p('M120 155 142 151 143 180 161 201 148 211 126 188Z','#415363')+shoe(81,200,True,angle=-7)+shoe(150,202,angle=12) + art=leg('M96 151L120 155Q115 177 106 189Q101 197 {R} L{L}Q81 192 91 177Q93 163 96 151Z', (86,204), INK, flip=True, cuff=14) + art+=leg('M120 154L142 150Q144 166 142 177Q146 189 {R} L{L}Q140 195 132 184Q127 177 124 165Z', (157,204), '#415363', cuff=14) art+=limb('M98 107 77 130Q72 135 66 128L49 108',a)+limb('M141 109 158 132Q162 137 169 130L188 105',a) art+=torso(119,a,'#D17A4D',angle=4)+head(117,66,skin,'#8E5038','wave',angle=8) art+=hand(46,105,skin,-35,'open')+hand(190,103,skin,38,'open') @@ -179,8 +224,8 @@ def infj(): def infp(): a,s=PALETTES['INFP'];skin=0 art=rect(67,166,55,43,9,'#D1D8B9',stroke='none')+p('M72 174H117',stroke=a,opacity='.25') - art+=p('M87 155 108 157 103 185 88 204H73L88 177Z','#415340') - art+=p('M106 153Q125 151 143 173Q149 180 143 188L128 204 115 196 129 180 107 177Z',INK)+shoe(77,202,True)+shoe(119,199,angle=20) + art+=leg('M105 153Q128 150 143 170Q151 180 144 190L{R} L{L}Q121 194 130 182Q117 178 105 176Z', (127,204), INK, cuff=14) + art+=leg('M81 153L103 157Q110 169 103 184L{R} L{L}Q83 193 89 179Q81 176 80 166Z', (90,204), '#415340', flip=True, cuff=14) art+=limb('M82 108Q67 126 81 145L100 150',a)+limb('M127 108Q146 121 152 140',a) art+=torso(104,a,'#889A56')+head(103,69,skin,'#624A39','wave',angle=8) art+=limb('M79 143 100 151',a,12) @@ -199,7 +244,8 @@ def enfj(): def enfp(): a,s=PALETTES['ENFP'];skin=1;coat='#C19435' - art=p('M91 153 113 157 99 181 74 201 61 190 84 169Z',INK)+p('M113 157 136 153 141 180 158 203 144 212 121 187Z','#4E5146')+shoe(65,192,True,angle=14)+shoe(146,204,angle=3) + art=leg('M89 151L113 157Q107 173 98 182Q90 190 {R} L{L}Q76 178 84 171Z', (72,191), INK, flip=True, angle=15, cuff=14) + art+=leg('M111 155L136 151Q139 165 139 177Q141 188 {R} L{L}Q133 193 125 184Q118 172 115 166Z', (151,204), '#4E5146', cuff=14) art+=limb('M88 105Q74 122 61 148',coat)+limb('M132 106 151 107Q158 107 160 98L164 79',coat) art+=torso(108,coat,a,angle=-5)+head(108,66,skin,'#684D35','wave',angle=-10)+hand(57,155,skin,15) art+=g(p('M157 47 185 24 209 52 181 80Z',coat)+p('M185 24 181 80 173 48Z',PAPER,stroke='none')+p('M157 47 209 52M185 24 181 80',stroke=a,stroke_width=1.3)+p('M181 80Q168 95 164 79M181 80Q183 99 200 106Q181 114 198 124',stroke=a,stroke_width=1.2)+p('M184 97 193 94 191 103Z',coat)+p('M192 116 201 113 200 122Z',coat),stroke=a) @@ -250,7 +296,8 @@ def esfj(): def istp(): a,s=PALETTES['ISTP'];skin=3 - art=p('M83 154 107 160 92 196 110 205 104 216H79Q68 215 73 204Z',INK)+p('M109 154 132 160 154 174Q159 178 157 186L151 207H135L137 186 111 179Z','#355954')+shoe(103,206)+shoe(136,205) + art=leg('M83 154L108 159Q105 180 99 201Q97 217 84 214L{R} L{L}L83 198Q87 201 89 194Q92 178 93 166Z', (65,196), INK, angle=105, cuff=14) + art+=leg('M104 153Q131 153 151 170Q160 176 157 188L{R} L{L}L136 187Q123 183 111 177L99 166Z', (145,204), '#355954', cuff=14) art+=limb('M78 113Q63 136 51 167',a)+limb('M127 114 149 139Q155 143 160 134L171 115',a) art+=torso(103,a,'#5C9B8B',angle=6)+p('M81 131 92 129 94 140 83 142ZM115 128 126 130 125 141 114 139Z','#276355',stroke='none') art+=head(101,73,skin,'#33463B','cap',beard=True,angle=7)+hand(47,175,skin,25) @@ -261,7 +308,8 @@ def istp(): def isfp(): a,s=PALETTES['ISFP'];skin=0 art=rect(69,166,60,7,3,'#BCA383')+p('M76 174 67 213M122 174 131 213',stroke='#A88C70',stroke_width=4) - art+=p('M81 156 105 159 100 181 84 203 69 198 85 176Z','#D9CBAE')+p('M103 154 126 159 141 175 137 203H120L124 182 104 176Z','#C8B99C')+shoe(75,201,True)+shoe(121,202) + art+=leg('M102 153Q123 154 139 170Q147 177 143 188L{R} L{L}L124 183Q112 179 100 175Z', (131,204), '#C8B99C', cuff=14) + art+=leg('M80 153L104 157Q110 171 103 185L{R} L{L}Q77 193 88 178Q80 174 79 165Z', (84,204), '#D9CBAE', flip=True, cuff=14) art+=limb('M78 109 62 134Q59 141 65 149',a)+limb('M124 112 138 136Q142 141 151 137L158 132',a) art+=torso(101,a,'#B498CC',kind='sweater')+head(99,69,skin,'#6B4E3D','sweep',beard=True,angle=7) art+=g(p('M156 212 177 82 181 82 203 212',stroke='#A78B70',stroke_width=4)+p('M163 202H196',stroke='#A78B70',stroke_width=2)+rect(161,94,47,68,2,'#B99C7D')+rect(165,98,39,59,1,PAPER,stroke='none')+c(193,111,5.5,GOLD,stroke='none')+p('M166 140 178 122 192 141 203 130V156H166Z','#A4B990',stroke='none')+p('M166 150 177 139 190 154 181 157H166Z',a,stroke='none')+p('M157 165H211',stroke='#9C8069',stroke_width=4)) @@ -272,7 +320,8 @@ def isfp(): def estp(): a,s=PALETTES['ESTP'];skin=2;coat='#B56B25' art=p('M134 214 143 195 161 190 183 195 202 214Z','#C7C5B1',stroke='none')+p('M143 195 160 198 168 207M161 190 174 201',stroke='#9C9C8C',stroke_width=1.2) - art+=p('M86 153H110L105 203H88Z',INK)+p('M108 152 132 149Q149 149 157 160L155 179H139L137 168 114 174Z','#4D565A')+shoe(88,201,True)+shoe(140,181) + art+=leg('M86 151H111Q111 171 107 185L{R} L{L}Q86 181 86 151Z', (97,204), INK, flip=True) + art+=leg('M108 152Q132 145 146 155Q158 161 157 170L{R} L{L}L137 173Q124 177 113 175L106 164Z', (147,184), '#4D565A', cuff=14) art+=limb('M87 108Q70 127 64 148',coat)+limb('M133 108Q152 120 151 145',coat) art+=torso(110,coat,'#D5914B')+hand(61,155,skin,-10)+head(110,67,skin,'#403D35','short',glasses='sun',angle=-6) art+=p('M101 105 118 140M130 105 136 141',stroke=INK,stroke_width=2.5) @@ -282,13 +331,14 @@ def estp(): def esfp(): a,s=PALETTES['ESFP'];skin=3 - art=p('M96 153 119 159 109 184 84 206 72 196 96 175Z',INK)+p('M119 155 140 149 159 171 182 182 176 199 148 186 125 175Z','#4F435A')+shoe(78,202,True,color=PAPER,angle=-7)+shoe(180,186,color=PAPER,angle=58) + art=leg('M96 152L120 157Q115 177 106 188Q99 198 {R} L{L}Q78 194 90 180L96 170Z', (85,204), INK, flip=True, cuff=14, shoe_color=PAPER, sole=a) + art+=leg('M118 154L140 149Q149 161 156 169Q163 175 {R} L{L}Q154 191 145 183L125 175Z', (179,196), '#4F435A', angle=-28, cuff=14, shoe_color=PAPER, sole=a) art+=p('M42 111Q25 135 31 167Q35 190 64 195',stroke='#71868E',stroke_width=1.4) art+=limb('M91 107 70 139Q66 144 61 135L43 113',a)+limb('M136 107 157 114Q161 115 166 108L182 88',a) art+=torso(113,a,'#C570A0',angle=-6)+p('M91 148 110 157 96 176 80 163Z','#C570A0',stroke='none')+head(113,65,skin,'#342F38','wave',moustache=True,angle=-10) art+=hand(187,81,skin,34,'open') art+=g(rect(-4,-3,8,28,4,INK)+el('ellipse',cx=0,cy=-10,rx=8,ry=11,fill='#70838B')+p('M-5-16 6-12M-6-11 6-7M-5-6 4-3',stroke=PAPER,stroke_width=1)+rect(-2,7,4,3,1,GOLD,stroke='none'),transform='translate(39 94) rotate(-26)') - art+=hand(45,108,skin,-26)+p('M63 209 76 208M181 198 185 205',stroke=a,stroke_width=1.4) + art+=hand(45,108,skin,-26) write('ESFP','The performer dancing with a microphone','An expressive moustached male performer in a magenta jacket dances in light sneakers. A clearly held microphone, a loose cable and an open raised hand complete the movement.',art) if __name__=='__main__': diff --git a/tests/test_type_illustration_legs.py b/tests/test_type_illustration_legs.py new file mode 100644 index 0000000..3ed9f9e --- /dev/null +++ b/tests/test_type_illustration_legs.py @@ -0,0 +1,56 @@ +"""Regressions for ankle-centred footwear; visual quality is reviewed separately.""" +import importlib.util +import math +from pathlib import Path +import re +import unittest +import xml.etree.ElementTree as ET + +ROOT = Path(__file__).resolve().parents[1] +SPEC = importlib.util.spec_from_file_location('art', ROOT / 'scripts/redraw_16_type_illustrations.py') +ART = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(ART) +NS = '{http://www.w3.org/2000/svg}' + +class AnkleGeometryTests(unittest.TestCase): + def test_cuff_edges_share_the_ankle_centre_at_every_rotation(self): + self.assertTrue(hasattr(ART, 'ankle_edges')) + for angle in (0, 15, -28, 105): + left, right = ART.ankle_edges(85, 204, 14, angle) + self.assertAlmostEqual((left[0] + right[0]) / 2, 85) + self.assertAlmostEqual((left[1] + right[1]) / 2, 204) + self.assertAlmostEqual(math.dist(left, right), 14) + + def test_mirroring_keeps_the_whole_collar_under_the_ankle(self): + for flipped in (False, True): + shoe = ET.fromstring(ART.shoe(90, 204, flip=flipped)) + d = shoe.find('path').get('d') + collar = re.match(r'M\s*(-?[\d.]+)[ ,]+(-?[\d.]+)\s*H\s*(-?[\d.]+)', d) + self.assertIsNotNone(collar) + left, y, right = map(float, collar.groups()) + self.assertLess(left, 0, 'The ankle cannot sit at one edge of the shoe') + self.assertAlmostEqual(left, -right) + self.assertLess(y, 0, 'The collar must overlap the trouser hem') + self.assertEqual(shoe.get('transform'), f'translate(90 204) rotate(0) scale({-1 if flipped else 1} 1)') + + def test_trouser_hem_uses_the_shoe_anchor_and_overlaps_its_collar(self): + self.assertTrue(hasattr(ART, 'leg')) + group = ET.fromstring(ART.leg('M80 160 L{L} L{R} L100 160Z', (90, 204), '#263D48', flip=True, angle=15, cuff=14)) + shoe, trousers = list(group) + self.assertEqual(shoe.get('data-part'), 'shoe') + self.assertEqual(trousers.get('data-part'), 'trousers') + self.assertEqual(shoe.get('transform'), 'translate(90 204) rotate(15) scale(-1 1)') + for edge in ART.ankle_edges(90, 204, 14, 15): + self.assertIn(ART.point(edge), trousers.get('d')) + + def test_each_character_has_exactly_two_integrated_leg_shoe_pairs(self): + for source in (ROOT / 'assets/illustrations/16-types').glob('*.svg'): + with self.subTest(code=source.stem): + svg = ET.parse(source).getroot() + legs = [node for node in svg.iter(NS + 'g') if node.get('data-part') == 'leg'] + self.assertEqual(len(legs), 2) + for leg in legs: + self.assertEqual([node.get('data-part') for node in leg], ['shoe', 'trousers']) + +if __name__ == '__main__': + unittest.main() From eea837ebcbaedf169b7446d35a8bf33be5941cce Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 16 Sep 2026 23:55:37 +0000 Subject: [PATCH 8/9] Fix leg and shoe geometry across all 16 type illustrations --- assets/downloads/the_16_types.js | 2 +- assets/illustrations/16-types/ENFJ.svg | 22 +++++++++++++--------- assets/illustrations/16-types/ENFP.svg | 22 +++++++++++++--------- assets/illustrations/16-types/ENTJ.svg | 22 +++++++++++++--------- assets/illustrations/16-types/ENTP.svg | 22 +++++++++++++--------- assets/illustrations/16-types/ESFJ.svg | 22 +++++++++++++--------- assets/illustrations/16-types/ESFP.svg | 23 ++++++++++++++--------- assets/illustrations/16-types/ESTJ.svg | 20 ++++++++++++-------- assets/illustrations/16-types/ESTP.svg | 20 ++++++++++++-------- assets/illustrations/16-types/INFJ.svg | 22 +++++++++++++--------- assets/illustrations/16-types/INFP.svg | 22 +++++++++++++--------- assets/illustrations/16-types/INTJ.svg | 20 ++++++++++++-------- assets/illustrations/16-types/INTP.svg | 20 ++++++++++++-------- assets/illustrations/16-types/ISFJ.svg | 22 +++++++++++++--------- assets/illustrations/16-types/ISFP.svg | 20 ++++++++++++-------- assets/illustrations/16-types/ISTJ.svg | 20 ++++++++++++-------- assets/illustrations/16-types/ISTP.svg | 22 +++++++++++++--------- tools/the_16_types.html | 2 +- 18 files changed, 205 insertions(+), 140 deletions(-) diff --git a/assets/downloads/the_16_types.js b/assets/downloads/the_16_types.js index 7106663..bd86ffc 100644 --- a/assets/downloads/the_16_types.js +++ b/assets/downloads/the_16_types.js @@ -1,3 +1,3 @@ /* Generated by build.py; loaded only for local-file downloads. */ window.NHLocalDownloads = window.NHLocalDownloads || Object.create(null); -window.NHLocalDownloads["the_16_types"] = "<!DOCTYPE html>
<html lang="he" dir="rtl">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <meta id="theme-color" name="theme-color" content="#fcf7f1">
  <script>
    (() => {
      let saved;
      try { saved = localStorage.getItem("nhlocal.16-types.theme"); } catch {}
      const dark = saved === "dark" || (saved !== "light" && matchMedia("(prefers-color-scheme: dark)").matches);
      document.documentElement.dataset.theme = dark ? "dark" : "light";
      document.getElementById("theme-color").content = dark ? "#171d28" : "#fcf7f1";
    })();
  </script>
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 64 64'%3E%3Crect width='64' height='64' rx='18' fill='%23e9eef5'/%3E%3Ctext x='32' y='45' font-family='Arial' font-size='36' font-weight='700' text-anchor='middle' fill='%23526b91'%3E16%3C/text%3E%3C/svg%3E">
  <style>/* Embedded Assistant font license:
Copyright 2020 The Assistant Project Authors (https://github.com/hafontia/Assistant).
Copyright 2010 The Source Sans Pro Authors (https://github.com/adobe-fonts/source-sans-pro), with Reserved Font Name 'Source'.
Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries.

This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at:
http://scripts.sil.org/OFL


-----------------------------------------------------------
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------

PREAMBLE
The goals of the Open Font License (OFL) are to stimulate worldwide
development of collaborative font projects, to support the font creation
efforts of academic and linguistic communities, and to provide a free and
open framework in which fonts may be shared and improved in partnership
with others.

The OFL allows the licensed fonts to be used, studied, modified and
redistributed freely as long as they are not sold by themselves. The
fonts, including any derivative works, can be bundled, embedded,
redistributed and/or sold with any software provided that any reserved
names are not used by derivative works. The fonts and derivatives,
however, cannot be released under any other type of license. The
requirement for fonts to remain under this license does not apply
to any document created using the fonts or their derivatives.

DEFINITIONS
"Font Software" refers to the set of files released by the Copyright
Holder(s) under this license and clearly marked as such. This may
include source files, build scripts and documentation.

"Reserved Font Name" refers to any names specified as such after the
copyright statement(s).

"Original Version" refers to the collection of Font Software components as
distributed by the Copyright Holder(s).

"Modified Version" refers to any derivative made by adding to, deleting,
or substituting -- in part or in whole -- any of the components of the
Original Version, by changing formats or by porting the Font Software to a
new environment.

"Author" refers to any designer, engineer, programmer, technical
writer or other person who contributed to the Font Software.

PERMISSION & CONDITIONS
Permission is hereby granted, free of charge, to any person obtaining
a copy of the Font Software, to use, study, copy, merge, embed, modify,
redistribute, and sell modified and unmodified copies of the Font
Software, subject to the following conditions:

1) Neither the Font Software nor any of its individual components,
in Original or Modified Versions, may be sold by itself.

2) Original or Modified Versions of the Font Software may be bundled,
redistributed and/or sold with any software, provided that each copy
contains the above copyright notice and this license. These can be
included either as stand-alone text files, human-readable headers or
in the appropriate machine-readable metadata fields within text or
binary files as long as those fields can be easily viewed by the user.

3) No Modified Version of the Font Software may use the Reserved Font
Name(s) unless explicit written permission is granted by the corresponding
Copyright Holder. This restriction only applies to the primary font name as
presented to the users.

4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
Software shall not be used to promote, endorse or advertise any
Modified Version, except to acknowledge the contribution(s) of the
Copyright Holder(s) and the Author(s) or with their explicit written
permission.

5) The Font Software, modified or unmodified, in part or in whole,
must be distributed entirely under this license, and must not be
distributed under any other license. The requirement for fonts to
remain under this license does not apply to any document created
using the Font Software.

TERMINATION
This license becomes null and void if any of the above conditions are
not met.

DISCLAIMER
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
OTHER DEALINGS IN THE FONT SOFTWARE.

*/
@font-face{font-family:Assistant;src:url(data:font/ttf;base64,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) format('truetype');font-weight:200 800;font-display:swap}
:root {
  color-scheme: light;
  --on-accent: #fff;
  --surface-warm: #f6f1ea;
  --surface-cool: #f0f3f7;
  --sheet-border: #ffffffad;
  --sheet-shadow: 10px 12px 0 #efe2d565, 0 18px 40px #687a9610;
  --sheet-row: #fffdf9;
  --sheet-row-alt: #f9f2eb;
  --notice-bg: #f6ecdc;
  --notice-line: #e7d4b4;
  --track: #dce1e8;
  --paper: #fcf7f1;
  --white: #fffdfa;
  --ink: #3b414e;
  --muted: #686772;
  --accent: #526b91;
  --accent-hover: #435b80;
  --clay: #9b634f;
  --blue-soft: #e9eef5;
  --peach-soft: #f5e6dc;
  --line: #e4dfd9;
  --green: #526b91;
  --error: #aa3b37;
  --ease: 180ms ease;
  --soft-shadow: 0 12px 35px #63564c08;
}
:root[data-theme="dark"] {
  color-scheme: dark;
  --paper: #171d28;
  --white: #222c3a;
  --ink: #edf1f7;
  --muted: #b6c1d1;
  --accent: #a5c1eb;
  --accent-hover: #bed2f0;
  --on-accent: #18263b;
  --clay: #e4b298;
  --blue-soft: #293b52;
  --peach-soft: #3a302e;
  --line: #415065;
  --surface-warm: #2b3039;
  --surface-cool: #263241;
  --sheet-border: #35465b;
  --sheet-shadow: 10px 12px 0 #111722, 0 18px 40px #0002;
  --sheet-row: #222e3e;
  --sheet-row-alt: #32333b;
  --notice-bg: #3a3229;
  --notice-line: #64553f;
  --track: #445066;
  --green: #a5c1eb;
  --error: #ffaba5;
  --soft-shadow: 0 10px 30px #0002;
}
* { box-sizing: border-box; }
body { margin: 0; background: var(--paper); color: var(--ink); font-family: Assistant, "Segoe UI", Arial, sans-serif; font-size: 18px; line-height: 1.7; }
button, input, select { font: inherit; }
button, a, summary, select { touch-action: manipulation; }
button { cursor: pointer; color: inherit; }
a { color: inherit; }
button:disabled { cursor: default; opacity: .4; }
[hidden] { display: none !important; }
::selection { background: #d6e1f0; color: var(--ink); }
:focus-visible { outline: 3px solid var(--accent); outline-offset: 5px; }
h1, h2, h3, p { margin-top: 0; }
h1, h2, h3 { line-height: 1.3; font-weight: 700; letter-spacing: 0; }
h2 { font-size: clamp(1.8rem, 3.4vw, 2.7rem); }
h3 { font-size: 1.3rem; }
p { margin-bottom: 1em; }
.shell { max-width: 1170px; padding-inline: 40px; margin-inline: auto; }
.site-header { min-height: 108px; display: flex; justify-content: space-between; align-items: center; gap: 20px; }
.brand { display: flex; align-items: center; gap: 11px; font-size: 1.28rem; font-weight: 550; text-decoration: none; }
.brand-mark { display: grid; place-items: center; flex: 0 0 auto; width: 52px; height: 52px; border-radius: 18px; background: var(--blue-soft); color: var(--accent); font-size: 1.5rem; font-weight: 750; line-height: 1; letter-spacing: 0; direction: ltr; }
.back-link { font-size: .9rem; text-decoration: none; color: var(--muted); padding: 8px 13px; border-radius: 20px; }
.header-actions { display: flex; align-items: center; gap: 16px; }
.theme-toggle { display: grid; place-items: center; width: 44px; height: 44px; flex-shrink: 0; padding: 0; border: 1px solid var(--line); border-radius: 50%; background: var(--white); color: var(--accent); }
.theme-toggle:hover { background: var(--blue-soft); }
.theme-toggle .icon { width: 21px; height: 21px; }
.theme-toggle .theme-sun, [data-theme="dark"] .theme-toggle .theme-moon { display: none; }
[data-theme="dark"] .theme-toggle .theme-sun { display: block; }
.back-link:hover { color: var(--accent); background: var(--blue-soft); }
.back-link { display: inline-flex; align-items: center; gap: 7px; }
.icon { display: block; width: 1.1em; height: 1.1em; flex: 0 0 auto; fill: none; stroke: currentColor; stroke-width: 1.8; stroke-linecap: round; stroke-linejoin: round; }
.screen { animation: arrive .28s ease both; }
.hero { display: grid; grid-template-columns: 1.2fr 1fr; gap: 78px; align-items: center; padding-block: 43px 58px; }
.hero h1 { font-size: clamp(3rem, 5.3vw, 4.7rem); font-weight: 800; line-height: 1.2; letter-spacing: -.015em; margin: 0 0 27px; }
.hero h1 em { font-style: normal; color: var(--clay); font-weight: 800; }
.lead { color: var(--muted); font-size: 1.06rem; line-height: 1.95; max-width: 550px; }
.hero .lead { margin-bottom: 28px; }
.button { display: inline-flex; align-items: center; justify-content: center; gap: 12px; min-height: 48px; max-width: 100%; padding: 11px 22px; border: 1px solid transparent; border-radius: 14px; font-size: 1.125rem; line-height: 1.3; font-weight: 700; text-align: center; text-decoration: none; transition: background var(--ease), transform var(--ease), box-shadow var(--ease); }
.hero-copy > .button { min-height: 52px; padding: 12px 24px; font-size: 1.25rem; gap: 18px; }
.primary { color: var(--on-accent); background: var(--accent); box-shadow: 0 3px 8px #526b9118; }
.primary:not(:disabled):hover { background: var(--accent-hover); transform: translateY(-1px); box-shadow: 0 4px 10px #526b9126; }
.primary:not(:disabled):active { transform: translateY(0); box-shadow: none; }
.secondary { color: var(--ink); background: var(--white); border-color: var(--line); }
.secondary:hover { background: var(--blue-soft); border-color: var(--line); }
.text-button { border: 0; background: transparent; color: var(--muted); padding: 10px 3px; border-radius: 8px; font-size: .85rem; text-decoration: underline; text-decoration-color: transparent; text-underline-offset: 5px; }
.text-button:hover { color: var(--accent); text-decoration-color: currentColor; }
.micro { font-size: .81rem; color: var(--muted); line-height: 1.8; margin-block: 15px 0; }
.type-sheet { position: relative; padding: 20px 27px 30px; background: var(--blue-soft); border: 7px solid var(--sheet-border); border-radius: 43% 43% 37px 37px; transform: rotate(-3deg); box-shadow: var(--sheet-shadow); }
.sheet-number { font-size: 9.2rem; font-weight: 650; line-height: 1.5; letter-spacing: -.11em; text-align: center; direction: ltr; padding-inline-end: .08em; color: var(--accent); }
.sheet-axes { display: grid; gap: 9px; }
.sheet-axes > div { display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 8px; align-items: center; padding: 10px 18px; background: var(--sheet-row); border-radius: 24px; font-size: .91rem; box-shadow: 0 2px 0 #c7d2df44; }
.sheet-axes > div:nth-child(even) { background: var(--sheet-row-alt); }
.sheet-axes > div > span:last-child { text-align: left; }
.sheet-axes bdi { text-align: center; font-size: .8rem; letter-spacing: .06em; color: var(--accent); }
.intro-details { margin: 17px auto 44px; display: grid; grid-template-columns: 1fr 1fr; gap: 16px; align-items: start; }
details { padding: 21px 22px; border: 1px solid var(--line); background: var(--white); border-radius: 23px; box-shadow: 0 4px 14px #60564e03; }
summary { cursor: pointer; font-weight: 600; list-style-position: outside; margin-inline-start: 16px; padding-inline-start: 7px; }
summary::marker { color: #7c8ba1; font-size: .8em; }
details > p, details > div { margin-top: 18px; color: var(--muted); font-size: .93rem; }
.eyebrow { display: inline-flex; align-items: center; gap: 9px; font-size: .83rem; font-weight: 450; color: var(--muted); }
.quiz-wrap { max-width: 850px; margin: 26px auto 55px; }
.quiz-top, .progress-heading { display: flex; justify-content: space-between; align-items: center; gap: 16px; }
.quiz-top { margin-bottom: 15px; }
.progress-heading { font-size: .84rem; margin-bottom: 10px; color: var(--muted); }
progress { display: block; border: 0; background: var(--track); width: 100%; height: 7px; border-radius: 10px; overflow: hidden; accent-color: var(--accent); }
progress::-webkit-progress-bar { background: var(--track); border-radius: 10px; }
progress::-webkit-progress-value { background: var(--accent); border-radius: 10px; transition: width .2s ease; }
progress::-moz-progress-bar { background: var(--accent); border-radius: 10px; }
.question-card { margin-top: 27px; padding: 36px 37px 32px; background: var(--white); border: 1px solid var(--line); border-radius: 32px; box-shadow: var(--soft-shadow); }
.question-card h2 { font-size: clamp(1.4rem, 2.6vw, 1.9rem); font-weight: 700; line-height: 1.55; margin: 0 0 25px; min-height: 3.1em; letter-spacing: 0; }
.situation-options { display: grid; grid-template-columns: 1fr 1fr; gap: 15px; margin-bottom: 25px; }
.situation { padding: 20px; background: var(--surface-warm); border-radius: 22px; }
.situation > span { display: grid; place-items: center; width: 34px; height: 34px; border-radius: 13px; background: var(--blue-soft); color: var(--accent); font-weight: 500; font-size: 1.05rem; margin-bottom: 12px; }
.situation p { margin: 0; font-size: 1.125rem; line-height: 1.7; }
fieldset { border: 0; padding: 0; margin: 0; min-width: 0; }
legend { font-size: 1rem; text-align: center; margin: 0 auto 16px; padding: 0; color: var(--muted); }
.answer-options { display: grid; grid-template-columns: repeat(5, minmax(0, 1fr)); gap: 9px; }
.answer-choice { position: relative; cursor: pointer; }
.answer-choice input { position: absolute; opacity: 0; width: 1px; height: 1px; }
.answer-choice > span { display: flex; align-items: center; justify-content: center; flex-direction: column; gap: 12px; padding: 15px 3px; min-height: 98px; font-size: 1rem; font-weight: 600; line-height: 1.35; text-align: center; border: 1px solid var(--line); border-radius: 18px; background: var(--white); transition: background var(--ease), border-color var(--ease), box-shadow var(--ease); }
.answer-choice i { display: block; width: 19px; height: 19px; border: 1.5px solid var(--muted); border-radius: 50%; position: relative; }
.answer-choice:nth-child(1) i, .answer-choice:nth-child(5) i { width: 24px; height: 24px; }
.answer-choice:nth-child(3) i { width: 14px; height: 14px; }
.answer-choice:hover > span { background: var(--surface-cool); border-color: var(--accent); }
.answer-choice input:checked + span { background: var(--accent); color: var(--on-accent); border-color: var(--accent); box-shadow: 0 2px 7px #526b9118; }
.answer-choice input:checked + span i { border-color: var(--on-accent); background: var(--on-accent); }
.answer-choice input:checked + span i:after { content: ""; position: absolute; inset: 4px; border-radius: 50%; background: var(--accent); }
.answer-choice input:focus-visible + span { outline: 3px solid var(--accent); outline-offset: 4px; }
.quiz-nav { display: flex; justify-content: space-between; gap: 16px; margin-top: 25px; }
.quiz-nav .button { min-width: 112px; }
.quiz-bottom { display: flex; justify-content: flex-end; margin-top: 18px; }
.error { color: var(--error); font-size: .9rem; margin: 18px 0 0; }
.reading-width { max-width: 850px; margin: 38px auto 60px; }
.reading-width h2 { margin-top: 12px; }
.review-group { margin-top: 28px; }
.review-question { display: block; width: 100%; text-align: start; border: 1px solid var(--line); background: var(--white); border-radius: 18px; padding: 17px 20px; margin-bottom: 10px; font-size: .97rem; }
.review-question:hover { background: var(--surface-cool); }
.review-question small { display: block; color: var(--muted); margin-top: 7px; font-size: .85rem; }
.action-row { display: flex; gap: 12px; align-items: center; flex-wrap: wrap; margin-top: 25px; }
.result-intro { margin: 35px 0 29px; }
.result-intro h2 { margin: 15px 0; }
.result-intro .lead { max-width: 750px; }
main.shell:has(#results:not([hidden])) { max-width: 1400px; }
.result-layout { display: grid; grid-template-columns: minmax(0, 1.75fr) minmax(320px, 1fr); gap: 27px; align-items: start; }
#results, .type-profile, .type-chip { --type-accent: var(--type-light-accent, var(--accent)); --type-soft: var(--type-light-soft, var(--blue-soft)); }
[data-theme="dark"] #results, [data-theme="dark"] .type-profile, [data-theme="dark"] .type-chip { --type-accent: var(--type-dark-accent, var(--accent)); --type-soft: var(--type-dark-soft, var(--blue-soft)); }
#results .profile-card { border-color: color-mix(in srgb, var(--type-accent) 30%, var(--line)); }
/* Keep the illustration backdrop distinct from its surrounding surface. */
.type-profile, .type-chip { --type-art-surface: color-mix(in srgb, var(--type-soft) 40%, var(--white)); }
.type-profile .profile-top { background: var(--type-art-surface); }
.type-profile .type-code, .profile-card .type-profile h4, .preview-card.type-profile h4 { color: var(--type-accent); }
.type-profile .experiment { background: var(--type-soft); }
#results .axis-pole.is-dominant { border-color: var(--type-accent); color: var(--type-accent); }
#results .axis-bar i.is-dominant { background: var(--type-accent); }
.profile-card { background: var(--white); padding: 30px; border: 1px solid var(--line); border-radius: 30px; box-shadow: var(--soft-shadow); }
.profile-top { display: flex; align-items: center; justify-content: space-between; gap: 14px; padding: 16px 21px; margin-bottom: 24px; border-radius: 22px; background: var(--blue-soft); }
.profile-codes { display: flex; flex-wrap: wrap; align-items: baseline; gap: 8px 12px; }
.profile-codes .he-code { margin: 0; }
.profile-identity { min-width: 0; }
.profile-identity .profile-name { margin: 12px 0 8px; }
.profile-identity p { margin: 0; font-size: .98rem; color: var(--muted); }
.profile-character { display: block; width: clamp(120px, 16vw, 210px); height: auto; flex: 0 0 auto; }
.type-character { display: block; width: 96px; height: 96px; align-self: center; }
.type-code { font-size: 2.8rem; letter-spacing: .02em; font-weight: 600; line-height: 1.15; color: var(--accent); }
.he-code { font-size: 1.2rem; margin-inline-start: 12px; color: var(--muted); }
.profile-name { font-size: 1.7rem; margin-bottom: 15px; }
.profile-card p { font-size: 1.0625rem; line-height: 1.8; }
.profile-card h4 { font-size: 1.02rem; margin: 25px 0 9px; color: var(--clay); font-weight: 500; }
.profile-card ul { padding-inline-start: 20px; font-size: 1.05rem; }
.profile-card li { margin-bottom: 7px; }
.experiment { padding: 18px 20px; border-radius: 20px; background: var(--peach-soft); margin-top: 25px; }
.experiment h4 { margin-top: 0; }
.experiment p { margin-bottom: 0; }
.axis-panel { container: preferences / inline-size; padding: 28px 25px; background: var(--surface-cool); border: 1px solid var(--line); border-radius: 30px; }
.axis-row { margin: 26px 0; padding-bottom: 24px; border-bottom: 1px solid var(--line); }
.axis-row:last-child { margin-bottom: 0; padding-bottom: 0; border-bottom: 0; }
.axis-title { font-size: 1rem; margin-bottom: 12px; }
.axis-title b { font-weight: 650; }
.axis-labels { display: grid; grid-template-columns: 1fr 1fr; gap: 8px; }
.axis-pole { display: flex; flex-direction: row; align-items: center; justify-content: space-between; gap: 8px; white-space: nowrap; padding: 10px 12px; border: 2px solid transparent; border-radius: 14px; color: var(--muted); }
.axis-pole strong { font-weight: 500; }
.axis-pole.is-dominant { border-color: var(--accent); background: var(--white); color: var(--accent); }
.axis-pole.is-dominant strong { font-weight: 800; }
.axis-pole bdi { font-size: .95rem; font-weight: 650; }
.axis-bar { display: flex; height: 10px; border-radius: 20px; background: var(--track); margin: 12px 0; overflow: hidden; direction: rtl; }
.axis-bar i { display: block; height: 100%; background: var(--track); }
.axis-bar i.is-dominant { background: var(--accent); }
.axis-bar i + i { border-inline-start: 2px solid var(--white); }
.axis-explain { font-size: .96rem; color: var(--muted); line-height: 1.7; margin: 0; }
.axis-explain strong { color: var(--ink); }
.axis-note { font-size: .93rem; color: var(--muted); line-height: 1.7; }
.notice { border: 1px solid var(--notice-line); background: var(--notice-bg); border-radius: 20px; padding: 18px 23px; font-size: .96rem; margin: 25px 0; }
.notice p:last-child { margin-bottom: 0; }
.nearby { margin-top: 27px; padding: 24px; background: var(--surface-warm); border-radius: 25px; }
.nearby p { font-size: .95rem; color: var(--muted); }
.type-chips, .type-picker { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 12px; }
.type-chip { display: flex; flex-direction: column; align-items: stretch; gap: 8px; min-width: 0; border: 1px solid var(--line); border-radius: 18px; background: var(--white); color: var(--ink); padding: 16px; text-align: start; cursor: pointer; transition: background var(--ease), border-color var(--ease); }
.type-chip { border-block-start: 3px solid var(--type-accent); }
.type-chip:hover { background: var(--type-art-surface); border-color: var(--type-accent); }
.type-chip[aria-pressed="true"] { background: var(--type-art-surface); border-color: var(--type-accent); box-shadow: inset 0 0 0 1px var(--type-accent); }
.type-chip-codes { display: flex; align-items: baseline; justify-content: space-between; gap: 8px; }
.type-chip-codes bdi { font-size: 1.3rem; font-weight: 750; color: var(--type-accent); letter-spacing: .04em; }
.type-chip-codes > span { color: var(--muted); font-size: .95rem; }
.type-chip-name { font-size: 1.05rem; font-weight: 650; line-height: 1.4; }
.result-disclaimer { max-width: 930px; }
.explore { margin: 27px 0 40px; }
.explore summary { font-size: 1.2rem; font-weight: 650; }
#type-preview { scroll-margin-top: 24px; }
.preview-card { background: var(--white); padding: 15px; max-width: 820px; color: var(--ink); }
.preview-card p { font-size: .97rem; }
.preview-card h4 { margin-bottom: 8px; }
.preview-card ul { padding-inline-start: 22px; }
.site-footer { display: flex; flex-wrap: wrap; align-items: center; gap: 12px; padding-block: 10px 30px; font-size: .83rem; color: var(--muted); }
.site-footer > div { display: flex; gap: 24px; }
.site-footer .text-button { font-size: .82rem; }
.site-footer section { flex-basis: 100%; max-width: 850px; font-size: .97rem; margin-top: 20px; }
.site-footer section h2 { font-size: 1.6rem; }
.site-footer li { margin-block: 8px; }
.storage-status { background: var(--notice-bg); padding: 14px 19px; border-radius: 16px; font-size: .91rem; }
.toast { position: fixed; bottom: 24px; inset-inline: 20px; max-width: 500px; margin: auto; background: var(--accent-hover); color: var(--on-accent); padding: 14px 22px; border-radius: 20px; z-index: 10; text-align: center; box-shadow: 0 6px 22px #526b9130; font-size: .93rem; }
dialog { border: 1px solid var(--line); border-radius: 28px; padding: 30px; background: var(--paper); color: var(--ink); max-width: 540px; width: calc(100% - 32px); box-shadow: 0 25px 80px #3b414e30; }
dialog h2 { font-size: 1.8rem; }
dialog::backdrop { background: #41495c80; backdrop-filter: blur(4px); }
.sr-only { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0,0,0,0); white-space: nowrap; }
.skip-link { position: fixed; top: -100px; right: 20px; padding: 12px; background: var(--white); z-index: 99; }
.skip-link:focus { top: 15px; }
@keyframes arrive { from { opacity: 0; transform: translateY(5px); } to { opacity: 1; transform: translateY(0); } }
@media (min-width: 1450px) { .hero { padding-block: 62px 65px; } }
@media (max-width: 900px) {
  .shell { padding-inline: 28px; }
  .hero { gap: 35px; padding-block: 35px 40px; }
  .hero h1 { font-size: 3.8rem; }
  .type-sheet { padding: 17px 18px 24px; border-width: 5px; }
  .sheet-number { font-size: 8rem; }
  .sheet-axes > div { font-size: .8rem; padding: 9px 12px; gap: 4px; }
  .sheet-axes bdi { font-size: .75rem; }
  .result-layout { grid-template-columns: 1fr; gap: 20px; }
  .type-chips, .type-picker { grid-template-columns: repeat(2, minmax(0, 1fr)); }
  .profile-card { padding: 25px; }
  .axis-panel { padding: 24px 20px; }
  .axis-title { flex-wrap: wrap; gap: 3px 10px; }
}
@media (max-width: 620px) {
  .header-actions { gap: 9px; }
  .brand { flex-shrink: 0; }
  .shell { padding-inline: 20px; }
  .site-header { min-height: 88px; }
  .brand { font-size: 1.08rem; gap: 9px; }
  .brand-mark { width: 44px; height: 44px; font-size: 1.3rem; border-radius: 17px; }
  .back-link { font-size: .78rem; padding-inline: 4px; }
  .hero { grid-template-columns: 1fr; padding-block: 24px 34px; gap: 35px; }
  .hero h1 { font-size: clamp(2.9rem, 12vw, 3.8rem); margin-bottom: 19px; line-height: 1.23; }
  .lead { font-size: 1rem; line-height: 1.95; }
  .hero .lead { margin-bottom: 23px; }
  .hero-copy > .button { width: auto; }
  .type-sheet { transform: rotate(-2deg); padding: 19px 18px 20px; border-radius: 50px 50px 30px 30px; display: grid; grid-template-columns: .8fr 1.7fr; gap: 12px; margin-inline: 5px; border-width: 4px; box-shadow: var(--sheet-shadow); }
  .sheet-number { font-size: 4.8rem; line-height: 1; align-self: center; }
  .sheet-axes { gap: 7px; }
  .sheet-axes > div { font-size: .75rem; padding: 7px 10px; gap: 3px; border-radius: 15px; }
  .sheet-axes bdi { font-size: .62rem; letter-spacing: 0; }
  .intro-details { grid-template-columns: 1fr; gap: 11px; margin-block: 12px 22px; }
  details { padding: 19px 17px; border-radius: 21px; }
  summary { font-size: .92rem; padding-inline-start: 3px; }
  .quiz-wrap { margin-top: 16px; }
  .quiz-top { gap: 9px; margin-bottom: 10px; }
  .quiz-top .eyebrow, .quiz-top .text-button { font-size: .75rem; }
  .progress-heading { font-size: .77rem; }
  .question-card { padding: 25px 15px; border-radius: 25px; margin-top: 23px; }
  .question-card h2 { font-size: 1.3rem; min-height: 0; line-height: 1.6; margin-bottom: 22px; }
  .situation-options { gap: 10px; margin-bottom: 23px; }
  .situation { padding: 14px 12px 16px; border-radius: 17px; }
  .situation p { font-size: 1rem; line-height: 1.9; }
  .situation > span { width: 29px; height: 29px; border-radius: 10px; font-size: .95rem; margin-bottom: 11px; }
  .situation-options { grid-template-columns: 1fr; }
  .situation { display: grid; grid-template-columns: 29px 1fr; gap: 12px; align-items: start; }
  .situation > span { margin: 0; }
  legend { font-size: .9375rem; }
  .answer-options { grid-template-columns: 1fr; gap: 8px; }
  .answer-choice > span { flex-direction: row; justify-content: flex-start; font-size: 1.0625rem; min-height: 49px; padding: 11px 16px; border-radius: 13px; gap: 13px; text-align: start; }
  .answer-choice i { width: 17px; height: 17px; }
  .answer-choice:nth-child(1) i, .answer-choice:nth-child(5) i { width: 21px; height: 21px; }
  .quiz-nav .button { padding-inline: 18px; min-height: 48px; font-size: 1.125rem; }
  .quiz-nav { gap: 12px; }
  .quiz-bottom .text-button { font-size: .8rem; }
  .reading-width { margin-block: 28px; }
  .result-intro { margin-top: 25px; }
  .type-chip { padding: 12px; }
  .type-chip-codes { flex-wrap: wrap; gap: 4px 8px; }
  .result-layout { grid-template-columns: 1fr; gap: 22px; }
  .profile-card { padding: 24px 20px; border-radius: 25px; }
  .profile-top { padding: 17px; border-radius: 18px; }
  .axis-panel { padding: 25px 20px; border-radius: 25px; }
  .result-actions { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
  .result-actions .primary { grid-column: 1 / -1; justify-self: start; }
  .result-actions .button { font-size: 1.0625rem; padding-inline: 16px; }
  .result-actions .text-button { font-size: .81rem; }
  .site-footer { display: block; padding-bottom: 20px; }
  .site-footer > div { margin-top: 8px; justify-content: space-between; gap: 8px; flex-wrap: wrap; }
  .site-footer .text-button { font-size: .72rem; }
  .notice { font-size: .9rem; padding: 17px; }
  .profile-character { width: 108px; }
  .profile-top { gap: 8px; padding: 12px; }
  .profile-identity .profile-name { font-size: 1.35rem; }
  .profile-identity p { font-size: .85rem; }
  .type-code { font-size: 2.2rem; }
  .profile-name { font-size: 1.6rem; }
  .axis-title { font-size: .9rem; }
  .axis-title span { font-size: .76rem; }
  .axis-labels { font-size: .86rem; }
}
@container preferences (max-width: 350px) {
  .axis-labels { grid-template-columns: 1fr; gap: 6px; }
  .axis-pole { padding: 9px 12px; }
}
@media (max-width: 360px) {
  .shell { padding-inline: 15px; }
  .hero h1 { font-size: 2.9rem; }
  .type-sheet { padding-inline: 12px; gap: 8px; }
  .sheet-number { font-size: 4rem; }
  .sheet-axes > div { font-size: .68rem; padding-inline: 8px; }
  .question-card { padding-inline: 12px; }
  .answer-options { gap: 4px; }
  .answer-choice > span { font-size: 1.0625rem; }
  .quiz-top .eyebrow, .quiz-top .text-button { font-size: .7rem; }
}
@media (prefers-reduced-motion: reduce) { *, *:before, *:after { animation: none !important; transition: none !important; scroll-behavior: auto !important; } }
@media print {
  :root, :root[data-theme="dark"] { color-scheme: light; --paper: #fff; --white: #fff; --ink: #303640; --muted: #525b68; --accent: #526b91; --on-accent: #fff; --clay: #815340; --blue-soft: #eef2f7; --peach-soft: #f7eee7; --line: #ccc; --surface-warm: #faf7f2; --surface-cool: #f4f6f8; --notice-bg: #faf5ed; --notice-line: #ddd; --track: #dce1e8; }
  body { background: white; color: #303640; font-size: 11pt; }
  #results, .type-profile { --type-accent: var(--type-light-accent, #526b91) !important; --type-soft: var(--type-light-soft, #eef2f7) !important; }
  .site-header, .site-footer, .result-actions, .explore, .toast, .storage-status, .skip-link, .screen:not(#results) { display: none !important; }
  .shell { max-width: none; padding: 0; }
  .result-layout { display: block; }
  .profile-card { background: white !important; color: #303640; border: 1px solid #aaa; box-shadow: none; }
  .profile-card p, .profile-card h4 { color: #303640; }
  .axis-panel { margin-top: 20px; break-inside: avoid; }
  .axis-bar { print-color-adjust: exact; -webkit-print-color-adjust: exact; }
  .nearby { break-inside: avoid; }
  .type-chips button { color: #303640; background: white; }
  .result-intro { margin-top: 0; }
  #results[hidden] { display: none !important; }
  dialog { display: none; }
}

/* Clear question choices in dark mode and a separate restart action. */
#fresh { display: block; width: fit-content; margin-top: 8px; }
@media screen {
  :root[data-theme="dark"] .question-card legend { color: var(--ink); font-size: 1.125rem; font-weight: 650; line-height: 1.5; }
  :root[data-theme="dark"] .situation { background: #303f53; border: 1px solid #52667e; }
  :root[data-theme="dark"] .situation p { color: #f5f7fb; font-size: 1.125rem; font-weight: 550; line-height: 1.7; }
  :root[data-theme="dark"] .situation > span { background: #3c5270; color: #f3f7ff; font-weight: 700; }
}

#reset-dialog .action-row { justify-content: flex-end; }
</style>
<!-- catalog metadata:start -->
<title>מבחן 16 הטיפוסים | ארגז הכלים של NH Local</title>
    <meta name="description" content="שאלון עצמאי בעברית בהשראת MBTI, עם 56 שאלות, שמירת התקדמות ותוצאה מפורטת. פועל גם ללא חיבור לרשת.">
    <link rel="canonical" href="https://tools.ze-kal.top/tools/the_16_types.html">
    <meta property="og:type" content="website">
    <meta property="og:locale" content="he_IL">
    <meta property="og:site_name" content="ארגז הכלים של NH Local">
    <meta property="og:title" content="מבחן 16 הטיפוסים | ארגז הכלים של NH Local">
    <meta property="og:description" content="שאלון עצמאי בעברית בהשראת MBTI, עם 56 שאלות, שמירת התקדמות ותוצאה מפורטת. פועל גם ללא חיבור לרשת.">
    <meta property="og:url" content="https://tools.ze-kal.top/tools/the_16_types.html">
    <meta property="og:image" content="https://tools.ze-kal.top/assets/social-card.png">
    <meta property="og:image:width" content="1200"><meta property="og:image:height" content="630">
    <meta property="og:image:alt" content="ארגז הכלים של NH Local: סקילים, כלי דפדפן, סקריפטים ותוספי כרום">
    <meta name="twitter:card" content="summary_large_image">
    <script type="application/ld+json">{"@context": "https://schema.org", "@graph": [{"@type": "WebSite", "@id": "https://tools.ze-kal.top/#website", "url": "https://tools.ze-kal.top/", "name": "ארגז הכלים של NH Local", "inLanguage": "he"}, {"@type": "WebPage", "@id": "https://tools.ze-kal.top/tools/the_16_types.html", "url": "https://tools.ze-kal.top/tools/the_16_types.html", "name": "מבחן 16 הטיפוסים | ארגז הכלים של NH Local", "description": "שאלון עצמאי בעברית בהשראת MBTI, עם 56 שאלות, שמירת התקדמות ותוצאה מפורטת. פועל גם ללא חיבור לרשת.", "inLanguage": "he", "isPartOf": {"@id": "https://tools.ze-kal.top/#website"}}]}</script>
<!-- catalog metadata:end -->
</head>
<body>
<a class="skip-link" href="#main">דילוג לתוכן</a>
<header class="site-header shell">
  <a class="brand" href="the_16_types.html" aria-label="16 הטיפוסים, דף הפתיחה"><span class="brand-mark" aria-hidden="true">16</span><span>הטיפוסים</span></a>
  <div class="header-actions">
    <a class="back-link" href="../index.html">לארגז הכלים <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M7 17 17 7M7 7h10v10"/></svg></a>
    <button id="theme-toggle" class="theme-toggle" type="button" aria-label="מצב אפל" aria-pressed="false" title="מעבר למצב אפל">
      <svg class="icon theme-moon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M20.5 13A8.5 8.5 0 0 1 11 3.5 8.5 8.5 0 1 0 20.5 13Z"/></svg>
      <svg class="icon theme-sun" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><circle cx="12" cy="12" r="4"/><path d="M12 2v2m0 16v2M2 12h2m16 0h2M5 5l1.5 1.5m11 11L19 19M5 19l1.5-1.5m11-11L19 5"/></svg>
    </button>
  </div>
</header>
<main id="main" class="shell" tabindex="-1">
  <section id="welcome" class="screen">
    <div class="hero">
      <div class="hero-copy">
        <h1>מה בדרך כלל<br><em>טבעי לך?</em></h1>
        <p class="lead">לחשוב בקול או לעבד בשקט? לתכנן מראש או להחליט בדרך?<br>56 שאלות על ההעדפות שלך ביומיום, ובסופן פרופיל לפי מודל 16 הטיפוסים.</p>
        <button id="start" class="button primary">להתחלת השאלון <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M19 12H5m7-7-7 7 7 7"/></svg></button>
        <button id="resume" class="button primary" hidden><span>להמשיך מאיפה שעצרתי</span> <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M19 12H5m7-7-7 7 7 7"/></svg></button>
        <button id="fresh" class="text-button" hidden>להתחיל מחדש ולמחוק את ההתקדמות</button>
      </div>
      <aside class="type-sheet" aria-label="ארבעת צירי השאלון">
        <div class="sheet-number" aria-hidden="true">16</div>
        <div class="sheet-axes"><div><span>מוחצן</span><bdi>E / I</bdi><span>מופנם</span></div><div><span>קונקרטי</span><bdi>S / N</bdi><span>עיוני</span></div><div><span>שכלתני</span><bdi>T / F</bdi><span>רגשי</span></div><div><span>גבולני</span><bdi>J / P</bdi><span>פתוח</span></div></div>
      </aside>
    </div>
    <div class="intro-details">
      <details><summary>רגע לפני: איך כדאי לענות?</summary><p>כדאי לחשוב על ההעדפות הרגילות שלך בחודשים האחרונים, כשיש לך חופש לבחור, ולא רק על יום עמוס במיוחד או על תפקיד בעבודה. בכל מצב יש שתי אפשרויות טובות. בוחרים למה נוטים יותר, ובאיזו מידה. כששתיהן מתאימות באותה מידה, אפשר לבחור באמצע.</p><p>אפשר לחזור ולשנות כל תשובה. ההתקדמות נשמרת במכשיר הזה, כל עוד הדפדפן מאפשר זאת. אין צורך לענות מהר.</p></details>
      <details><summary>מה זה MBTI, ומה המבחן הזה מציע?</summary><p>מודל 16 הטיפוסים מחבר ארבעה זוגות של העדפות: מוחצן או מופנם, קונקרטי או עיוני, שכלתני או רגשי, גבולני או פתוח. הצירוף של ארבע הבחירות יוצר אחד מ-16 טיפוסים אפשריים.</p><p>המינוחים בעברית וכינויי הטיפוסים כאן תואמים לטבלה שסופקה לפרויקט. <b>גבולני</b> הוא הכינוי כאן להעדפה למסגרת ולסגירת קצוות (J), ללא משמעות קלינית. <b>רגשי</b> מתאר מתן משקל לערכים ולאנשים, ולא חוסר היגיון. <b>עיוני</b> מתייחס לדפוסים ולאפשרויות, ולא לרמת השכלה.</p><p>זהו שאלון עצמאי בהשראת ארבעת צירי MBTI, ולא מבחן MBTI רשמי או שאלון של 16Personalities. הוא נועד להיכרות עצמית, אינו אבחון ולא עבר תיקוף פסיכומטרי. טיפוס אינו מדד ליכולת או לערך אישי.</p></details>
    </div>
  </section>
  <section id="quiz" class="screen quiz-wrap" hidden aria-labelledby="question-heading">
    <div class="quiz-top"><span id="chapter-label" class="eyebrow"></span><button id="pause" class="text-button">שמירה ויציאה</button></div>
    <div class="progress-heading"><span id="question-counter"></span><span id="progress-text"></span></div>
    <progress id="progress" max="56" value="0" aria-label="שאלות שנענו"></progress>
    <form id="quiz-form" novalidate>
      <div class="question-card">
        <h2 id="question-heading" tabindex="-1"></h2>
        <div class="situation-options"><div class="situation option-a"><span aria-hidden="true">א'</span><p id="option-a"></p></div><div class="situation option-b"><span aria-hidden="true">ב'</span><p id="option-b"></p></div></div>
        <fieldset><legend>מה מרגיש לך יותר טבעי?</legend><div id="answer-options" class="answer-options"></div></fieldset>
        <p id="answer-error" class="error" role="alert" hidden>צריך לבחור תשובה כדי להמשיך. אפשר לבחור גם באמצע</p>
      </div>
      <div class="quiz-nav"><button id="previous" type="button" class="button secondary"><svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M5 12h14m-7-7 7 7-7 7"/></svg> <span>הקודם</span></button><button id="next" type="submit" class="button primary"><span>הבא</span> <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M19 12H5m7-7-7 7 7 7"/></svg></button></div>
    </form>
    <div class="quiz-bottom"><button id="review-link" class="text-button">כל התשובות שלי</button></div>
  </section>
  <section id="review" class="screen reading-width" hidden aria-labelledby="review-heading">
    <span class="eyebrow">בדיקה ועריכה</span><h2 id="review-heading" tabindex="-1">התשובות שלך</h2><p>לחיצה על שאלה מאפשרת לעדכן את התשובה. אין צורך לענות מחדש על הכול.</p><p id="review-count"></p><div id="review-list"></div><div class="action-row"><button id="review-finish" class="button primary"><span>לתוצאות</span> <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M19 12H5m7-7-7 7 7 7"/></svg></button><button id="review-back" class="button secondary">חזרה לשאלון</button></div>
  </section>
  <section id="results" class="screen" hidden aria-labelledby="result-heading">
    <div class="result-intro"><h2 id="result-heading" tabindex="-1"></h2><p id="result-subtitle" class="lead"></p></div>
    <div id="result-notice" class="notice" hidden></div>
    <div class="result-layout"><div id="profile-card" class="profile-card"></div><div class="axis-panel"><h3>ההעדפות שלך בארבעת התחומים</h3><div id="axis-results"></div><p class="axis-note">האחוזים מתארים נטייה בתשובות, ולא סבירות לטיפוס</p></div></div>
    <div id="nearby" class="nearby" hidden><h3>טיפוסים נוספים להשוואה</h3><p id="nearby-explanation"></p><div id="nearby-types" class="type-chips"></div></div>
    <div class="result-actions action-row"><button id="download" class="button primary"><span>לשמור את התוצאה</span> <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M12 3v12m-5-5 5 5 5-5M5 16v5h14v-5"/></svg></button><button id="copy" class="button secondary">העתקת סיכום</button><button id="print" class="button secondary">הדפסה</button><button id="edit" class="text-button">לעבור על התשובות</button><button id="restart" class="text-button">להתחיל מחדש</button></div>
    <p class="micro result-disclaimer">שאלון עצמאי להיכרות עצמית, ללא תיקוף פסיכומטרי. התוצאה אינה אבחון</p>
    <details class="explore"><summary>כל 16 הטיפוסים</summary><p>אפשר לעיין בכל התיאורים. הבחירה כאן אינה משנה את התוצאה שלך.</p><div id="type-picker" class="type-picker" role="group" aria-label="בחירת טיפוס לעיון"></div><div id="type-preview" tabindex="-1"></div></details>
  </section>
  <p id="storage-status" class="storage-status" role="status" hidden></p>
  <noscript><div class="notice">כדי למלא את השאלון נדרש להפעיל JavaScript בדפדפן. אין צורך בחיבור לרשת</div></noscript>
</main>
<footer class="shell site-footer"><div><button id="about-toggle" class="text-button" aria-expanded="false" aria-controls="method">מקורות ושיטת החישוב</button><button id="erase" class="text-button">מחיקת התשובות מהמכשיר</button></div>
<section id="method" hidden><h2>על מה מבוסס השאלון?</h2><p>56 השאלות נכתבו במיוחד לשאלון זה. בכל ציר 14 שאלות במשקל שווה, במחציתן כל צד מופיע ראשון. השאלות עוסקות באנרגיה ועיבוד, קליטת מידע, שיקולי החלטה וגישה למסגרת. הן אינן העתק של שאלון מסחרי.</p><p>כל תשובה מקבלת ערך בין 2- ל-2 בהתאם לכיוון ולמידת ההעדפה. סכום של 14 התשובות בציר מומר לסולם 0 עד 100, עם אמצע ב-50. בשוויון מוצג X ולא נבחר צד שרירותי. כשציון הצד המוביל אינו עולה על 62.5, מוצעים גם צירופים קרובים להשוואה. זהו סף תצוגה שנבחר לשאלון, לא גבול מחקרי או רווח סמך.</p><p>המודל של 16Personalities מוסיף ממד חמישי משלו; הוא אינו נמדד כאן. תיאורי הטיפוסים הם הצעות להתבוננות שנכתבו לשאלון, ולא ניבוי של הצלחה בעבודה או בקשרים. סימולציות עם סוכני שפה שימשו לאיתור בעיות ניסוח וניקוד, ואינן תיקוף על בני אדם.</p><ul><li><a href="https://www.myersbriggs.org/my-mbti-personality-type/the-mbti-preferences/" target="_blank" rel="noopener noreferrer">Myers &amp; Briggs Foundation: ארבעת זוגות ההעדפות</a></li><li><a href="https://www.myersbriggs.org/my-mbti-personality-type/my-mbti-results/" target="_blank" rel="noopener noreferrer">Myers &amp; Briggs Foundation: פרשנות התוצאה והתאמה אישית</a></li><li><a href="https://www.16personalities.com/articles/our-theory" target="_blank" rel="noopener noreferrer">16Personalities: ההבדל בין המודל שלהם ל-MBTI</a></li><li><a href="https://pubmed.ncbi.nlm.nih.gov/2709300/" target="_blank" rel="noopener noreferrer">McCrae &amp; Costa (1989): בחינה ביקורתית של החלוקה לטיפוסים</a></li><li><a href="https://pubmed.ncbi.nlm.nih.gov/16367525/" target="_blank" rel="noopener noreferrer">Tzeng ואחרים (1984): תוקף פריטים וסוגיות בבניית שאלות</a></li></ul></section></footer>
<div id="announcement" class="sr-only" aria-live="polite"></div><div id="toast" class="toast" role="status" hidden></div>
<dialog id="reset-dialog"><h2 id="reset-title">למחוק את התשובות?</h2><p>התשובות והתוצאה השמורות בדפדפן הזה יימחקו. אפשר לבטל ולהמשיך מהמצב הקיים.</p><div class="action-row"><button id="cancel-reset" class="button secondary" autofocus>ביטול</button><button id="confirm-reset" class="button primary">למחוק ולהתחיל מחדש</button></div></dialog>
<script>const MBTI_DATA = {"version":"1.1.0","chapters":["ברגעים הקטנים","אנשים סביבנו","משהו חדש מתחיל","בין רעיון למעשה","כשצריך לבחור","יוצאים מהשגרה","התמונה השלמה"],"questions":[{"id":1,"axis":"EI","aPole":"I","facet":"recharge","text":"התפנה לך ערב אחרי יום עמוס. מה בדרך כלל ממלא אותך מחדש?","a":"זמן שקט לעצמי, בלי צורך לדבר","b":"מפגש או שיחה עם אנשים שנעים לי איתם","sourceId":1},{"id":2,"axis":"SN","aPole":"S","facet":"learning","text":"התחלת ללמוד משחק חדש. איזו פתיחה נוחה לך יותר?","a":"הדגמה של תור אחד, צעד אחר צעד","b":"הסבר של הרעיון שמאחורי המשחק והאפשרויות שבו","sourceId":2},{"id":3,"axis":"TF","aPole":"F","facet":"decisions","text":"בוחרים מקום לבילוי עם חברים. מה נוטה להכריע אצלך כשאין אפשרות שמתאימה להכול?","a":"הרצונות האישיים של מי שיוצאים איתי","b":"השוואה של המחיר, המרחק ומה שיש בכל מקום","sourceId":3},{"id":4,"axis":"JP","aPole":"J","facet":"planning","text":"לקראת יום חופשי, מה מרגיש לך נעים יותר?","a":"להחליט מראש מה עושים ומתי","b":"להשאיר את היום פתוח ולבחור תוך כדי","sourceId":4},{"id":5,"axis":"SN","aPole":"N","facet":"attention","text":"אחרי ביקור במקום מעניין, על מה המחשבות שלך נוטות להתעכב?","a":"על הרעיונות והקשרים שהמקום עורר בי","b":"על המראות והפרטים המסוימים שראיתי","sourceId":5},{"id":6,"axis":"EI","aPole":"E","facet":"processing","text":"רעיון מתחיל להתגבש לך בראש. מה בדרך כלל עוזר להבהיר אותו?","a":"לספר עליו למישהו ולחשוב בקול תוך כדי","b":"לעבד אותו בשקט לפני שמשתפים","sourceId":6},{"id":7,"axis":"JP","aPole":"P","facet":"closure","text":"מצאת אפשרות טובה לבילוי, ואפשר להזמין גם מחר. מה טבעי לך?","a":"להשאיר עוד קצת מקום לאפשרויות נוספות","b":"לסגור את הבחירה ולהתפנות לדברים אחרים","sourceId":7},{"id":8,"axis":"TF","aPole":"T","facet":"fairness","text":"צריך לחלק תורנויות בבית. מה נראה לך הוגן יותר?","a":"לקבוע כלל אחיד שלפיו כולם מתחלקים בתורנויות","b":"להתאים את החלוקה למצב האישי של כל אחד","sourceId":8},{"id":9,"axis":"EI","aPole":"E","facet":"breadth","text":"במפגש נעים שבו אפשר לנוע בין שיחות, למה יש לך יותר חשק?","a":"לפגוש כמה אנשים ולהצטרף למעגלי שיחה שונים","b":"להישאר לשיחה ממושכת עם אדם אחד או שניים","sourceId":9},{"id":10,"axis":"TF","aPole":"T","facet":"feedback","text":"חבר מבקש את דעתך על סיפור שכתב. במה יתמקד המשוב שלך קודם?","a":"עד כמה העלילה מובנת והאירועים מתחברים זה לזה","b":"איך הסיפור השפיע עליי ומה הרגשתי כלפי הדמויות","sourceId":10},{"id":11,"axis":"SN","aPole":"N","facet":"patterns","text":"מישהו מספר על כמה אירועים שקרו לו. למה תשומת הלב שלך נמשכת?","a":"לחוט המקשר ולמשמעות שמסתתרת ביניהם","b":"למה שקרה בכל אירוע ולפרטים שמבדילים ביניהם","sourceId":11},{"id":12,"axis":"JP","aPole":"P","facet":"structure","text":"קבוצה קובעת איך להעביר מפגש חברתי. איזו מסגרת נוחה לך?","a":"כיוון כללי, עם מקום לשנות לפי האווירה","b":"תוכנית מוסכמת, כך שברור מה עומד לקרות","sourceId":12},{"id":13,"axis":"TF","aPole":"F","facet":"conflict","text":"שני חברים חלוקים בדעתם ומבקשים לשמוע את דעתך. מאיפה טבעי לך להתחיל?","a":"ממה שחשוב לכל אחד מהם ומאיך ההחלטה תשפיע עליו","b":"מהטענות של כל אחד מהם ומאיזו מהן מבוססת יותר","sourceId":13},{"id":14,"axis":"JP","aPole":"J","facet":"planning","text":"מתכננים ארוחה משותפת בעוד שבוע. מה עדיף לך?","a":"לקבוע כבר עכשיו מי מביא מה","b":"להחליט קרוב למועד לפי מה שיתאים אז","sourceId":14},{"id":15,"axis":"EI","aPole":"I","facet":"processing","text":"צריך להסביר דעה בנושא מורכב, ויש אפשרות לבחור איך. מה נוח לך יותר?","a":"לנסח אותה בכתב לפני שמשוחחים עליה","b":"לפתח אותה בשיחה שבה אפשר לשאול ולהגיב","sourceId":15},{"id":16,"axis":"SN","aPole":"S","facet":"learning","text":"כשמסבירים לך רעיון מורכב, מה הכי עוזר לך לעקוב?","a":"דוגמה ממשית שממחישה בדיוק למה הכוונה","b":"דימוי או עיקרון רחב שמחבר את החלקים","sourceId":16},{"id":17,"axis":"JP","aPole":"J","facet":"sequence","text":"החלטת ללמוד משהו חדש בזמן הפנוי. איך נוח לך להתקדם?","a":"לחלק את הלמידה לשלבים וללכת לפי הסדר","b":"לבחור בכל פעם במה להעמיק לפי מה שמעניין אותי","sourceId":17},{"id":18,"axis":"SN","aPole":"S","facet":"experience","text":"קראת על דרך חיים שונה מאוד משלך. מה היית רוצה להכיר יותר מקרוב?","a":"איך נראים חיי היומיום: האוכל, הבתים והמנהגים","b":"אילו רעיונות ותפיסות עולם עומדים מאחורי דרך החיים","sourceId":18},{"id":19,"axis":"EI","aPole":"I","facet":"initiation","text":"נכנסת לקבוצה חדשה שמקבלת אותך בחום. מה מרגיש טבעי יותר?","a":"להכיר בהדרגה דרך כמה שיחות אישיות","b":"להיכנס מהר לשיחה הקבוצתית ולהכיר תוך כדי","sourceId":19},{"id":20,"axis":"TF","aPole":"F","facet":"values","text":"שתי אפשרויות מתאימות לך באותה מידה מבחינה מעשית. מה יעזור לך לבחור?","a":"לחשוב איזו מהן קרובה יותר למה שחשוב לי אישית","b":"להשוות את הנימוקים בעד ונגד כל אחת","sourceId":20},{"id":21,"axis":"SN","aPole":"N","facet":"possibilities","text":"קיבלת כלי חדש שאפשר להשתמש בו בדרכים שונות. מה מסקרן אותך קודם?","a":"אילו שימושים חדשים ולא צפויים אפשר להמציא לו","b":"מה הוא יודע לעשות בפועל ואיך משתמשים בו היטב","sourceId":21},{"id":22,"axis":"JP","aPole":"P","facet":"adaptability","text":"באמצע עיסוק בשעות הפנאי עולה רעיון למשהו אחר, ויש זמן לשניהם. מה טבעי לך?","a":"לעצור ולנסות את הרעיון החדש","b":"לסיים את מה שהתחלתי ואז לנסות את הרעיון החדש","sourceId":22},{"id":23,"axis":"TF","aPole":"T","facet":"decisions","text":"קיבלת החלטה שמשפיעה גם על אנשים קרובים. מה נותן לך יותר ביטחון בה?","a":"שיש לי נימוקים ברורים לבחירה שעשיתי","b":"שהבחירה מתאימה למה שחשוב לי ולאנשים הקרובים אליי","sourceId":23},{"id":24,"axis":"EI","aPole":"E","facet":"initiation","text":"במפגש הושיבו אותך ליד אדם שנראה נעים, ועדיין לא דיברתם. מה טבעי לך יותר?","a":"לפתוח בשיחה ולהתחיל להכיר","b":"לתת לשיחה להיפתח בהדרגה, בלי ליזום מיד","sourceId":24},{"id":25,"axis":"TF","aPole":"T","facet":"perspective","text":"כדי לפתור מחלוקת מתמשכת, מה יעזור לך יותר בהתחלה?","a":"להפריד בין הטענות ולבדוק מה מבוסס בכל אחת","b":"להבין מה חשוב לכל צד ומה עומד מאחורי עמדתו","sourceId":25},{"id":26,"axis":"EI","aPole":"E","facet":"recharge","text":"אחרי כמה שעות טובות של עיסוק לבד, מה לרוב מתחשק לך?","a":"לצאת קצת החוצה ולפגוש או לדבר עם אנשים","b":"להמשיך עוד זמן במרחב האישי הנעים שלי","sourceId":26},{"id":27,"axis":"JP","aPole":"P","facet":"sequence","text":"יש כמה דברים לעשות בבית, ואין סדר מחייב. איך נוח לך לגשת אליהם?","a":"לעבור מדבר לדבר לפי מה שמתחשק לי באותו רגע","b":"לבחור סדר ולסיים דבר אחד לפני שמתחילים את הבא","sourceId":27},{"id":28,"axis":"SN","aPole":"S","facet":"attention","text":"כשצריך לתאר חדר שהיה לך נעים בו, במה יתמקד התיאור שלך?","a":"באור, בצבעים, ברהיטים ובמה שהיה בחדר","b":"באווירה, באסוציאציות ובמה שהחדר הזכיר לי","sourceId":31},{"id":29,"axis":"EI","aPole":"I","facet":"privacy","text":"קרה לך משהו אישי ומשמח. מה בדרך כלל מתאים לך?","a":"לשמור אותו לעצמי בהתחלה ולשתף רק מעטים","b":"לשתף כמה אנשים קרובים די מהר","sourceId":29},{"id":30,"axis":"TF","aPole":"F","facet":"appreciation","text":"מישהו מודה לך על עזרה. איזה חלק בדבריו משמעותי לך יותר?","a":"שהרגיש שראיתי אותו והבנתי מה הוא צריך","b":"שהעזרה שלי פתרה את הבעיה בצורה טובה","sourceId":30},{"id":31,"axis":"SN","aPole":"S","facet":"interpretation","text":"בסרט מופיע רגע שאפשר להבין בכמה דרכים. מה מעניין אותך יותר?","a":"מה קרה בפועל ומה הדמויות אמרו ועשו","b":"איזו משמעות נוספת או סמל עשויים להיות ברגע הזה","sourceId":33},{"id":32,"axis":"JP","aPole":"J","facet":"preparation","text":"עומדים לצאת לכמה שעות מהבית. מה נוח לך יותר?","a":"להכין מראש את כל מה שצריך לקחת","b":"לאסוף את הדברים כשמגיע הזמן לצאת","sourceId":32},{"id":33,"axis":"EI","aPole":"I","facet":"stimulation","text":"אפשר לבלות שעה נעימה בבית קפה תוסס או בפינה שקטה. מה מושך אותך יותר?","a":"הפינה השקטה, שבה פחות קורה סביבי","b":"בית הקפה התוסס, שבו מרגישים את האנשים מסביב","sourceId":36},{"id":34,"axis":"SN","aPole":"N","facet":"possibilities","text":"כשעולה רעיון לשיפור מקום מוכר, מה מעסיק אותך קודם?","a":"איך המקום יכול להיראות בעתיד אם נחשוב אחרת","b":"מה פועל בו עכשיו ואיזה שינוי ממשי יועיל","sourceId":38},{"id":35,"axis":"TF","aPole":"F","facet":"support","text":"חבר מספר על יום קשה. מה התגובה הראשונה שטבעית לך?","a":"להקשיב ולתת מקום למה שהוא מרגיש","b":"לברר מה קרה ולחשוב איתו מה עשוי לעזור","sourceId":35},{"id":36,"axis":"JP","aPole":"J","facet":"pace","text":"יש לך שבוע להכין משהו למפגש חברים. איזה קצב מתאים לך יותר?","a":"להתחיל מוקדם ולהתקדם קצת בכל יום","b":"לרכז את ההכנה סמוך למפגש, כשכבר נכנסים לאווירה","sourceId":34},{"id":37,"axis":"SN","aPole":"N","facet":"communication","text":"חבר מבקש לשמוע על חוויה שלך. באיזו דרך טבעי לך לספר?","a":"לספר לו מה החוויה גרמה לי לחשוב ומה היא מזכירה לי","b":"לספר לו מה קרה, לפי הסדר, עם פרטים ותיאורים","sourceId":44},{"id":38,"axis":"EI","aPole":"E","facet":"expression","text":"בחבורה קרובה מבקשים ממך לספר סיפור שכולם יקשיבו לו. איך זה מרגיש לך?","a":"נעים לי להיות במרכז השיחה ולשתף את כולם","b":"נעים לי יותר לספר לאדם אחד מאשר לכל החבורה","sourceId":39},{"id":39,"axis":"JP","aPole":"P","facet":"routine","text":"קבעת לעשות משהו בשעות הפנאי, ובאותו יום מתחשק לך משהו אחר. מה טבעי לך?","a":"לשנות את התוכנית לפי מה שמתאים לי עכשיו","b":"להישאר עם התוכנית שבחרתי מראש","sourceId":37},{"id":40,"axis":"TF","aPole":"T","facet":"support","text":"מישהו מציע לך לשנות הרגל. איזה הסבר עשוי לשכנע אותך יותר?","a":"הסבר שמראה איך השינוי יעבוד ומה התועלת שלו","b":"הסבר שמחבר את השינוי לדברים שחשובים לי בחיים","sourceId":40},{"id":41,"axis":"EI","aPole":"E","facet":"stimulation","text":"יום פנוי עבר כמעט בלי קשר עם אחרים. מה בדרך כלל חסר לך בסופו?","a":"קצת נוכחות של אנשים והתרחשות סביבי","b":"לא בהכרח חסר לי משהו, השקט נעים לי","sourceId":43},{"id":42,"axis":"TF","aPole":"F","facet":"fairness","text":"יש כלל קבוע במפגש חברים, ומישהו מבקש לחרוג ממנו. מה השיקול הראשון שלך?","a":"למה החריגה חשובה לו ומה המשמעות שלה עבורו","b":"האם יש סיבה שאפשר להחיל גם על מקרים דומים","sourceId":45},{"id":43,"axis":"SN","aPole":"S","facet":"experience","text":"משהו קטן בבית לא פועל כרגיל. איך טבעי לך להתחיל לבדוק מה קרה?","a":"לבדוק אחד אחד את הפרטים שאפשר לראות ולנסות","b":"לחשוב על הסבר שיכול לחבר בין כל הסימנים","sourceId":46},{"id":44,"axis":"JP","aPole":"J","facet":"routine","text":"בשגרה שיש לך חופש לקבוע, מה מרגיש לך נוח יותר?","a":"לעשות דברים מסוימים בשעות קבועות","b":"לשנות את סדר היום לפי מה שמתאים בכל פעם","sourceId":47},{"id":45,"axis":"TF","aPole":"F","facet":"feedback","text":"חבר מבקש חוות דעת על בחירה שחשובה לו. איך טבעי לך לנסח הסתייגות?","a":"להסביר קודם שאני מבין מה חשוב לו, ואז לומר מה מטריד אותי","b":"לומר קודם מה הבעיה שאני רואה, ואז להסביר את הסיבה","sourceId":51},{"id":46,"axis":"JP","aPole":"J","facet":"closure","text":"סיימת משהו שיצרת להנאתך, והוא מוצלח בעיניך. מה נעים לך יותר?","a":"להחליט שהוא גמור ולעבור לדבר הבא","b":"להשאיר אותו פתוח לעוד שינויים שיעלו בהמשך","sourceId":52},{"id":47,"axis":"EI","aPole":"I","facet":"company","text":"יש לך תחביב שאפשר ליהנות ממנו לבד או יחד. מה בדרך כלל עדיף לך?","a":"לעסוק בו לבד, בקצב ובמרחב שלי","b":"לעסוק בו עם אחרים ולהחליף חוויות תוך כדי","sourceId":49},{"id":48,"axis":"SN","aPole":"N","facet":"interpretation","text":"בקריאת סיפור, מה נוטה לתפוס אותך יותר?","a":"הרעיונות, הסמלים והאפשרויות לפרשנות","b":"הפרטים החיים והתחושה של להיות בתוך ההתרחשות","sourceId":53},{"id":49,"axis":"JP","aPole":"P","facet":"preparation","text":"יוצאים למקום מוכר ולא חסר שם ציוד. איך נוח לך להתכונן?","a":"לקחת את הדברים הבסיסיים ולהחליט במקום מה עוד צריך","b":"לחשוב מראש על מה שאולי ארצה ולהכין בהתאם","sourceId":55},{"id":50,"axis":"SN","aPole":"N","facet":"application","text":"אפשר לקרוא על שימוש מעשי בתגלית או על מה שעוד עשוי להתאפשר בזכותה. מה מושך אותך יותר?","a":"לחשוב על האפשרויות העתידיות שהיא פותחת","b":"להבין איך אפשר להשתמש בה כבר היום","sourceId":59},{"id":51,"axis":"EI","aPole":"E","facet":"company","text":"בזמן עיסוק נינוח, מכר נעים מתחיל איתך שיחה לא דחופה. מה ההרגשה הראשונית שלך?","a":"נחמד לי שנוצרה הזדמנות לשיחה תוך כדי","b":"הייתי מעדיף להמשיך בעיסוק שלי בלי שיחה כרגע","sourceId":56},{"id":52,"axis":"TF","aPole":"T","facet":"conflict","text":"בני הבית לא מסכימים מה עדיף לעשות. איזה תפקיד טבעי לך לקחת בשיחה?","a":"לחדד את ההבדלים בין ההצעות כדי שיהיה קל להכריע","b":"למצוא מה משותף להצעות כדי שיהיה קל להגיע להסכמה","sourceId":54},{"id":53,"axis":"SN","aPole":"S","facet":"application","text":"בתחום שמעניין אותך, מה מושך אותך יותר?","a":"לשפר משהו קיים כך שיעבוד טוב יותר","b":"לחשוב על משהו חדש שעדיין לא ניסו","sourceId":64},{"id":54,"axis":"JP","aPole":"P","facet":"structure","text":"למשחק חברתי חדש מציעים לקבוע כללים יחד. מה מתאים לך יותר?","a":"להתחיל עם כמה כללים ולהוסיף לפי מה שיתעורר","b":"להסכים מראש על הכללים לפני שמתחילים לשחק","sourceId":58},{"id":55,"axis":"TF","aPole":"T","facet":"values","text":"שמעת הצעה שנשמעת טובה בהתחלה. מה טבעי לך לבדוק קודם?","a":"אילו חסרונות או קשיים אולי לא הביאו בחשבון","b":"מה יש בה שכדאי לתמוך בו ולעודד","sourceId":57},{"id":56,"axis":"EI","aPole":"I","facet":"privacy","text":"הצטרפת לחבורה נחמדה והאווירה פתוחה. כמה מעצמך טבעי לך לשתף בהתחלה?","a":"בעיקר דברים כלליים, ואת האישי לשמור להמשך ההיכרות","b":"גם מחשבות וחוויות אישיות, אם השיחה מזמינה זאת","sourceId":63}],"revision":"1.1.0-f21b74663d17"};
const MBTI_PROFILES = {"ISTJ":{"he":"מקשג","name":"המפקח / הלוגיסטיקן","description":"הצירוף הזה מציע העדפה לעבודה שקולה, לפרטים ממשיים ולהתקדמות בתוך מסגרת ברורה. ייתכן שנוח לך לברר מה נדרש, לבנות דרך מסודרת ולדאוג שגם הפרטים הקטנים יקבלו מענה.","strengths":["מעקב אחר פרטים והתחייבויות","תרגום ניסיון לשיטה שימושית","קבלת החלטות לפי קריטריונים עקביים"],"stretch":"כששיטה מוכרת עובדת, קל לפסול חלופה לפני שנותנים לה הזדמנות. כדאי לברר מתי הניסיון מועיל ומתי התנאים כבר השתנו.","relationships":"אכפתיות יכולה להתבטא אצלך בעשייה ובנוכחות עקבית. לפעמים כדאי לומר במילים את מה שמבחינתך כבר ברור מהמעשים.","work":"מטרה מוגדרת, אחריות ברורה וזמן להכנה עשויים לעזור לך להביא את המיטב.","experiment":"לבחור הרגל קטן ולנסות לו חלופה אחת, בלי להתחייב לאמץ אותה."},"ISFJ":{"he":"מקרג","name":"המגן","description":"כאן נפגשות תשומת לב לפרטים, התחשבות אישית וחיבה למסגרת. ייתכן שחשוב לך לזכור מה מועיל לאנשים סביבך וליצור עבורם תחושה של רציפות וביטחון, גם בלי לעמוד במרכז.","strengths":["זיכרון לפרטים אישיים שימושיים","תמיכה מעשית שמתאימה לאדם","התמדה בטיפוח קשרים ומסגרות"],"stretch":"הרצון לשמור על מה שטוב לאחרים עלול לדחוק את ההעדפות שלך. הבעת צורך אישי אינה מבטלת את ההתחשבות.","relationships":"מחוות קטנות עשויות להיות שפה טבעית עבורך. שיחה מפורשת על ציפיות יכולה לחסוך הנחות שאינן משותפות לשני הצדדים.","work":"סביבה מכבדת, משימות מוחשיות וציפיות ידועות עשויות להתאים לקצב שלך.","experiment":"לנסח בקשה אישית אחת באופן ברור, לפני שמציעים שוב עזרה."},"INFJ":{"he":"מערג","name":"הסנגור","description":"השילוב הזה נוטה לחבר התבוננות פנימית, חיפוש משמעות והתחשבות באנשים עם רצון להתקדם לכיוון ברור. ייתכן שחשוב לך להבין לא רק מה קורה, אלא גם מה עומד מאחוריו ולאן הוא מוביל.","strengths":["חיבור בין רעיונות לערכים","הקשבה למשמעויות שמאחורי הדברים","התמקדות בכיוון בעל משמעות אישית"],"stretch":"תמונה פנימית משכנעת אינה תמיד התמונה של האחר. כדאי לבדוק פרשנויות במקום להניח שהבנת בדיוק למה התכוונו.","relationships":"ייתכן שחשובות לך שיחות עומק וזמן לעיבוד. אפשר לבקש את שניהם במפורש, גם בלי לצפות שאחרים ינחשו.","work":"מרחב ריכוז, מטרה משמעותית ויכולת לתכנן את הדרך עשויים לתמוך בך.","experiment":"לבדוק פרשנות אחת באמצעות שאלה פשוטה: האם לזה התכוונת?"},"INTJ":{"he":"מעשג","name":"האדריכל","description":"התשובות בכיוון הזה מחברות חשיבה עצמאית, זיהוי דפוסים ובחינה עניינית עם רצון במבנה ובהכרעה. ייתכן שנוח לך לבנות תמונה רחבה ואז לחפש את הדרך ההגיונית שתהפוך אותה למציאות.","strengths":["בניית תמונה אסטרטגית","בחינת הנחות ומבנים","מיקוד מאמץ בכיוון ארוך טווח"],"stretch":"תוכנית בהירה בראש אינה בהכרח ברורה לאחרים. שיתוף בהנחות ובשיקולים יכול להיות חלק מהביצוע עצמו.","relationships":"עצמאות וישירות עשויות להיות חשובות לך. כדאי להשאיר מקום גם למה שאנשים מרגישים לפני שמציעים שיפור.","work":"בעיה מורכבת, חופש לחשוב ומטרות ברורות עשויים להיות שילוב נוח עבורך.","experiment":"להציג רעיון לפני שהוא מושלם ולבקש מאדם אחר לזהות הנחה חסרה."},"ISTP":{"he":"מקשפ","name":"האומן / הווירטואוז","description":"זהו שילוב של מרחב אישי, תשומת לב למה שקורה בפועל, בחינה הגיונית וגמישות. ייתכן שנוח לך להבין בעיה דרך התנסות ולבחור פתרון לפי המצב, בלי להעמיס עליו מסגרת מיותרת.","strengths":["איתור תקלות באופן ענייני","למידה דרך התנסות ישירה","התאמת פתרונות לתנאים בשטח"],"stretch":"פתרון שעובד ברגע זה אינו תמיד מסביר לאחרים מה יקרה בהמשך. מעט תיאום מראש יכול להגן על החופש שלך.","relationships":"ייתכן שנוח לך להראות אכפתיות דרך עזרה מעשית וזמן משותף. לפעמים הצד השני צריך גם לשמוע מה עובר עליך.","work":"עצמאות, בעיות מוחשיות ומרחב לשנות את דרך הפעולה עשויים להתאים לך.","experiment":"לשתף מישהו בצעד הבא שלך עוד לפני שהוא שואל."},"ISFP":{"he":"מקרפ","name":"ההרפתקן","description":"כאן נפגשים עיבוד פנימי, חוויה מוחשית, ערכים אישיים וגמישות. ייתכן שנוח לך להרגיש את הדברים מקרוב ולבחור בקצב שלך מה מתאים לך, בלי להפוך כל חוויה לתוכנית מסודרת.","strengths":["רגישות לפרטים בחוויה המיידית","נאמנות למה שחשוב לך","התחשבות אישית שאינה מחייבת במה"],"stretch":"שמירת האפשרויות פתוחות עשויה להקשות על אחרים להבין למה לצפות. אפשר לקבוע עוגן קטן בלי לוותר על גמישות.","relationships":"ייתכן שמעשים וחוויות משותפות קרובים לליבך. הבעת העדפות במילים נותנת לאחרים הזדמנות לכבד אותן.","work":"מרחב אישי, עשייה מוחשית וחופש בדרך הביצוע עשויים לעזור לך.","experiment":"לבחור התחייבות קטנה אחת לשבוע ולתת לה זמן מוגדר."},"INFP":{"he":"מערפ","name":"המתווך","description":"הצירוף הזה מחבר התבוננות פנימית, דמיון וערכים אישיים עם פתיחות לאפשרויות. ייתכן שחשוב לך למצוא דרך שנאמנה למה שיקר לך, ולראות מעבר למצב הקיים גם את מה שהוא יכול להיות.","strengths":["התבוננות מזוויות אפשריות שונות","חיבור בין רעיונות לערכים אישיים","מתן מקום לחוויה של אדם אחר"],"stretch":"כשיש הרבה אפשרויות משמעותיות, הבחירה באחת עלולה להרגיש כמו ויתור. צעד קטן אינו מחייב החלטה לכל החיים.","relationships":"ייתכן שחשובים לך כנות, עומק ומרחב להיות עצמך. שיתוף בצרכים קונקרטיים יכול לקרב יותר מרמזים.","work":"משמעות אישית, זמן לחשיבה וגמישות מסוימת בדרך עשויים לעזור לך להתמיד.","experiment":"להפוך רעיון יקר לך לפעולה שאפשר להשלים בעשרים דקות."},"INTP":{"he":"מעשפ","name":"הלוגיקאי / הפילוסוף","description":"זהו שילוב של מחשבה עצמאית, עניין בדפוסים, בחינה הגיונית ופתיחות. ייתכן שהסקרנות שלך מתעוררת כשאפשר לפרק הנחות, לבדוק הסברים ולגלות אפשרות שלא נראתה בהתחלה.","strengths":["בחינה של עקביות פנימית","יצירת הסברים וחיבורים חדשים","נכונות לעדכן רעיון כשמוצאים בו פער"],"stretch":"תמיד אפשר לחדד עוד, אבל לפעמים ערכו של רעיון מתברר רק כשמנסים אותו. כדאי להגדיר מה מספיק לניסוי ראשון.","relationships":"שיחה על רעיונות עשויה להיות דרך לחיבור. שווה לבדוק אם כרגע מבקשים ממך ניתוח, הקשבה או עזרה מעשית.","work":"שאלות מורכבות, זמן ללא הפרעות וחופש לבדוק חלופות עשויים להתאים לך.","experiment":"להגדיר שעת עצירה למחקר ולהוציא גרסה קטנה שאפשר לבחון."},"ESTP":{"he":"חקשפ","name":"היזם","description":"כאן נפגשים קשר עם הסביבה, התמקדות במציאות, שיקולים ענייניים וגמישות. ייתכן שנוח לך לפגוש מצב כפי שהוא, לנסות משהו ולתקן בהתאם למשוב שמגיע מהשטח.","strengths":["זיהוי אפשרויות מעשיות ברגע נתון","למידה מהירה דרך עשייה","שיחה ישירה שמקדמת פעולה"],"stretch":"הצעד הזמין ביותר אינו תמיד המתאים ביותר לטווח ארוך. עצירה קצרה יכולה לחשוף מחיר שלא רואים מיד.","relationships":"עשייה משותפת ושיחה חיה עשויות להיות טבעיות לך. כדאי לתת מקום גם לקצב עיבוד איטי משלך.","work":"מגע עם אנשים, משוב מיידי ומרחב לאלתור עשויים לעזור לך להתקדם.","experiment":"לפני פעולה חדשה, לרשום תוצאה אפשרית אחת להיום ואחת לעוד חודש."},"ESFP":{"he":"חקרפ","name":"הבדרן","description":"השילוב הזה מציע עניין באנשים, חוויה מוחשית, התחשבות וגמישות. ייתכן שקל לך להתחבר למה שקורה עכשיו ולשים לב כיצד אפשר להפוך את הרגע לנעים ומשמעותי יותר עבור המשתתפים.","strengths":["יצירת קשר דרך חוויה משותפת","תשומת לב לתגובות של אנשים בזמן אמת","התאמה גמישה למה שקורה סביבך"],"stretch":"מה שנעים ברגע זה עלול להשאיר משימה חשובה למועד לא נוח. עוגנים קטנים יכולים לפנות מקום להנאה בהמשך.","relationships":"ייתכן שחום, נוכחות ועשייה משותפת חשובים לך. שיחות שקטות יכולות לחשוף צרכים שאינם בולטים על פני השטח.","work":"סביבה אנושית, משימות מוחשיות ומגוון עשויים להיטיב איתך.","experiment":"לסיים משימה קטנה שקבעת מראש לפני שעוברים להזדמנות המפתה הבאה."},"ENFP":{"he":"חערפ","name":"הפעיל / האקטיביסט","description":"כאן מתחברים עיבוד דרך קשר עם אחרים, חיפוש אפשרויות, ערכים אישיים וגמישות. ייתכן ששיחה טובה מעוררת אצלך כיוונים חדשים, במיוחד כשהם מתחברים לאנשים או למשהו שחשוב לך.","strengths":["חיבור בין רעיונות ואנשים","זיהוי פוטנציאל שעדיין לא התממש","התלהבות שמזמינה השתתפות"],"stretch":"ריבוי כיוונים יכול לפזר את האנרגיה גם כשכולם טובים. בחירת כיוון זמני יכולה לעזור לרעיון אחד לקבל חיים.","relationships":"סקרנות וחילופי מחשבות עשויים להיות דרך טבעית לקרבה. כדאי לבדוק גם אילו התחייבויות קטנות הצד השני צריך.","work":"גיוון, משמעות ומרחב להציע דרכים חדשות עשויים להתאים לך.","experiment":"לבחור רעיון אחד לשבוע הקרוב ולהגדיר לו תוצר קטן ומועד."},"ENTP":{"he":"חעשפ","name":"הפולמוסן / המתווכח","description":"השילוב הזה מחבר חשיבה בקול, עניין באפשרויות, בדיקה עניינית ופתיחות. ייתכן ששיחה היא עבורך מעבדה לרעיונות: מציעים, מערערים ומשנים כדי למצוא זווית טובה יותר.","strengths":["יצירת חלופות לא שגרתיות","זיהוי הנחות שאפשר לאתגר","פיתוח רעיון באמצעות שיחה וביקורת"],"stretch":"בחינת טיעון לשם הסקרנות עלולה להיחוות כביקורת אישית. כדאי להבהיר את הכוונה ולברר אם הצד השני רוצה דיון כזה עכשיו.","relationships":"ייתכן שהחלפת רעיונות נותנת לך אנרגיה. הקשבה בלי להציע מיד זווית נגדית יכולה לפתוח סוג אחר של קרבה.","work":"שאלות פתוחות, שותפים לחשיבה וחופש לנסות חלופות עשויים להיטיב איתך.","experiment":"לבחור חלופה אחת ולבדוק אותה בפועל לפני שמציעים שלוש נוספות."},"ESTJ":{"he":"חקשג","name":"המנהל","description":"זהו חיבור בין מעורבות בסביבה, תשומת לב לעובדות, הכרעה עניינית ומסגרת. ייתכן שנוח לך להבהיר את המטרה, לסכם מה צריך לקרות וליצור סדר שמאפשר לאנשים להתקדם יחד.","strengths":["הפיכת מטרות למשימות מוגדרות","תיאום אחריות וציפיות","בחינת התקדמות לפי נתונים ברורים"],"stretch":"קצב החלטה מהיר עלול להקדים מידע או הסתייגות שעדיין לא נאמרו. הזמנה מפורשת להשמיע קושי יכולה לשפר את התוכנית.","relationships":"נאמנות ועזרה מעשית עשויות להיות חשובות לך. לא כל קושי שמספרים לך עליו דורש ארגון מחדש.","work":"יעדים ברורים, תיאום ומרחב לקדם ביצוע עשויים להתאים לך.","experiment":"לפני סיכום החלטה, לבקש מכל משתתף לציין דבר אחד שעוד לא נשקל."},"ESFJ":{"he":"חקרג","name":"היועץ","description":"כאן נפגשים קשר פעיל עם אנשים, תשומת לב לפרטים, התחשבות ומסגרת. ייתכן שחשוב לך שהציפיות יהיו ברורות ושהאנשים המעורבים ירגישו שיש מי שרואה אותם ודואג למפגש מוצלח.","strengths":["תיאום צרכים מעשיים של אנשים","יצירת תחושת שותפות","מעקב אחר פרטים שמקלים על אחרים"],"stretch":"ניסיון לדאוג לכולם עלול להפוך להסכמה אוטומטית. גבול ברור עוזר לשמור גם על הקשר וגם על הכוחות שלך.","relationships":"שיתוף, מחוות והדדיות עשויים להיות חשובים לך. כדאי לבדוק אם לאחרים יש דרך שונה להביע אכפתיות.","work":"שיתוף פעולה, תפקידים ידועים ומשוב אנושי עשויים לסייע לך.","experiment":"להחליף הסכמה מיידית אחת במשפט: אבדוק מה מתאים לי ואחזור עם תשובה."},"ENFJ":{"he":"חערג","name":"הגיבור","description":"הצירוף הזה מחבר מעורבות חברתית, ראיית אפשרויות, ערכים ורצון בכיוון ברור. ייתכן שנוח לך לחשוב יחד עם אחרים על מה שיכול לצמוח, ולעזור לרעיון משותף להפוך למחויבות מעשית.","strengths":["ניסוח כיוון שאנשים יכולים להתחבר אליו","זיהוי שאיפות וצרכים בשיחה","ארגון מאמץ סביב מטרה משותפת"],"stretch":"ראיית פוטנציאל באדם אינה אומרת שזה הכיוון שהוא רוצה. אפשר להציע תמיכה ולהשאיר את הבחירה בידיו.","relationships":"ייתכן שחשוב לך לדבר על משמעות ועל צמיחה משותפת. לפעמים קשר צריך פשוט מקום להיות, בלי יעד לשיפור.","work":"מטרה בעלת משמעות, קשר עם אנשים ותוכנית ברורה עשויים להתאים לך.","experiment":"לשאול אדם קרוב איזה סוג תמיכה הוא רוצה, ולפעול לפי תשובתו."},"ENTJ":{"he":"חעשג","name":"המפקד","description":"כאן מתחברים חשיבה דרך מעורבות, תמונה רחבה, הכרעה עניינית והעדפה למסגרת. ייתכן שנוח לך לזהות כיוון, להציב סדרי עדיפויות ולהניע שיחה שמסתיימת בהחלטה ובצעד הבא.","strengths":["חיבור בין אסטרטגיה להחלטות","תעדוף של מאמץ ומשאבים","הבהרת מטרות והנעת התקדמות"],"stretch":"כשברור לך מה צריך לקרות, קל להניח שגם לאחרים ברור ומוסכם. בדיקת ההבנה וההשפעה האנושית יכולה לחזק את הביצוע.","relationships":"ישירות ומחויבות עשויות להיות חשובות לך. אפשר להראות אכפתיות גם בהקשבה שאין בסופה פתרון.","work":"אתגר מורכב, אחריות ברורה ואפשרות לקדם כיוון עשויים לעזור לך.","experiment":"בדיון הבא, לשמוע את ההצעות של האחרים לפני שמציגים את ההכרעה שלך."}};
const MBTI_ILLUSTRATIONS = {"ISTJ":"data:image/svg+xml;base64,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","ISFJ":"data:image/svg+xml;base64,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","INFJ":"data:image/svg+xml;base64,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","INTJ":"data:image/svg+xml;base64,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","ISTP":"data:image/svg+xml;base64,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","ISFP":"data:image/svg+xml;base64,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","INFP":"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNDAgMjQwIiByb2xlPSJpbWciIGFyaWEtbGFiZWxsZWRieT0iaW5mcC10aXRsZSIgYXJpYS1kZXNjcmliZWRieT0iaW5mcC1kZXNjIj4KPHRpdGxlIGlkPSJpbmZwLXRpdGxlIj5JTkZQOiBUaGUgcmVhZGVyIGFic29yYmVkIGluIGEgYm9vazwvdGl0bGU+CjxkZXNjIGlkPSJpbmZwLWRlc2MiPkEgZ2VudGxlIG1hbGUgcmVhZGVyIGluIGFuIG9saXZlIGphY2tldCBzaXRzIG9uIGEgc21hbGwgY3VzaGlvbi4gSGUgbGVhbnMgdG93YXJkIGFuIG9wZW4gYm9vaywgd2l0aCBib3RoIGhhbmRzIHJlc3RpbmcgbmF0dXJhbGx5IG9uIHRoZSBwYWdlIGVkZ2VzLjwvZGVzYz4KPGNpcmNsZSBjeD0iMTIwIiBjeT0iMTIyIiByPSI4NCIgZmlsbD0iI0VGRjJFMiIvPgo8ZWxsaXBzZSBjeD0iMTIwIiBjeT0iMjE2IiByeD0iNjUiIHJ5PSIzIiBmaWxsPSIjMjYzRDQ4IiBvcGFjaXR5PSIuMDgiLz4KPGcgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjMjYzRDQ4IiBzdHJva2Utd2lkdGg9IjEuNCIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIj4KPHJlY3QgeD0iNjciIHk9IjE2NiIgd2lkdGg9IjU1IiBoZWlnaHQ9IjQzIiByeD0iOSIgZmlsbD0iI0QxRDhCOSIgc3Ryb2tlPSJub25lIi8+CjxwYXRoIGQ9Ik03MiAxNzRIMTE3IiBzdHJva2U9IiM1RTcwMzQiIG9wYWNpdHk9Ii4yNSIvPgo8cGF0aCBkPSJNODcgMTU1IDEwOCAxNTcgMTAzIDE4NSA4OCAyMDRINzNMODggMTc3WiIgZmlsbD0iIzQxNTM0MCIvPgo8cGF0aCBkPSJNMTA2IDE1M1ExMjUgMTUxIDE0MyAxNzNRMTQ5IDE4MCAxNDMgMTg4TDEyOCAyMDQgMTE1IDE5NiAxMjkgMTgwIDEwNyAxNzdaIiBmaWxsPSIjMjYzRDQ4Ii8+CjxnIHRyYW5zZm9ybT0idHJhbnNsYXRlKDc3IDIwMikgcm90YXRlKDApIHNjYWxlKC0xIDEpIj4KPHBhdGggZD0iTTAgMEgxNFExOCA0IDI2IDVRMzAgNiAyOSAxMUgtMVEtNCA4IDAgMFoiIGZpbGw9IiMyNjNENDgiLz4KPHBhdGggZD0iTTAgOUgyNyIgc3Ryb2tlPSIjRkZGOUVEIiBzdHJva2Utd2lkdGg9IjEiIG9wYWNpdHk9Ii4zOCIvPgo8L2c+CjxnIHRyYW5zZm9ybT0idHJhbnNsYXRlKDExOSAxOTkpIHJvdGF0ZSgyMCkgc2NhbGUoMSAxKSI+CjxwYXRoIGQ9Ik0wIDBIMTRRMTggNCAyNiA1UTMwIDYgMjkgMTFILTFRLTQgOCAwIDBaIiBmaWxsPSIjMjYzRDQ4Ii8+CjxwYXRoIGQ9Ik0wIDlIMjciIHN0cm9rZT0iI0ZGRjlFRCIgc3Ryb2tlLXdpZHRoPSIxIiBvcGFjaXR5PSIuMzgiLz4KPC9nPgo8cGF0aCBkPSJNODIgMTA4UTY3IDEyNiA4MSAxNDVMMTAwIDE1MCIgc3Ryb2tlLXdpZHRoPSIxNi42Ii8+CjxwYXRoIGQ9Ik04MiAxMDhRNjcgMTI2IDgxIDE0NUwxMDAgMTUwIiBzdHJva2U9IiM1RTcwMzQiIHN0cm9rZS13aWR0aD0iMTQiLz4KPHBhdGggZD0iTTEyNyAxMDhRMTQ2IDEyMSAxNTIgMTQwIiBzdHJva2Utd2lkdGg9IjE2LjYiLz4KPHBhdGggZD0iTTEyNyAxMDhRMTQ2IDEyMSAxNTIgMTQwIiBzdHJva2U9IiM1RTcwMzQiIHN0cm9rZS13aWR0aD0iMTQiLz4KPGcgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoMTA0IDApIHJvdGF0ZSgwIDAgMTI2KSI+CjxwYXRoIGQ9Ik0tMTAgOTZRLTI2IDk3LTI4IDEwOUwtMjQgMTU4UTAgMTYzIDI2IDE1NkwyNSAxMDlRMjMgOTkgMTAgOTZaIiBmaWxsPSIjNUU3MDM0Ii8+CjxwYXRoIGQ9Ik0tOSA5NyAwIDEwNCAxMCA5NyAxMiAxNTYtNyAxNTlaIiBmaWxsPSIjRkZGOUVEIiBzdHJva2U9Im5vbmUiLz4KPHBhdGggZD0iTS0xMSA5Ni0yIDEwNC0xMCAxMjItMjAgMTA4WiIgZmlsbD0iIzg4OUE1NiIgc3Ryb2tlPSJub25lIi8+CjxwYXRoIGQ9Ik0xMSA5NiAyIDEwNCAxMiAxMjEgMjEgMTA3WiIgZmlsbD0iIzg4OUE1NiIgc3Ryb2tlPSJub25lIi8+CjxwYXRoIGQ9Ik0tMTAgMTI0LTExIDE1NE0xMyAxMjUgMTYgMTUzIiBzdHJva2U9IiNGRkY5RUQiIHN0cm9rZS13aWR0aD0iMSIgb3BhY2l0eT0iLjI4Ii8+CjwvZz4KPGcgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoMTAzIDY5KSByb3RhdGUoOCkiPgo8cmVjdCB4PSItNiIgeT0iMTciIHdpZHRoPSIxMiIgaGVpZ2h0PSIxNiIgcng9IjMiIGZpbGw9IiNFREMyQTEiLz4KPHBhdGggZD0iTS01IDIxUTAgMjYgNiAyMlYyOFEwIDMwLTUgMjdaIiBmaWxsPSIjRDg5Qzc3IiBzdHJva2U9Im5vbmUiLz4KPGVsbGlwc2UgY3g9Ii0xNi41IiBjeT0iMyIgcng9IjMuNSIgcnk9IjUiIGZpbGw9IiNFREMyQTEiLz4KPGVsbGlwc2UgY3g9IjE2LjUiIGN5PSIzIiByeD0iMy41IiByeT0iNSIgZmlsbD0iI0VEQzJBMSIvPgo8cGF0aCBkPSJNLTE2LTEyUS0xNi0yNCAwLTI0UTE2LTI0IDE2LTEyVjdRMTUgMjEgMCAyNFEtMTQgMjItMTYgOFoiIGZpbGw9IiNFREMyQTEiLz4KPHBhdGggZD0iTS0xNiA0US0yMi01LTE3LTEyUS0yMS0yMi0xMC0yM1EtMy0zMCA1LTI1UTE2LTI5IDE4LTE4UTI0LTEzIDE3LTVMMTMgMlYtOVEzLTQtNC0xM1EtOC03LTEyLThWNFoiIGZpbGw9IiM2MjRBMzkiIHN0cm9rZT0iIzYyNEEzOSIvPgo8cGF0aCBkPSJNLTExLTJRLTctNC0zLTJNNC0yUTgtNCAxMi0yIiBzdHJva2U9IiM2MjRBMzkiLz4KPGNpcmNsZSBjeD0iLTciIGN5PSIzIiByPSIxLjE1IiBmaWxsPSIjMjYzRDQ4IiBzdHJva2U9Im5vbmUiLz4KPGNpcmNsZSBjeD0iOCIgY3k9IjMiIHI9IjEuMTUiIGZpbGw9IiMyNjNENDgiIHN0cm9rZT0ibm9uZSIvPgo8cGF0aCBkPSJNMSA0LTEgOSAyIDEwIiBzdHJva2U9IiNEODlDNzciIHN0cm9rZS13aWR0aD0iMS4yIi8+CjxwYXRoIGQ9Ik0tNSAxNFEwIDE5IDYgMTQiLz4KPC9nPgo8cGF0aCBkPSJNNzkgMTQzIDEwMCAxNTEiIHN0cm9rZS13aWR0aD0iMTQuNiIvPgo8cGF0aCBkPSJNNzkgMTQzIDEwMCAxNTEiIHN0cm9rZT0iIzVFNzAzNCIgc3Ryb2tlLXdpZHRoPSIxMiIvPgo8ZyBzdHJva2U9IiM1RTcwMzQiPgo8cGF0aCBkPSJNOTYgMTQwUTExMCAxMzcgMTI0IDE0NVExMzggMTM1IDE1NiAxMzhMMTUzIDE2OFExMzkgMTY2IDEyNiAxNzZRMTEwIDE2OSA5NyAxNzJaIiBmaWxsPSIjRThENEE4Ii8+CjxwYXRoIGQ9Ik05OSAxMzlRMTExIDEzNyAxMjQgMTQ0UTE0MCAxMzQgMTUzIDEzN0wxNTAgMTY0UTEzNyAxNjQgMTI1IDE3MlExMTIgMTY2IDEwMCAxNjhaIiBmaWxsPSIjRkZGOUVEIi8+CjxwYXRoIGQ9Ik0xMjQgMTQ1IDEyNSAxNzFNMTA1IDE0NSAxMTcgMTQ4TTEwNSAxNTEgMTE3IDE1NE0xMzIgMTQ3IDE0NiAxNDNNMTMyIDE1MyAxNDUgMTQ5IiBzdHJva2Utd2lkdGg9IjEuMiIvPgo8L2c+CjxnIHRyYW5zZm9ybT0idHJhbnNsYXRlKDk4IDE1Nikgcm90YXRlKC05KSI+CjxwYXRoIGQ9Ik0tNSAzVi00US01LTctMi03SDNRNy03IDctM1YzUTYgOCAxIDhRLTMgOC01IDNaIiBmaWxsPSIjRURDMkExIi8+CjxwYXRoIGQ9Ik0tNSAwLTEtMlEyLTMgMyAwTDAgMyIgc3Ryb2tlPSIjRDg5Qzc3IiBzdHJva2Utd2lkdGg9IjEiLz4KPC9nPgo8ZyB0cmFuc2Zvcm09InRyYW5zbGF0ZSgxNTQgMTUzKSByb3RhdGUoOSkiPgo8cGF0aCBkPSJNLTUgM1YtNFEtNS03LTItN0gzUTctNyA3LTNWM1E2IDggMSA4US0zIDgtNSAzWiIgZmlsbD0iI0VEQzJBMSIvPgo8cGF0aCBkPSJNLTUgMC0xLTJRMi0zIDMgMEwwIDMiIHN0cm9rZT0iI0Q4OUM3NyIgc3Ryb2tlLXdpZHRoPSIxIi8+CjwvZz4KPC9nPgo8L3N2Zz4K","INTP":"data:image/svg+xml;base64,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","ESTP":"data:image/svg+xml;base64,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","ESFP":"data:image/svg+xml;base64,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","ENFP":"data:image/svg+xml;base64,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","ENTP":"data:image/svg+xml;base64,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","ESTJ":"data:image/svg+xml;base64,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","ESFJ":"data:image/svg+xml;base64,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","ENFJ":"data:image/svg+xml;base64,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","ENTJ":"data:image/svg+xml;base64,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"};
const MBTI_PALETTES = {"INTJ":{"accent":"#43558B","soft":"#EBEDF7","darkAccent":"#AFBAF4","darkSoft":"#252D49"},"INTP":{"accent":"#745F8B","soft":"#F0EBF5","darkAccent":"#CEB4E6","darkSoft":"#362A43"},"ENTJ":{"accent":"#933F56","soft":"#F7E9ED","darkAccent":"#F2A9BA","darkSoft":"#482935"},"ENTP":{"accent":"#A4502B","soft":"#F9ECDF","darkAccent":"#F5B48C","darkSoft":"#493124"},"INFJ":{"accent":"#3B6C59","soft":"#E7F1EB","darkAccent":"#9ED4B7","darkSoft":"#263D33"},"INFP":{"accent":"#5E7034","soft":"#EFF2E2","darkAccent":"#C6D598","darkSoft":"#363D25"},"ENFJ":{"accent":"#267376","soft":"#E4F2EF","darkAccent":"#98DADB","darkSoft":"#203D40"},"ENFP":{"accent":"#89641B","soft":"#FBF2D8","darkAccent":"#EAC66F","darkSoft":"#443921"},"ISTJ":{"accent":"#476778","soft":"#E8EFF3","darkAccent":"#ABCADB","darkSoft":"#293942"},"ISFJ":{"accent":"#9A5263","soft":"#F7EAEE","darkAccent":"#EDB3C2","darkSoft":"#472D37"},"ESTJ":{"accent":"#345A8B","soft":"#E7EEF7","darkAccent":"#A9C7F2","darkSoft":"#26354B"},"ESFJ":{"accent":"#A1503E","soft":"#FAEAE3","darkAccent":"#F3B29C","darkSoft":"#4B302A"},"ISTP":{"accent":"#317469","soft":"#E4F2EE","darkAccent":"#98D6C8","darkSoft":"#243F38"},"ISFP":{"accent":"#795B98","soft":"#F2EAF9","darkAccent":"#D3B6F1","darkSoft":"#3B2D4C"},"ESTP":{"accent":"#9B5B20","soft":"#FFF0DE","darkAccent":"#F7C286","darkSoft":"#4C3724"},"ESFP":{"accent":"#A3477A","soft":"#F9E9F2","darkAccent":"#F0AED4","darkSoft":"#492C40"}};</script>
<script>/* Shared by the standalone page and Node verification. No fitted persona weights. */
(function (root) {
  'use strict';
  const axes = [
    { id: 'EI', title: 'מאיפה מגיעה האנרגיה', labels: ['מוחצן', 'מופנם'], explanations: ['מפגש עם אנשים ועיבוד בקול', 'מרחב אישי ועיבוד פנימי'] },
    { id: 'SN', title: 'איך קולטים את העולם', labels: ['קונקרטי', 'עיוני'], explanations: ['פרטים מוחשיים וניסיון ישיר', 'דפוסים, רעיונות ואפשרויות'] },
    { id: 'TF', title: 'מה מנחה החלטות', labels: ['שכלתני', 'רגשי'], explanations: ['עקביות, עקרונות ושיקולים ענייניים', 'ערכים אישיים וההשפעה על אנשים'] },
    { id: 'JP', title: 'איך ניגשים לחיי היום-יום', labels: ['גבולני', 'פתוח'], explanations: ['מסגרת, תכנון וסגירת קצוות', 'גמישות, התאמה והשארת אפשרויות'] }
  ];
  const hebrew = { E: 'ח', I: 'מ', S: 'ק', N: 'ע', T: 'ש', F: 'ר', J: 'ג', P: 'פ', X: '?' };
  function score(questions, answers) {
    if (!Array.isArray(answers) || answers.length !== questions.length || Array.from(answers).some(a => !Number.isInteger(a) || a < 1 || a > 5)) {
      throw new Error('יש להשיב על כל השאלות בתשובות בין 1 ל-5');
    }
    const results = axes.map(axis => {
      let sum = 0, count = 0, neutral = 0, first = 0, second = 0;
      questions.forEach((q, i) => {
        if (q.axis !== axis.id) return;
        const value = (3 - answers[i]) * (q.aPole === axis.id[0] ? 1 : -1);
        sum += value; count++;
        if (!value) neutral++; else if (value > 0) first++; else second++;
      });
      if (!count) throw new Error('Missing axis: ' + axis.id);
      const normalized = sum / (count * 2);
      const firstPercent = Math.round(50 + 50 * normalized);
      return { ...axis, sum, count, neutral, first, second, normalized, firstPercent,
        secondPercent: 100 - firstPercent, letter: sum === 0 ? 'X' : sum > 0 ? axis.id[0] : axis.id[1],
        close: Math.abs(normalized) <= 0.25,
        label: sum === 0 ? 'ללא העדפה מכריעה' : Math.abs(normalized) <= 0.25 ? 'נטייה קלה' : Math.abs(normalized) <= 0.6 ? 'נטייה בינונית' : 'נטייה בולטת' };
    });
    const code = results.map(a => a.letter).join('');
    const candidates = results.reduce((codes, a) => codes.flatMap(c => (a.close ? [...a.id] : [a.letter]).map(l => c + l)), ['']);
    candidates.sort((a, b) => distance(a) - distance(b) || a.localeCompare(b));
    function distance(type) { return results.reduce((total, axis, i) => total + (1 - (type[i] === axis.id[0] ? 1 : -1) * axis.normalized), 0); }
    return { code, hebrewCode: [...code].map(c => hebrew[c]).join(''), axes: results, candidates,
      neutralCount: answers.filter(a => a === 3).length,
      straightLine: new Set(answers).size === 1 };
  }
  const api = { axes, hebrew, score };
  if (typeof module !== 'undefined' && module.exports) module.exports = api;
  else root.MBTI = api;
})(typeof globalThis !== 'undefined' ? globalThis : this);
</script>
<script>(() => {
  'use strict';
  const $ = id => document.getElementById(id);
  const questions = MBTI_DATA.questions;
  const key = 'nhlocal.16-types.v1';
  const themeKey = 'nhlocal.16-types.theme';
  const systemTheme = matchMedia('(prefers-color-scheme: dark)');
  let explicitTheme = null;
  try { const saved = localStorage.getItem(themeKey); if (saved === 'light' || saved === 'dark') explicitTheme = saved; } catch {}
  function applyTheme(theme) {
    document.documentElement.dataset.theme = theme;
    const dark = theme === 'dark';
    $('theme-toggle').setAttribute('aria-pressed', String(dark));
    $('theme-toggle').title = dark ? 'מעבר למצב בהיר' : 'מעבר למצב אפל';
    $('theme-color').content = dark ? '#171d28' : '#fcf7f1';
  }
  applyTheme(explicitTheme || (systemTheme.matches ? 'dark' : 'light'));
  $('theme-toggle').addEventListener('click', () => {
    explicitTheme = document.documentElement.dataset.theme === 'dark' ? 'light' : 'dark';
    applyTheme(explicitTheme);
    try { localStorage.setItem(themeKey, explicitTheme); } catch {}
  });
  systemTheme.addEventListener('change', event => { if (!explicitTheme) applyTheme(event.matches ? 'dark' : 'light'); });
  const optionLabels = ["בבירור א'", "נוטה ל-א'", 'לא ברור', "נוטה ל-ב'", "בבירור ב'"];
  const fullLabels = ["בבירור א', העדפה ברורה לאפשרות א'", "נוטה ל-א', העדפה קלה לאפשרות א'", 'לא ברור, אין העדפה ברורה בין האפשרויות', "נוטה ל-ב', העדפה קלה לאפשרות ב'", "בבירור ב', העדפה ברורה לאפשרות ב'"];
  let answers = Array(questions.length).fill(null), current = 0, screen = 'welcome', returnToReview = false, result = null, storageWorks = true, resetStartsQuiz = false, toastTimer;
  const esc = value => String(value).replace(/[&<>"']/g, char => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[char]));
  const answered = () => answers.filter(a => a !== null).length;
  function storageFailure() {
    storageWorks = false;
    $('storage-status').hidden = false;
    $('storage-status').textContent = 'השמירה בדפדפן אינה זמינה כרגע. אפשר להמשיך, אבל רענון או סגירה של הדף עלולים למחוק את ההתקדמות';
    $('pause').textContent = 'יציאה מהשאלון';
  }
  function load() {
    try {
      const raw = localStorage.getItem(key);
      if (!raw) return;
      const saved = JSON.parse(raw);
      if (!saved || saved.version !== MBTI_DATA.revision || !Array.isArray(saved.answers) || saved.answers.length !== questions.length || !saved.answers.every(a => a === null || (Number.isInteger(a) && a >= 1 && a <= 5)) || !Number.isInteger(saved.current) || saved.current < 0 || saved.current >= questions.length) {
        localStorage.removeItem(key); return;
      }
      answers = saved.answers; current = saved.current;
    } catch (error) {
      if (error instanceof SyntaxError) { try { localStorage.removeItem(key); } catch { storageFailure(); } }
      else storageFailure();
    }
  }
  function save() {
    if (!storageWorks) return;
    try { localStorage.setItem(key, JSON.stringify({version: MBTI_DATA.revision, answers, current})); }
    catch { storageFailure(); }
  }
  function show(id, focusId) {
    screen = id;
    ['welcome','quiz','review','results'].forEach(name => { $(name).hidden = name !== id; });
    if (focusId) $(focusId).focus({preventScroll:true});
    window.scrollTo({top:0,behavior:'instant'});
  }
  function welcome() {
    const count = answered();
    $('start').hidden = count > 0;
    $('resume').hidden = count === 0;
    $('fresh').hidden = count === 0;
    $('resume').querySelector('span').textContent = count === questions.length ? 'חזרה לתוצאה שלי' : 'להמשיך מאיפה שעצרתי';
    show('welcome');
  }
  function updateProgress() {
    $('progress').max = questions.length;
    $('progress').value = answered();
    $('progress-text').textContent = `${answered()} מתוך ${questions.length} נענו`;
  }
  function renderQuestion() {
    const q = questions[current], chapter = Math.floor(current / 8);
    $('chapter-label').textContent = `פרק ${chapter + 1} מתוך ${MBTI_DATA.chapters.length} · ${MBTI_DATA.chapters[chapter]}`;
    $('question-counter').textContent = `שאלה ${current + 1} מתוך ${questions.length}`;
    $('question-heading').textContent = q.text;
    $('option-a').textContent = q.a; $('option-b').textContent = q.b;
    $('answer-options').innerHTML = optionLabels.map((label, i) => `<label class="answer-choice"><input type="radio" name="answer" value="${i+1}" aria-label="${esc(fullLabels[i])}" ${answers[current] === i+1 ? 'checked' : ''}><span><i aria-hidden="true"></i>${label}</span></label>`).join('');
    $('previous').disabled = current === 0;
    $('next').querySelector('span').textContent = returnToReview ? 'שמירה וחזרה למפה' : current === questions.length - 1 ? 'לתוצאות' : 'הבא';
    $('answer-error').hidden = true;
    updateProgress(); save();
    show('quiz', 'question-heading');
    $('announcement').textContent = `שאלה ${current+1} מתוך ${questions.length}. ${MBTI_DATA.chapters[chapter]}`;
  }
  function start() { current = 0; returnToReview = false; renderQuestion(); }
  function review() {
    $('review-count').textContent = `${answered()} מתוך ${questions.length} שאלות נענו`;
    $('review-list').innerHTML = MBTI_DATA.chapters.map((chapter, c) => `<section class="review-group"><h3>${c+1}. ${esc(chapter)}</h3>${questions.slice(c*8,c*8+8).map(q => {
      const a = answers[q.id-1];
      return `<button class="review-question" data-index="${q.id-1}"><b>${q.id}.</b> ${esc(q.text)}<small>${a === null ? 'עדיין לא נענתה' : esc(fullLabels[a-1]) + (a === 3 ? '' : ': ' + esc(a < 3 ? q.a : q.b))}</small></button>`;
    }).join('')}</section>`).join('');
    $('review-finish').querySelector('span').textContent = answered() === questions.length ? 'לתוצאות' : `להמשיך לשאלות שנותרו (${questions.length - answered()})`;
    show('review', 'review-heading');
  }
  function typeStyle(code) {
    const p = MBTI_PALETTES[code];
    return p ? `--type-light-accent:${p.accent};--type-light-soft:${p.soft};--type-dark-accent:${p.darkAccent};--type-dark-soft:${p.darkSoft}` : '';
  }
  function profileHTML(code, preview = false) {
    const p = MBTI_PROFILES[code];
    const words = [...code].map((letter,i) => MBTI.axes[i].labels[MBTI.axes[i].id.indexOf(letter)]).join(' · ');
    return `<div class="type-profile ${preview ? 'preview-card' : ''}" style="${typeStyle(code)}"><div class="profile-top"><div class="profile-identity"><div class="profile-codes"><bdi class="type-code">${code}</bdi><span class="he-code">${p.he}</span></div><h3 class="profile-name">${esc(p.name)}</h3><p>${words}</p></div><img class="profile-character" src="${MBTI_ILLUSTRATIONS[code]}" alt="" width="210" height="210"></div><p>${esc(p.description)}</p><h4>העדפות וחוזקות אפשריות</h4><ul>${p.strengths.map(s => `<li>${esc(s)}</li>`).join('')}</ul><h4>נקודה למחשבה</h4><p>${esc(p.stretch)}</p><h4>בקשרים עם אנשים</h4><p>${esc(p.relationships)}</p><h4>בלמידה ובעשייה</h4><p>${esc(p.work)}</p><div class="experiment"><h4>אפשר לנסות השבוע</h4><p>${esc(p.experiment)}</p></div></div>`;
  }
  function typeButton(code) {
    const p = MBTI_PROFILES[code];
    return `<button type="button" class="type-chip" style="${typeStyle(code)}" data-type="${code}" aria-pressed="false" aria-controls="type-preview"><img class="type-character" src="${MBTI_ILLUSTRATIONS[code]}" alt="" width="96" height="96" loading="lazy"><span class="type-chip-codes"><bdi dir="ltr">${code}</bdi><span>${p.he}</span></span><span class="type-chip-name">${esc(p.name)}</span></button>`;
  }
  function previewType(code) {
    document.querySelectorAll('[data-type]').forEach(button => button.setAttribute('aria-pressed', String(button.dataset.type === code)));
    $('type-preview').innerHTML = profileHTML(code, true);
  }
  function results() {
    if (answered() !== questions.length) { current = answers.indexOf(null); returnToReview = false; renderQuestion(); return; }
    result = MBTI.score(questions, answers);
    const tied = result.code.includes('X');
    $('results').style.cssText = typeStyle(result.code);
    $('result-heading').textContent = tied ? 'לא התקבלה העדפה בכל הצירים' : `הכיוון שלך: ${MBTI_PROFILES[result.code].name}`;
    $('result-subtitle').textContent = tied ? 'בחלק מהצירים אין כרגע העדפה מכריעה. אפשר לעיין בפירוט ולהשוות בין התיאורים' : 'הפרופיל שעולה מהתשובות שלך';
    $('profile-card').innerHTML = tied ? `<div class="profile-top"><bdi class="type-code">${result.code}</bdi></div><h3>אין טיפוס יחיד בתוצאה הזו</h3><p>האות X מסמנת ציר שבו התקבל שוויון. לא בחרנו עבורך צד שרירותי, ולכן אין כאן תיאור של טיפוס יחיד.</p><p>אפשר לעיין בצירופים המוצעים בהמשך, ולחשוב איזו העדפה חוזרת בחיים שלך כשיש חופש לבחור.</p><div class="experiment"><h4>אפשר לנסות השבוע</h4><p>לתעד שלושה רגעים של בחירה חופשית: מה בחרת, למה, והאם זו הייתה העדפה או דרישה של המצב.</p></div>` : profileHTML(result.code);
    $('axis-results').innerHTML = result.axes.map(a => {
      const winner = a.id.indexOf(a.letter);
      const percentages = [a.firstPercent, a.secondPercent];
      const emphasis = i => i === winner ? ' is-dominant' : '';
      const summary = winner < 0 ? 'אין העדפה לצד מסוים' : `${a.close ? 'נטייה קלה' : 'הנטייה שלך'}: ${a.labels[winner]}`;
      return `<section class="axis-row"><div class="axis-title"><b>${a.title}</b></div><div class="axis-labels">${a.labels.map((label,i) => `<div class="axis-pole${emphasis(i)}"><strong>${label}</strong><bdi dir="ltr">${a.id[i]} · ${percentages[i]}%</bdi></div>`).join('')}</div><div class="axis-bar" role="img" aria-label="${a.labels[0]} ${a.firstPercent} אחוז, ${a.labels[1]} ${a.secondPercent} אחוז">${percentages.map((value,i) => `<i class="${emphasis(i).trim()}" style="width:${value}%"></i>`).join('')}</div><p class="axis-explain"><strong>${summary}</strong>${winner < 0 ? '' : `<br>${a.explanations[winner]}`}</p></section>`;
    }).join('');
    const notices = [];
    if (result.neutralCount >= questions.length / 2) notices.push('בחלק גדול מהשאלות נבחר האמצע. ייתכן ששתי האפשרויות מתאימות לך או שההעדפות משתנות בין מצבים. כדאי לתת לתיאורים משקל מוגבל');
    if (result.straightLine && result.neutralCount === 0) notices.push('נבחרה אותה עמדה בכל השאלות. מכיוון שכיוון האפשרויות מתחלף, התוצאה מאוזנת. כדאי לעבור על התשובות ולבדוק שהבחירות מבטאות את ההעדפות שלך');
    const close = result.axes.filter(a => a.close);
    if (close.length && !tied) notices.push(`בצירים ${close.map(a=>a.labels.join(' / ')).join(', ')} הנטייה קרובה לאמצע. שינוי בכמה תשובות עשוי לשנות את האות המתאימה`);
    $('result-notice').hidden = notices.length === 0;
    $('result-notice').innerHTML = notices.map(n => `<p>${esc(n)}</p>`).join('');
    const nearby = result.candidates.filter(c => c !== result.code);
    $('nearby').hidden = nearby.length === 0;
    $('nearby-explanation').textContent = 'בצירים הקרובים לאמצע כדאי להשוות גם לתיאורים האלה';
    $('nearby-types').innerHTML = nearby.map(typeButton).join('');
    $('type-picker').innerHTML = Object.keys(MBTI_PROFILES).map(typeButton).join('');
    previewType(tied ? result.candidates[0] : result.code);
    save(); show('results', 'result-heading');
  }
  function resultText() {
    const lines = ['16 הטיפוסים | שאלון עצמאי להיכרות עצמית', '', `הצירוף: ${result.code} (${result.hebrewCode})`];
    if (MBTI_PROFILES[result.code]) {
      const p = MBTI_PROFILES[result.code];
      lines.push(p.name, '', p.description, '', 'חוזקות אפשריות:', ...p.strengths.map(s=>'• '+s), '', 'נקודה למחשבה:',p.stretch,'','בקשרים:',p.relationships,'','בלמידה ובעשייה:',p.work,'','ניסוי קטן:',p.experiment);
    } else lines.push('X מסמן שוויון בציר. לא נבחר טיפוס יחיד');
    lines.push('', 'ההעדפות שלך בארבעת התחומים:');
    result.axes.forEach(a => lines.push(`${a.labels[0]} ${a.firstPercent}% | ${a.labels[1]} ${a.secondPercent}% (${a.label})`));
    if (result.candidates.length > 1) lines.push('', 'צירופים להשוואה: ' + result.candidates.join(', '));
    if (!$('result-notice').hidden) lines.push('', $('result-notice').textContent);
    lines.push('', 'האחוזים הם ציוני נטייה מהתשובות, לא הסתברות או מדד ליכולת. שאלון זה אינו מבחן MBTI רשמי ולא עבר תיקוף פסיכומטרי. התוצאה אינה אבחון.', `גרסת שאלון: ${MBTI_DATA.revision}`);
    return lines.join('\n');
  }
  function toast(message) { $('toast').textContent = message; $('toast').hidden = false; clearTimeout(toastTimer); toastTimer = setTimeout(() => {$('toast').hidden = true;}, 5000); }
  function askReset(startAfter) {
    resetStartsQuiz = startAfter;
    $('reset-dialog').setAttribute('aria-labelledby','reset-title');
    $('confirm-reset').textContent = startAfter ? 'למחוק ולהתחיל מחדש' : 'למחוק את התשובות';
    $('reset-dialog').showModal();
  }
  $('start').addEventListener('click',start);
  $('resume').addEventListener('click',()=>{ returnToReview=false; answered()===questions.length ? results() : renderQuestion(); });
  $('pause').addEventListener('click',()=>{save();welcome();$('resume').focus();});
  $('answer-options').addEventListener('change',event=>{ if(event.target.name !== 'answer') return; answers[current]=Number(event.target.value);$('answer-error').hidden=true;save();updateProgress();});
  $('quiz-form').addEventListener('submit',event=>{
    event.preventDefault();
    if(answers[current]===null){$('answer-error').hidden=false;$('answer-options').querySelector('input').focus();return;}
    if(returnToReview){returnToReview=false;review();return;}
    if(current===questions.length-1){results();return;}
    current++;renderQuestion();
  });
  $('previous').addEventListener('click',()=>{if(current>0){current--;renderQuestion();}});
  $('review-link').addEventListener('click',review);
  $('review-list').addEventListener('click',event=>{const button=event.target.closest('[data-index]');if(!button)return;current=Number(button.dataset.index);returnToReview=true;renderQuestion();});
  $('review-back').addEventListener('click',()=>{returnToReview=false;renderQuestion();});
  $('review-finish').addEventListener('click',results);
  $('edit').addEventListener('click',review);
  $('type-picker').addEventListener('click', event => {
    const button = event.target.closest('[data-type]');
    if (!button) return;
    previewType(button.dataset.type);
    $('type-preview').focus({preventScroll:true});
    $('type-preview').scrollIntoView({block:'start',behavior:'instant'});
  });
  $('nearby-types').addEventListener('click',event=>{const button=event.target.closest('[data-type]');if(!button)return;document.querySelector('.explore').open=true;previewType(button.dataset.type);$('type-preview').focus({preventScroll:true});$('type-preview').scrollIntoView({block:'start',behavior:'instant'});});
  $('download').addEventListener('click',()=>{const blob=new Blob(['\ufeff'+resultText()],{type:'text/plain;charset=utf-8'});const url=URL.createObjectURL(blob);const link=document.createElement('a');link.href=url;link.download=`16-types-${result.code}.txt`;document.body.appendChild(link);link.click();link.remove();setTimeout(()=>URL.revokeObjectURL(url),1000);toast('הסיכום מוכן להורדה');});
  $('copy').addEventListener('click',async()=>{try{await navigator.clipboard.writeText(resultText());toast('הסיכום הועתק');}catch{toast('ההעתקה אינה זמינה בדפדפן הזה. אפשר לשמור את התוצאה כקובץ');}});
  $('print').addEventListener('click',()=>window.print());
  $('fresh').addEventListener('click',()=>askReset(true));
  $('restart').addEventListener('click',()=>askReset(true));
  $('erase').addEventListener('click',()=>askReset(false));
  $('cancel-reset').addEventListener('click',()=>$('reset-dialog').close());
  $('confirm-reset').addEventListener('click',()=>{
    let removed=true;
    try{localStorage.removeItem(key);}catch{removed=false;storageFailure();}
    answers=Array(questions.length).fill(null);current=0;result=null;returnToReview=false;
    $('reset-dialog').close();
    if(resetStartsQuiz)start();else{welcome();$('start').focus();}
    toast(removed?'התשובות הקודמות נמחקו':'התשובות אופסו בדף. מחיקת האחסון חסומה; אפשר לנקות את נתוני האתר בהגדרות הדפדפן');
  });
  $('about-toggle').addEventListener('click',()=>{const open=$('method').hidden;$('method').hidden=!open;$('about-toggle').setAttribute('aria-expanded',String(open));});
  load(); welcome();
})();
</script>
</body>
</html>
"; +window.NHLocalDownloads["the_16_types"] = "<!DOCTYPE html>
<html lang="he" dir="rtl">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <meta id="theme-color" name="theme-color" content="#fcf7f1">
  <script>
    (() => {
      let saved;
      try { saved = localStorage.getItem("nhlocal.16-types.theme"); } catch {}
      const dark = saved === "dark" || (saved !== "light" && matchMedia("(prefers-color-scheme: dark)").matches);
      document.documentElement.dataset.theme = dark ? "dark" : "light";
      document.getElementById("theme-color").content = dark ? "#171d28" : "#fcf7f1";
    })();
  </script>
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 64 64'%3E%3Crect width='64' height='64' rx='18' fill='%23e9eef5'/%3E%3Ctext x='32' y='45' font-family='Arial' font-size='36' font-weight='700' text-anchor='middle' fill='%23526b91'%3E16%3C/text%3E%3C/svg%3E">
  <style>/* Embedded Assistant font license:
Copyright 2020 The Assistant Project Authors (https://github.com/hafontia/Assistant).
Copyright 2010 The Source Sans Pro Authors (https://github.com/adobe-fonts/source-sans-pro), with Reserved Font Name 'Source'.
Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries.

This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at:
http://scripts.sil.org/OFL


-----------------------------------------------------------
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------

PREAMBLE
The goals of the Open Font License (OFL) are to stimulate worldwide
development of collaborative font projects, to support the font creation
efforts of academic and linguistic communities, and to provide a free and
open framework in which fonts may be shared and improved in partnership
with others.

The OFL allows the licensed fonts to be used, studied, modified and
redistributed freely as long as they are not sold by themselves. The
fonts, including any derivative works, can be bundled, embedded,
redistributed and/or sold with any software provided that any reserved
names are not used by derivative works. The fonts and derivatives,
however, cannot be released under any other type of license. The
requirement for fonts to remain under this license does not apply
to any document created using the fonts or their derivatives.

DEFINITIONS
"Font Software" refers to the set of files released by the Copyright
Holder(s) under this license and clearly marked as such. This may
include source files, build scripts and documentation.

"Reserved Font Name" refers to any names specified as such after the
copyright statement(s).

"Original Version" refers to the collection of Font Software components as
distributed by the Copyright Holder(s).

"Modified Version" refers to any derivative made by adding to, deleting,
or substituting -- in part or in whole -- any of the components of the
Original Version, by changing formats or by porting the Font Software to a
new environment.

"Author" refers to any designer, engineer, programmer, technical
writer or other person who contributed to the Font Software.

PERMISSION & CONDITIONS
Permission is hereby granted, free of charge, to any person obtaining
a copy of the Font Software, to use, study, copy, merge, embed, modify,
redistribute, and sell modified and unmodified copies of the Font
Software, subject to the following conditions:

1) Neither the Font Software nor any of its individual components,
in Original or Modified Versions, may be sold by itself.

2) Original or Modified Versions of the Font Software may be bundled,
redistributed and/or sold with any software, provided that each copy
contains the above copyright notice and this license. These can be
included either as stand-alone text files, human-readable headers or
in the appropriate machine-readable metadata fields within text or
binary files as long as those fields can be easily viewed by the user.

3) No Modified Version of the Font Software may use the Reserved Font
Name(s) unless explicit written permission is granted by the corresponding
Copyright Holder. This restriction only applies to the primary font name as
presented to the users.

4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
Software shall not be used to promote, endorse or advertise any
Modified Version, except to acknowledge the contribution(s) of the
Copyright Holder(s) and the Author(s) or with their explicit written
permission.

5) The Font Software, modified or unmodified, in part or in whole,
must be distributed entirely under this license, and must not be
distributed under any other license. The requirement for fonts to
remain under this license does not apply to any document created
using the Font Software.

TERMINATION
This license becomes null and void if any of the above conditions are
not met.

DISCLAIMER
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
OTHER DEALINGS IN THE FONT SOFTWARE.

*/
@font-face{font-family:Assistant;src:url(data:font/ttf;base64,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) format('truetype');font-weight:200 800;font-display:swap}
:root {
  color-scheme: light;
  --on-accent: #fff;
  --surface-warm: #f6f1ea;
  --surface-cool: #f0f3f7;
  --sheet-border: #ffffffad;
  --sheet-shadow: 10px 12px 0 #efe2d565, 0 18px 40px #687a9610;
  --sheet-row: #fffdf9;
  --sheet-row-alt: #f9f2eb;
  --notice-bg: #f6ecdc;
  --notice-line: #e7d4b4;
  --track: #dce1e8;
  --paper: #fcf7f1;
  --white: #fffdfa;
  --ink: #3b414e;
  --muted: #686772;
  --accent: #526b91;
  --accent-hover: #435b80;
  --clay: #9b634f;
  --blue-soft: #e9eef5;
  --peach-soft: #f5e6dc;
  --line: #e4dfd9;
  --green: #526b91;
  --error: #aa3b37;
  --ease: 180ms ease;
  --soft-shadow: 0 12px 35px #63564c08;
}
:root[data-theme="dark"] {
  color-scheme: dark;
  --paper: #171d28;
  --white: #222c3a;
  --ink: #edf1f7;
  --muted: #b6c1d1;
  --accent: #a5c1eb;
  --accent-hover: #bed2f0;
  --on-accent: #18263b;
  --clay: #e4b298;
  --blue-soft: #293b52;
  --peach-soft: #3a302e;
  --line: #415065;
  --surface-warm: #2b3039;
  --surface-cool: #263241;
  --sheet-border: #35465b;
  --sheet-shadow: 10px 12px 0 #111722, 0 18px 40px #0002;
  --sheet-row: #222e3e;
  --sheet-row-alt: #32333b;
  --notice-bg: #3a3229;
  --notice-line: #64553f;
  --track: #445066;
  --green: #a5c1eb;
  --error: #ffaba5;
  --soft-shadow: 0 10px 30px #0002;
}
* { box-sizing: border-box; }
body { margin: 0; background: var(--paper); color: var(--ink); font-family: Assistant, "Segoe UI", Arial, sans-serif; font-size: 18px; line-height: 1.7; }
button, input, select { font: inherit; }
button, a, summary, select { touch-action: manipulation; }
button { cursor: pointer; color: inherit; }
a { color: inherit; }
button:disabled { cursor: default; opacity: .4; }
[hidden] { display: none !important; }
::selection { background: #d6e1f0; color: var(--ink); }
:focus-visible { outline: 3px solid var(--accent); outline-offset: 5px; }
h1, h2, h3, p { margin-top: 0; }
h1, h2, h3 { line-height: 1.3; font-weight: 700; letter-spacing: 0; }
h2 { font-size: clamp(1.8rem, 3.4vw, 2.7rem); }
h3 { font-size: 1.3rem; }
p { margin-bottom: 1em; }
.shell { max-width: 1170px; padding-inline: 40px; margin-inline: auto; }
.site-header { min-height: 108px; display: flex; justify-content: space-between; align-items: center; gap: 20px; }
.brand { display: flex; align-items: center; gap: 11px; font-size: 1.28rem; font-weight: 550; text-decoration: none; }
.brand-mark { display: grid; place-items: center; flex: 0 0 auto; width: 52px; height: 52px; border-radius: 18px; background: var(--blue-soft); color: var(--accent); font-size: 1.5rem; font-weight: 750; line-height: 1; letter-spacing: 0; direction: ltr; }
.back-link { font-size: .9rem; text-decoration: none; color: var(--muted); padding: 8px 13px; border-radius: 20px; }
.header-actions { display: flex; align-items: center; gap: 16px; }
.theme-toggle { display: grid; place-items: center; width: 44px; height: 44px; flex-shrink: 0; padding: 0; border: 1px solid var(--line); border-radius: 50%; background: var(--white); color: var(--accent); }
.theme-toggle:hover { background: var(--blue-soft); }
.theme-toggle .icon { width: 21px; height: 21px; }
.theme-toggle .theme-sun, [data-theme="dark"] .theme-toggle .theme-moon { display: none; }
[data-theme="dark"] .theme-toggle .theme-sun { display: block; }
.back-link:hover { color: var(--accent); background: var(--blue-soft); }
.back-link { display: inline-flex; align-items: center; gap: 7px; }
.icon { display: block; width: 1.1em; height: 1.1em; flex: 0 0 auto; fill: none; stroke: currentColor; stroke-width: 1.8; stroke-linecap: round; stroke-linejoin: round; }
.screen { animation: arrive .28s ease both; }
.hero { display: grid; grid-template-columns: 1.2fr 1fr; gap: 78px; align-items: center; padding-block: 43px 58px; }
.hero h1 { font-size: clamp(3rem, 5.3vw, 4.7rem); font-weight: 800; line-height: 1.2; letter-spacing: -.015em; margin: 0 0 27px; }
.hero h1 em { font-style: normal; color: var(--clay); font-weight: 800; }
.lead { color: var(--muted); font-size: 1.06rem; line-height: 1.95; max-width: 550px; }
.hero .lead { margin-bottom: 28px; }
.button { display: inline-flex; align-items: center; justify-content: center; gap: 12px; min-height: 48px; max-width: 100%; padding: 11px 22px; border: 1px solid transparent; border-radius: 14px; font-size: 1.125rem; line-height: 1.3; font-weight: 700; text-align: center; text-decoration: none; transition: background var(--ease), transform var(--ease), box-shadow var(--ease); }
.hero-copy > .button { min-height: 52px; padding: 12px 24px; font-size: 1.25rem; gap: 18px; }
.primary { color: var(--on-accent); background: var(--accent); box-shadow: 0 3px 8px #526b9118; }
.primary:not(:disabled):hover { background: var(--accent-hover); transform: translateY(-1px); box-shadow: 0 4px 10px #526b9126; }
.primary:not(:disabled):active { transform: translateY(0); box-shadow: none; }
.secondary { color: var(--ink); background: var(--white); border-color: var(--line); }
.secondary:hover { background: var(--blue-soft); border-color: var(--line); }
.text-button { border: 0; background: transparent; color: var(--muted); padding: 10px 3px; border-radius: 8px; font-size: .85rem; text-decoration: underline; text-decoration-color: transparent; text-underline-offset: 5px; }
.text-button:hover { color: var(--accent); text-decoration-color: currentColor; }
.micro { font-size: .81rem; color: var(--muted); line-height: 1.8; margin-block: 15px 0; }
.type-sheet { position: relative; padding: 20px 27px 30px; background: var(--blue-soft); border: 7px solid var(--sheet-border); border-radius: 43% 43% 37px 37px; transform: rotate(-3deg); box-shadow: var(--sheet-shadow); }
.sheet-number { font-size: 9.2rem; font-weight: 650; line-height: 1.5; letter-spacing: -.11em; text-align: center; direction: ltr; padding-inline-end: .08em; color: var(--accent); }
.sheet-axes { display: grid; gap: 9px; }
.sheet-axes > div { display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 8px; align-items: center; padding: 10px 18px; background: var(--sheet-row); border-radius: 24px; font-size: .91rem; box-shadow: 0 2px 0 #c7d2df44; }
.sheet-axes > div:nth-child(even) { background: var(--sheet-row-alt); }
.sheet-axes > div > span:last-child { text-align: left; }
.sheet-axes bdi { text-align: center; font-size: .8rem; letter-spacing: .06em; color: var(--accent); }
.intro-details { margin: 17px auto 44px; display: grid; grid-template-columns: 1fr 1fr; gap: 16px; align-items: start; }
details { padding: 21px 22px; border: 1px solid var(--line); background: var(--white); border-radius: 23px; box-shadow: 0 4px 14px #60564e03; }
summary { cursor: pointer; font-weight: 600; list-style-position: outside; margin-inline-start: 16px; padding-inline-start: 7px; }
summary::marker { color: #7c8ba1; font-size: .8em; }
details > p, details > div { margin-top: 18px; color: var(--muted); font-size: .93rem; }
.eyebrow { display: inline-flex; align-items: center; gap: 9px; font-size: .83rem; font-weight: 450; color: var(--muted); }
.quiz-wrap { max-width: 850px; margin: 26px auto 55px; }
.quiz-top, .progress-heading { display: flex; justify-content: space-between; align-items: center; gap: 16px; }
.quiz-top { margin-bottom: 15px; }
.progress-heading { font-size: .84rem; margin-bottom: 10px; color: var(--muted); }
progress { display: block; border: 0; background: var(--track); width: 100%; height: 7px; border-radius: 10px; overflow: hidden; accent-color: var(--accent); }
progress::-webkit-progress-bar { background: var(--track); border-radius: 10px; }
progress::-webkit-progress-value { background: var(--accent); border-radius: 10px; transition: width .2s ease; }
progress::-moz-progress-bar { background: var(--accent); border-radius: 10px; }
.question-card { margin-top: 27px; padding: 36px 37px 32px; background: var(--white); border: 1px solid var(--line); border-radius: 32px; box-shadow: var(--soft-shadow); }
.question-card h2 { font-size: clamp(1.4rem, 2.6vw, 1.9rem); font-weight: 700; line-height: 1.55; margin: 0 0 25px; min-height: 3.1em; letter-spacing: 0; }
.situation-options { display: grid; grid-template-columns: 1fr 1fr; gap: 15px; margin-bottom: 25px; }
.situation { padding: 20px; background: var(--surface-warm); border-radius: 22px; }
.situation > span { display: grid; place-items: center; width: 34px; height: 34px; border-radius: 13px; background: var(--blue-soft); color: var(--accent); font-weight: 500; font-size: 1.05rem; margin-bottom: 12px; }
.situation p { margin: 0; font-size: 1.125rem; line-height: 1.7; }
fieldset { border: 0; padding: 0; margin: 0; min-width: 0; }
legend { font-size: 1rem; text-align: center; margin: 0 auto 16px; padding: 0; color: var(--muted); }
.answer-options { display: grid; grid-template-columns: repeat(5, minmax(0, 1fr)); gap: 9px; }
.answer-choice { position: relative; cursor: pointer; }
.answer-choice input { position: absolute; opacity: 0; width: 1px; height: 1px; }
.answer-choice > span { display: flex; align-items: center; justify-content: center; flex-direction: column; gap: 12px; padding: 15px 3px; min-height: 98px; font-size: 1rem; font-weight: 600; line-height: 1.35; text-align: center; border: 1px solid var(--line); border-radius: 18px; background: var(--white); transition: background var(--ease), border-color var(--ease), box-shadow var(--ease); }
.answer-choice i { display: block; width: 19px; height: 19px; border: 1.5px solid var(--muted); border-radius: 50%; position: relative; }
.answer-choice:nth-child(1) i, .answer-choice:nth-child(5) i { width: 24px; height: 24px; }
.answer-choice:nth-child(3) i { width: 14px; height: 14px; }
.answer-choice:hover > span { background: var(--surface-cool); border-color: var(--accent); }
.answer-choice input:checked + span { background: var(--accent); color: var(--on-accent); border-color: var(--accent); box-shadow: 0 2px 7px #526b9118; }
.answer-choice input:checked + span i { border-color: var(--on-accent); background: var(--on-accent); }
.answer-choice input:checked + span i:after { content: ""; position: absolute; inset: 4px; border-radius: 50%; background: var(--accent); }
.answer-choice input:focus-visible + span { outline: 3px solid var(--accent); outline-offset: 4px; }
.quiz-nav { display: flex; justify-content: space-between; gap: 16px; margin-top: 25px; }
.quiz-nav .button { min-width: 112px; }
.quiz-bottom { display: flex; justify-content: flex-end; margin-top: 18px; }
.error { color: var(--error); font-size: .9rem; margin: 18px 0 0; }
.reading-width { max-width: 850px; margin: 38px auto 60px; }
.reading-width h2 { margin-top: 12px; }
.review-group { margin-top: 28px; }
.review-question { display: block; width: 100%; text-align: start; border: 1px solid var(--line); background: var(--white); border-radius: 18px; padding: 17px 20px; margin-bottom: 10px; font-size: .97rem; }
.review-question:hover { background: var(--surface-cool); }
.review-question small { display: block; color: var(--muted); margin-top: 7px; font-size: .85rem; }
.action-row { display: flex; gap: 12px; align-items: center; flex-wrap: wrap; margin-top: 25px; }
.result-intro { margin: 35px 0 29px; }
.result-intro h2 { margin: 15px 0; }
.result-intro .lead { max-width: 750px; }
main.shell:has(#results:not([hidden])) { max-width: 1400px; }
.result-layout { display: grid; grid-template-columns: minmax(0, 1.75fr) minmax(320px, 1fr); gap: 27px; align-items: start; }
#results, .type-profile, .type-chip { --type-accent: var(--type-light-accent, var(--accent)); --type-soft: var(--type-light-soft, var(--blue-soft)); }
[data-theme="dark"] #results, [data-theme="dark"] .type-profile, [data-theme="dark"] .type-chip { --type-accent: var(--type-dark-accent, var(--accent)); --type-soft: var(--type-dark-soft, var(--blue-soft)); }
#results .profile-card { border-color: color-mix(in srgb, var(--type-accent) 30%, var(--line)); }
/* Keep the illustration backdrop distinct from its surrounding surface. */
.type-profile, .type-chip { --type-art-surface: color-mix(in srgb, var(--type-soft) 40%, var(--white)); }
.type-profile .profile-top { background: var(--type-art-surface); }
.type-profile .type-code, .profile-card .type-profile h4, .preview-card.type-profile h4 { color: var(--type-accent); }
.type-profile .experiment { background: var(--type-soft); }
#results .axis-pole.is-dominant { border-color: var(--type-accent); color: var(--type-accent); }
#results .axis-bar i.is-dominant { background: var(--type-accent); }
.profile-card { background: var(--white); padding: 30px; border: 1px solid var(--line); border-radius: 30px; box-shadow: var(--soft-shadow); }
.profile-top { display: flex; align-items: center; justify-content: space-between; gap: 14px; padding: 16px 21px; margin-bottom: 24px; border-radius: 22px; background: var(--blue-soft); }
.profile-codes { display: flex; flex-wrap: wrap; align-items: baseline; gap: 8px 12px; }
.profile-codes .he-code { margin: 0; }
.profile-identity { min-width: 0; }
.profile-identity .profile-name { margin: 12px 0 8px; }
.profile-identity p { margin: 0; font-size: .98rem; color: var(--muted); }
.profile-character { display: block; width: clamp(120px, 16vw, 210px); height: auto; flex: 0 0 auto; }
.type-character { display: block; width: 96px; height: 96px; align-self: center; }
.type-code { font-size: 2.8rem; letter-spacing: .02em; font-weight: 600; line-height: 1.15; color: var(--accent); }
.he-code { font-size: 1.2rem; margin-inline-start: 12px; color: var(--muted); }
.profile-name { font-size: 1.7rem; margin-bottom: 15px; }
.profile-card p { font-size: 1.0625rem; line-height: 1.8; }
.profile-card h4 { font-size: 1.02rem; margin: 25px 0 9px; color: var(--clay); font-weight: 500; }
.profile-card ul { padding-inline-start: 20px; font-size: 1.05rem; }
.profile-card li { margin-bottom: 7px; }
.experiment { padding: 18px 20px; border-radius: 20px; background: var(--peach-soft); margin-top: 25px; }
.experiment h4 { margin-top: 0; }
.experiment p { margin-bottom: 0; }
.axis-panel { container: preferences / inline-size; padding: 28px 25px; background: var(--surface-cool); border: 1px solid var(--line); border-radius: 30px; }
.axis-row { margin: 26px 0; padding-bottom: 24px; border-bottom: 1px solid var(--line); }
.axis-row:last-child { margin-bottom: 0; padding-bottom: 0; border-bottom: 0; }
.axis-title { font-size: 1rem; margin-bottom: 12px; }
.axis-title b { font-weight: 650; }
.axis-labels { display: grid; grid-template-columns: 1fr 1fr; gap: 8px; }
.axis-pole { display: flex; flex-direction: row; align-items: center; justify-content: space-between; gap: 8px; white-space: nowrap; padding: 10px 12px; border: 2px solid transparent; border-radius: 14px; color: var(--muted); }
.axis-pole strong { font-weight: 500; }
.axis-pole.is-dominant { border-color: var(--accent); background: var(--white); color: var(--accent); }
.axis-pole.is-dominant strong { font-weight: 800; }
.axis-pole bdi { font-size: .95rem; font-weight: 650; }
.axis-bar { display: flex; height: 10px; border-radius: 20px; background: var(--track); margin: 12px 0; overflow: hidden; direction: rtl; }
.axis-bar i { display: block; height: 100%; background: var(--track); }
.axis-bar i.is-dominant { background: var(--accent); }
.axis-bar i + i { border-inline-start: 2px solid var(--white); }
.axis-explain { font-size: .96rem; color: var(--muted); line-height: 1.7; margin: 0; }
.axis-explain strong { color: var(--ink); }
.axis-note { font-size: .93rem; color: var(--muted); line-height: 1.7; }
.notice { border: 1px solid var(--notice-line); background: var(--notice-bg); border-radius: 20px; padding: 18px 23px; font-size: .96rem; margin: 25px 0; }
.notice p:last-child { margin-bottom: 0; }
.nearby { margin-top: 27px; padding: 24px; background: var(--surface-warm); border-radius: 25px; }
.nearby p { font-size: .95rem; color: var(--muted); }
.type-chips, .type-picker { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 12px; }
.type-chip { display: flex; flex-direction: column; align-items: stretch; gap: 8px; min-width: 0; border: 1px solid var(--line); border-radius: 18px; background: var(--white); color: var(--ink); padding: 16px; text-align: start; cursor: pointer; transition: background var(--ease), border-color var(--ease); }
.type-chip { border-block-start: 3px solid var(--type-accent); }
.type-chip:hover { background: var(--type-art-surface); border-color: var(--type-accent); }
.type-chip[aria-pressed="true"] { background: var(--type-art-surface); border-color: var(--type-accent); box-shadow: inset 0 0 0 1px var(--type-accent); }
.type-chip-codes { display: flex; align-items: baseline; justify-content: space-between; gap: 8px; }
.type-chip-codes bdi { font-size: 1.3rem; font-weight: 750; color: var(--type-accent); letter-spacing: .04em; }
.type-chip-codes > span { color: var(--muted); font-size: .95rem; }
.type-chip-name { font-size: 1.05rem; font-weight: 650; line-height: 1.4; }
.result-disclaimer { max-width: 930px; }
.explore { margin: 27px 0 40px; }
.explore summary { font-size: 1.2rem; font-weight: 650; }
#type-preview { scroll-margin-top: 24px; }
.preview-card { background: var(--white); padding: 15px; max-width: 820px; color: var(--ink); }
.preview-card p { font-size: .97rem; }
.preview-card h4 { margin-bottom: 8px; }
.preview-card ul { padding-inline-start: 22px; }
.site-footer { display: flex; flex-wrap: wrap; align-items: center; gap: 12px; padding-block: 10px 30px; font-size: .83rem; color: var(--muted); }
.site-footer > div { display: flex; gap: 24px; }
.site-footer .text-button { font-size: .82rem; }
.site-footer section { flex-basis: 100%; max-width: 850px; font-size: .97rem; margin-top: 20px; }
.site-footer section h2 { font-size: 1.6rem; }
.site-footer li { margin-block: 8px; }
.storage-status { background: var(--notice-bg); padding: 14px 19px; border-radius: 16px; font-size: .91rem; }
.toast { position: fixed; bottom: 24px; inset-inline: 20px; max-width: 500px; margin: auto; background: var(--accent-hover); color: var(--on-accent); padding: 14px 22px; border-radius: 20px; z-index: 10; text-align: center; box-shadow: 0 6px 22px #526b9130; font-size: .93rem; }
dialog { border: 1px solid var(--line); border-radius: 28px; padding: 30px; background: var(--paper); color: var(--ink); max-width: 540px; width: calc(100% - 32px); box-shadow: 0 25px 80px #3b414e30; }
dialog h2 { font-size: 1.8rem; }
dialog::backdrop { background: #41495c80; backdrop-filter: blur(4px); }
.sr-only { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0,0,0,0); white-space: nowrap; }
.skip-link { position: fixed; top: -100px; right: 20px; padding: 12px; background: var(--white); z-index: 99; }
.skip-link:focus { top: 15px; }
@keyframes arrive { from { opacity: 0; transform: translateY(5px); } to { opacity: 1; transform: translateY(0); } }
@media (min-width: 1450px) { .hero { padding-block: 62px 65px; } }
@media (max-width: 900px) {
  .shell { padding-inline: 28px; }
  .hero { gap: 35px; padding-block: 35px 40px; }
  .hero h1 { font-size: 3.8rem; }
  .type-sheet { padding: 17px 18px 24px; border-width: 5px; }
  .sheet-number { font-size: 8rem; }
  .sheet-axes > div { font-size: .8rem; padding: 9px 12px; gap: 4px; }
  .sheet-axes bdi { font-size: .75rem; }
  .result-layout { grid-template-columns: 1fr; gap: 20px; }
  .type-chips, .type-picker { grid-template-columns: repeat(2, minmax(0, 1fr)); }
  .profile-card { padding: 25px; }
  .axis-panel { padding: 24px 20px; }
  .axis-title { flex-wrap: wrap; gap: 3px 10px; }
}
@media (max-width: 620px) {
  .header-actions { gap: 9px; }
  .brand { flex-shrink: 0; }
  .shell { padding-inline: 20px; }
  .site-header { min-height: 88px; }
  .brand { font-size: 1.08rem; gap: 9px; }
  .brand-mark { width: 44px; height: 44px; font-size: 1.3rem; border-radius: 17px; }
  .back-link { font-size: .78rem; padding-inline: 4px; }
  .hero { grid-template-columns: 1fr; padding-block: 24px 34px; gap: 35px; }
  .hero h1 { font-size: clamp(2.9rem, 12vw, 3.8rem); margin-bottom: 19px; line-height: 1.23; }
  .lead { font-size: 1rem; line-height: 1.95; }
  .hero .lead { margin-bottom: 23px; }
  .hero-copy > .button { width: auto; }
  .type-sheet { transform: rotate(-2deg); padding: 19px 18px 20px; border-radius: 50px 50px 30px 30px; display: grid; grid-template-columns: .8fr 1.7fr; gap: 12px; margin-inline: 5px; border-width: 4px; box-shadow: var(--sheet-shadow); }
  .sheet-number { font-size: 4.8rem; line-height: 1; align-self: center; }
  .sheet-axes { gap: 7px; }
  .sheet-axes > div { font-size: .75rem; padding: 7px 10px; gap: 3px; border-radius: 15px; }
  .sheet-axes bdi { font-size: .62rem; letter-spacing: 0; }
  .intro-details { grid-template-columns: 1fr; gap: 11px; margin-block: 12px 22px; }
  details { padding: 19px 17px; border-radius: 21px; }
  summary { font-size: .92rem; padding-inline-start: 3px; }
  .quiz-wrap { margin-top: 16px; }
  .quiz-top { gap: 9px; margin-bottom: 10px; }
  .quiz-top .eyebrow, .quiz-top .text-button { font-size: .75rem; }
  .progress-heading { font-size: .77rem; }
  .question-card { padding: 25px 15px; border-radius: 25px; margin-top: 23px; }
  .question-card h2 { font-size: 1.3rem; min-height: 0; line-height: 1.6; margin-bottom: 22px; }
  .situation-options { gap: 10px; margin-bottom: 23px; }
  .situation { padding: 14px 12px 16px; border-radius: 17px; }
  .situation p { font-size: 1rem; line-height: 1.9; }
  .situation > span { width: 29px; height: 29px; border-radius: 10px; font-size: .95rem; margin-bottom: 11px; }
  .situation-options { grid-template-columns: 1fr; }
  .situation { display: grid; grid-template-columns: 29px 1fr; gap: 12px; align-items: start; }
  .situation > span { margin: 0; }
  legend { font-size: .9375rem; }
  .answer-options { grid-template-columns: 1fr; gap: 8px; }
  .answer-choice > span { flex-direction: row; justify-content: flex-start; font-size: 1.0625rem; min-height: 49px; padding: 11px 16px; border-radius: 13px; gap: 13px; text-align: start; }
  .answer-choice i { width: 17px; height: 17px; }
  .answer-choice:nth-child(1) i, .answer-choice:nth-child(5) i { width: 21px; height: 21px; }
  .quiz-nav .button { padding-inline: 18px; min-height: 48px; font-size: 1.125rem; }
  .quiz-nav { gap: 12px; }
  .quiz-bottom .text-button { font-size: .8rem; }
  .reading-width { margin-block: 28px; }
  .result-intro { margin-top: 25px; }
  .type-chip { padding: 12px; }
  .type-chip-codes { flex-wrap: wrap; gap: 4px 8px; }
  .result-layout { grid-template-columns: 1fr; gap: 22px; }
  .profile-card { padding: 24px 20px; border-radius: 25px; }
  .profile-top { padding: 17px; border-radius: 18px; }
  .axis-panel { padding: 25px 20px; border-radius: 25px; }
  .result-actions { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
  .result-actions .primary { grid-column: 1 / -1; justify-self: start; }
  .result-actions .button { font-size: 1.0625rem; padding-inline: 16px; }
  .result-actions .text-button { font-size: .81rem; }
  .site-footer { display: block; padding-bottom: 20px; }
  .site-footer > div { margin-top: 8px; justify-content: space-between; gap: 8px; flex-wrap: wrap; }
  .site-footer .text-button { font-size: .72rem; }
  .notice { font-size: .9rem; padding: 17px; }
  .profile-character { width: 108px; }
  .profile-top { gap: 8px; padding: 12px; }
  .profile-identity .profile-name { font-size: 1.35rem; }
  .profile-identity p { font-size: .85rem; }
  .type-code { font-size: 2.2rem; }
  .profile-name { font-size: 1.6rem; }
  .axis-title { font-size: .9rem; }
  .axis-title span { font-size: .76rem; }
  .axis-labels { font-size: .86rem; }
}
@container preferences (max-width: 350px) {
  .axis-labels { grid-template-columns: 1fr; gap: 6px; }
  .axis-pole { padding: 9px 12px; }
}
@media (max-width: 360px) {
  .shell { padding-inline: 15px; }
  .hero h1 { font-size: 2.9rem; }
  .type-sheet { padding-inline: 12px; gap: 8px; }
  .sheet-number { font-size: 4rem; }
  .sheet-axes > div { font-size: .68rem; padding-inline: 8px; }
  .question-card { padding-inline: 12px; }
  .answer-options { gap: 4px; }
  .answer-choice > span { font-size: 1.0625rem; }
  .quiz-top .eyebrow, .quiz-top .text-button { font-size: .7rem; }
}
@media (prefers-reduced-motion: reduce) { *, *:before, *:after { animation: none !important; transition: none !important; scroll-behavior: auto !important; } }
@media print {
  :root, :root[data-theme="dark"] { color-scheme: light; --paper: #fff; --white: #fff; --ink: #303640; --muted: #525b68; --accent: #526b91; --on-accent: #fff; --clay: #815340; --blue-soft: #eef2f7; --peach-soft: #f7eee7; --line: #ccc; --surface-warm: #faf7f2; --surface-cool: #f4f6f8; --notice-bg: #faf5ed; --notice-line: #ddd; --track: #dce1e8; }
  body { background: white; color: #303640; font-size: 11pt; }
  #results, .type-profile { --type-accent: var(--type-light-accent, #526b91) !important; --type-soft: var(--type-light-soft, #eef2f7) !important; }
  .site-header, .site-footer, .result-actions, .explore, .toast, .storage-status, .skip-link, .screen:not(#results) { display: none !important; }
  .shell { max-width: none; padding: 0; }
  .result-layout { display: block; }
  .profile-card { background: white !important; color: #303640; border: 1px solid #aaa; box-shadow: none; }
  .profile-card p, .profile-card h4 { color: #303640; }
  .axis-panel { margin-top: 20px; break-inside: avoid; }
  .axis-bar { print-color-adjust: exact; -webkit-print-color-adjust: exact; }
  .nearby { break-inside: avoid; }
  .type-chips button { color: #303640; background: white; }
  .result-intro { margin-top: 0; }
  #results[hidden] { display: none !important; }
  dialog { display: none; }
}

/* Clear question choices in dark mode and a separate restart action. */
#fresh { display: block; width: fit-content; margin-top: 8px; }
@media screen {
  :root[data-theme="dark"] .question-card legend { color: var(--ink); font-size: 1.125rem; font-weight: 650; line-height: 1.5; }
  :root[data-theme="dark"] .situation { background: #303f53; border: 1px solid #52667e; }
  :root[data-theme="dark"] .situation p { color: #f5f7fb; font-size: 1.125rem; font-weight: 550; line-height: 1.7; }
  :root[data-theme="dark"] .situation > span { background: #3c5270; color: #f3f7ff; font-weight: 700; }
}

#reset-dialog .action-row { justify-content: flex-end; }
</style>
<!-- catalog metadata:start -->
<title>מבחן 16 הטיפוסים | ארגז הכלים של NH Local</title>
    <meta name="description" content="שאלון עצמאי בעברית בהשראת MBTI, עם 56 שאלות, שמירת התקדמות ותוצאה מפורטת. פועל גם ללא חיבור לרשת.">
    <link rel="canonical" href="https://tools.ze-kal.top/tools/the_16_types.html">
    <meta property="og:type" content="website">
    <meta property="og:locale" content="he_IL">
    <meta property="og:site_name" content="ארגז הכלים של NH Local">
    <meta property="og:title" content="מבחן 16 הטיפוסים | ארגז הכלים של NH Local">
    <meta property="og:description" content="שאלון עצמאי בעברית בהשראת MBTI, עם 56 שאלות, שמירת התקדמות ותוצאה מפורטת. פועל גם ללא חיבור לרשת.">
    <meta property="og:url" content="https://tools.ze-kal.top/tools/the_16_types.html">
    <meta property="og:image" content="https://tools.ze-kal.top/assets/social-card.png">
    <meta property="og:image:width" content="1200"><meta property="og:image:height" content="630">
    <meta property="og:image:alt" content="ארגז הכלים של NH Local: סקילים, כלי דפדפן, סקריפטים ותוספי כרום">
    <meta name="twitter:card" content="summary_large_image">
    <script type="application/ld+json">{"@context": "https://schema.org", "@graph": [{"@type": "WebSite", "@id": "https://tools.ze-kal.top/#website", "url": "https://tools.ze-kal.top/", "name": "ארגז הכלים של NH Local", "inLanguage": "he"}, {"@type": "WebPage", "@id": "https://tools.ze-kal.top/tools/the_16_types.html", "url": "https://tools.ze-kal.top/tools/the_16_types.html", "name": "מבחן 16 הטיפוסים | ארגז הכלים של NH Local", "description": "שאלון עצמאי בעברית בהשראת MBTI, עם 56 שאלות, שמירת התקדמות ותוצאה מפורטת. פועל גם ללא חיבור לרשת.", "inLanguage": "he", "isPartOf": {"@id": "https://tools.ze-kal.top/#website"}}]}</script>
<!-- catalog metadata:end -->
</head>
<body>
<a class="skip-link" href="#main">דילוג לתוכן</a>
<header class="site-header shell">
  <a class="brand" href="the_16_types.html" aria-label="16 הטיפוסים, דף הפתיחה"><span class="brand-mark" aria-hidden="true">16</span><span>הטיפוסים</span></a>
  <div class="header-actions">
    <a class="back-link" href="../index.html">לארגז הכלים <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M7 17 17 7M7 7h10v10"/></svg></a>
    <button id="theme-toggle" class="theme-toggle" type="button" aria-label="מצב אפל" aria-pressed="false" title="מעבר למצב אפל">
      <svg class="icon theme-moon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M20.5 13A8.5 8.5 0 0 1 11 3.5 8.5 8.5 0 1 0 20.5 13Z"/></svg>
      <svg class="icon theme-sun" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><circle cx="12" cy="12" r="4"/><path d="M12 2v2m0 16v2M2 12h2m16 0h2M5 5l1.5 1.5m11 11L19 19M5 19l1.5-1.5m11-11L19 5"/></svg>
    </button>
  </div>
</header>
<main id="main" class="shell" tabindex="-1">
  <section id="welcome" class="screen">
    <div class="hero">
      <div class="hero-copy">
        <h1>מה בדרך כלל<br><em>טבעי לך?</em></h1>
        <p class="lead">לחשוב בקול או לעבד בשקט? לתכנן מראש או להחליט בדרך?<br>56 שאלות על ההעדפות שלך ביומיום, ובסופן פרופיל לפי מודל 16 הטיפוסים.</p>
        <button id="start" class="button primary">להתחלת השאלון <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M19 12H5m7-7-7 7 7 7"/></svg></button>
        <button id="resume" class="button primary" hidden><span>להמשיך מאיפה שעצרתי</span> <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M19 12H5m7-7-7 7 7 7"/></svg></button>
        <button id="fresh" class="text-button" hidden>להתחיל מחדש ולמחוק את ההתקדמות</button>
      </div>
      <aside class="type-sheet" aria-label="ארבעת צירי השאלון">
        <div class="sheet-number" aria-hidden="true">16</div>
        <div class="sheet-axes"><div><span>מוחצן</span><bdi>E / I</bdi><span>מופנם</span></div><div><span>קונקרטי</span><bdi>S / N</bdi><span>עיוני</span></div><div><span>שכלתני</span><bdi>T / F</bdi><span>רגשי</span></div><div><span>גבולני</span><bdi>J / P</bdi><span>פתוח</span></div></div>
      </aside>
    </div>
    <div class="intro-details">
      <details><summary>רגע לפני: איך כדאי לענות?</summary><p>כדאי לחשוב על ההעדפות הרגילות שלך בחודשים האחרונים, כשיש לך חופש לבחור, ולא רק על יום עמוס במיוחד או על תפקיד בעבודה. בכל מצב יש שתי אפשרויות טובות. בוחרים למה נוטים יותר, ובאיזו מידה. כששתיהן מתאימות באותה מידה, אפשר לבחור באמצע.</p><p>אפשר לחזור ולשנות כל תשובה. ההתקדמות נשמרת במכשיר הזה, כל עוד הדפדפן מאפשר זאת. אין צורך לענות מהר.</p></details>
      <details><summary>מה זה MBTI, ומה המבחן הזה מציע?</summary><p>מודל 16 הטיפוסים מחבר ארבעה זוגות של העדפות: מוחצן או מופנם, קונקרטי או עיוני, שכלתני או רגשי, גבולני או פתוח. הצירוף של ארבע הבחירות יוצר אחד מ-16 טיפוסים אפשריים.</p><p>המינוחים בעברית וכינויי הטיפוסים כאן תואמים לטבלה שסופקה לפרויקט. <b>גבולני</b> הוא הכינוי כאן להעדפה למסגרת ולסגירת קצוות (J), ללא משמעות קלינית. <b>רגשי</b> מתאר מתן משקל לערכים ולאנשים, ולא חוסר היגיון. <b>עיוני</b> מתייחס לדפוסים ולאפשרויות, ולא לרמת השכלה.</p><p>זהו שאלון עצמאי בהשראת ארבעת צירי MBTI, ולא מבחן MBTI רשמי או שאלון של 16Personalities. הוא נועד להיכרות עצמית, אינו אבחון ולא עבר תיקוף פסיכומטרי. טיפוס אינו מדד ליכולת או לערך אישי.</p></details>
    </div>
  </section>
  <section id="quiz" class="screen quiz-wrap" hidden aria-labelledby="question-heading">
    <div class="quiz-top"><span id="chapter-label" class="eyebrow"></span><button id="pause" class="text-button">שמירה ויציאה</button></div>
    <div class="progress-heading"><span id="question-counter"></span><span id="progress-text"></span></div>
    <progress id="progress" max="56" value="0" aria-label="שאלות שנענו"></progress>
    <form id="quiz-form" novalidate>
      <div class="question-card">
        <h2 id="question-heading" tabindex="-1"></h2>
        <div class="situation-options"><div class="situation option-a"><span aria-hidden="true">א'</span><p id="option-a"></p></div><div class="situation option-b"><span aria-hidden="true">ב'</span><p id="option-b"></p></div></div>
        <fieldset><legend>מה מרגיש לך יותר טבעי?</legend><div id="answer-options" class="answer-options"></div></fieldset>
        <p id="answer-error" class="error" role="alert" hidden>צריך לבחור תשובה כדי להמשיך. אפשר לבחור גם באמצע</p>
      </div>
      <div class="quiz-nav"><button id="previous" type="button" class="button secondary"><svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M5 12h14m-7-7 7 7-7 7"/></svg> <span>הקודם</span></button><button id="next" type="submit" class="button primary"><span>הבא</span> <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M19 12H5m7-7-7 7 7 7"/></svg></button></div>
    </form>
    <div class="quiz-bottom"><button id="review-link" class="text-button">כל התשובות שלי</button></div>
  </section>
  <section id="review" class="screen reading-width" hidden aria-labelledby="review-heading">
    <span class="eyebrow">בדיקה ועריכה</span><h2 id="review-heading" tabindex="-1">התשובות שלך</h2><p>לחיצה על שאלה מאפשרת לעדכן את התשובה. אין צורך לענות מחדש על הכול.</p><p id="review-count"></p><div id="review-list"></div><div class="action-row"><button id="review-finish" class="button primary"><span>לתוצאות</span> <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M19 12H5m7-7-7 7 7 7"/></svg></button><button id="review-back" class="button secondary">חזרה לשאלון</button></div>
  </section>
  <section id="results" class="screen" hidden aria-labelledby="result-heading">
    <div class="result-intro"><h2 id="result-heading" tabindex="-1"></h2><p id="result-subtitle" class="lead"></p></div>
    <div id="result-notice" class="notice" hidden></div>
    <div class="result-layout"><div id="profile-card" class="profile-card"></div><div class="axis-panel"><h3>ההעדפות שלך בארבעת התחומים</h3><div id="axis-results"></div><p class="axis-note">האחוזים מתארים נטייה בתשובות, ולא סבירות לטיפוס</p></div></div>
    <div id="nearby" class="nearby" hidden><h3>טיפוסים נוספים להשוואה</h3><p id="nearby-explanation"></p><div id="nearby-types" class="type-chips"></div></div>
    <div class="result-actions action-row"><button id="download" class="button primary"><span>לשמור את התוצאה</span> <svg class="icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M12 3v12m-5-5 5 5 5-5M5 16v5h14v-5"/></svg></button><button id="copy" class="button secondary">העתקת סיכום</button><button id="print" class="button secondary">הדפסה</button><button id="edit" class="text-button">לעבור על התשובות</button><button id="restart" class="text-button">להתחיל מחדש</button></div>
    <p class="micro result-disclaimer">שאלון עצמאי להיכרות עצמית, ללא תיקוף פסיכומטרי. התוצאה אינה אבחון</p>
    <details class="explore"><summary>כל 16 הטיפוסים</summary><p>אפשר לעיין בכל התיאורים. הבחירה כאן אינה משנה את התוצאה שלך.</p><div id="type-picker" class="type-picker" role="group" aria-label="בחירת טיפוס לעיון"></div><div id="type-preview" tabindex="-1"></div></details>
  </section>
  <p id="storage-status" class="storage-status" role="status" hidden></p>
  <noscript><div class="notice">כדי למלא את השאלון נדרש להפעיל JavaScript בדפדפן. אין צורך בחיבור לרשת</div></noscript>
</main>
<footer class="shell site-footer"><div><button id="about-toggle" class="text-button" aria-expanded="false" aria-controls="method">מקורות ושיטת החישוב</button><button id="erase" class="text-button">מחיקת התשובות מהמכשיר</button></div>
<section id="method" hidden><h2>על מה מבוסס השאלון?</h2><p>56 השאלות נכתבו במיוחד לשאלון זה. בכל ציר 14 שאלות במשקל שווה, במחציתן כל צד מופיע ראשון. השאלות עוסקות באנרגיה ועיבוד, קליטת מידע, שיקולי החלטה וגישה למסגרת. הן אינן העתק של שאלון מסחרי.</p><p>כל תשובה מקבלת ערך בין 2- ל-2 בהתאם לכיוון ולמידת ההעדפה. סכום של 14 התשובות בציר מומר לסולם 0 עד 100, עם אמצע ב-50. בשוויון מוצג X ולא נבחר צד שרירותי. כשציון הצד המוביל אינו עולה על 62.5, מוצעים גם צירופים קרובים להשוואה. זהו סף תצוגה שנבחר לשאלון, לא גבול מחקרי או רווח סמך.</p><p>המודל של 16Personalities מוסיף ממד חמישי משלו; הוא אינו נמדד כאן. תיאורי הטיפוסים הם הצעות להתבוננות שנכתבו לשאלון, ולא ניבוי של הצלחה בעבודה או בקשרים. סימולציות עם סוכני שפה שימשו לאיתור בעיות ניסוח וניקוד, ואינן תיקוף על בני אדם.</p><ul><li><a href="https://www.myersbriggs.org/my-mbti-personality-type/the-mbti-preferences/" target="_blank" rel="noopener noreferrer">Myers &amp; Briggs Foundation: ארבעת זוגות ההעדפות</a></li><li><a href="https://www.myersbriggs.org/my-mbti-personality-type/my-mbti-results/" target="_blank" rel="noopener noreferrer">Myers &amp; Briggs Foundation: פרשנות התוצאה והתאמה אישית</a></li><li><a href="https://www.16personalities.com/articles/our-theory" target="_blank" rel="noopener noreferrer">16Personalities: ההבדל בין המודל שלהם ל-MBTI</a></li><li><a href="https://pubmed.ncbi.nlm.nih.gov/2709300/" target="_blank" rel="noopener noreferrer">McCrae &amp; Costa (1989): בחינה ביקורתית של החלוקה לטיפוסים</a></li><li><a href="https://pubmed.ncbi.nlm.nih.gov/16367525/" target="_blank" rel="noopener noreferrer">Tzeng ואחרים (1984): תוקף פריטים וסוגיות בבניית שאלות</a></li></ul></section></footer>
<div id="announcement" class="sr-only" aria-live="polite"></div><div id="toast" class="toast" role="status" hidden></div>
<dialog id="reset-dialog"><h2 id="reset-title">למחוק את התשובות?</h2><p>התשובות והתוצאה השמורות בדפדפן הזה יימחקו. אפשר לבטל ולהמשיך מהמצב הקיים.</p><div class="action-row"><button id="cancel-reset" class="button secondary" autofocus>ביטול</button><button id="confirm-reset" class="button primary">למחוק ולהתחיל מחדש</button></div></dialog>
<script>const MBTI_DATA = {"version":"1.1.0","chapters":["ברגעים הקטנים","אנשים סביבנו","משהו חדש מתחיל","בין רעיון למעשה","כשצריך לבחור","יוצאים מהשגרה","התמונה השלמה"],"questions":[{"id":1,"axis":"EI","aPole":"I","facet":"recharge","text":"התפנה לך ערב אחרי יום עמוס. מה בדרך כלל ממלא אותך מחדש?","a":"זמן שקט לעצמי, בלי צורך לדבר","b":"מפגש או שיחה עם אנשים שנעים לי איתם","sourceId":1},{"id":2,"axis":"SN","aPole":"S","facet":"learning","text":"התחלת ללמוד משחק חדש. איזו פתיחה נוחה לך יותר?","a":"הדגמה של תור אחד, צעד אחר צעד","b":"הסבר של הרעיון שמאחורי המשחק והאפשרויות שבו","sourceId":2},{"id":3,"axis":"TF","aPole":"F","facet":"decisions","text":"בוחרים מקום לבילוי עם חברים. מה נוטה להכריע אצלך כשאין אפשרות שמתאימה להכול?","a":"הרצונות האישיים של מי שיוצאים איתי","b":"השוואה של המחיר, המרחק ומה שיש בכל מקום","sourceId":3},{"id":4,"axis":"JP","aPole":"J","facet":"planning","text":"לקראת יום חופשי, מה מרגיש לך נעים יותר?","a":"להחליט מראש מה עושים ומתי","b":"להשאיר את היום פתוח ולבחור תוך כדי","sourceId":4},{"id":5,"axis":"SN","aPole":"N","facet":"attention","text":"אחרי ביקור במקום מעניין, על מה המחשבות שלך נוטות להתעכב?","a":"על הרעיונות והקשרים שהמקום עורר בי","b":"על המראות והפרטים המסוימים שראיתי","sourceId":5},{"id":6,"axis":"EI","aPole":"E","facet":"processing","text":"רעיון מתחיל להתגבש לך בראש. מה בדרך כלל עוזר להבהיר אותו?","a":"לספר עליו למישהו ולחשוב בקול תוך כדי","b":"לעבד אותו בשקט לפני שמשתפים","sourceId":6},{"id":7,"axis":"JP","aPole":"P","facet":"closure","text":"מצאת אפשרות טובה לבילוי, ואפשר להזמין גם מחר. מה טבעי לך?","a":"להשאיר עוד קצת מקום לאפשרויות נוספות","b":"לסגור את הבחירה ולהתפנות לדברים אחרים","sourceId":7},{"id":8,"axis":"TF","aPole":"T","facet":"fairness","text":"צריך לחלק תורנויות בבית. מה נראה לך הוגן יותר?","a":"לקבוע כלל אחיד שלפיו כולם מתחלקים בתורנויות","b":"להתאים את החלוקה למצב האישי של כל אחד","sourceId":8},{"id":9,"axis":"EI","aPole":"E","facet":"breadth","text":"במפגש נעים שבו אפשר לנוע בין שיחות, למה יש לך יותר חשק?","a":"לפגוש כמה אנשים ולהצטרף למעגלי שיחה שונים","b":"להישאר לשיחה ממושכת עם אדם אחד או שניים","sourceId":9},{"id":10,"axis":"TF","aPole":"T","facet":"feedback","text":"חבר מבקש את דעתך על סיפור שכתב. במה יתמקד המשוב שלך קודם?","a":"עד כמה העלילה מובנת והאירועים מתחברים זה לזה","b":"איך הסיפור השפיע עליי ומה הרגשתי כלפי הדמויות","sourceId":10},{"id":11,"axis":"SN","aPole":"N","facet":"patterns","text":"מישהו מספר על כמה אירועים שקרו לו. למה תשומת הלב שלך נמשכת?","a":"לחוט המקשר ולמשמעות שמסתתרת ביניהם","b":"למה שקרה בכל אירוע ולפרטים שמבדילים ביניהם","sourceId":11},{"id":12,"axis":"JP","aPole":"P","facet":"structure","text":"קבוצה קובעת איך להעביר מפגש חברתי. איזו מסגרת נוחה לך?","a":"כיוון כללי, עם מקום לשנות לפי האווירה","b":"תוכנית מוסכמת, כך שברור מה עומד לקרות","sourceId":12},{"id":13,"axis":"TF","aPole":"F","facet":"conflict","text":"שני חברים חלוקים בדעתם ומבקשים לשמוע את דעתך. מאיפה טבעי לך להתחיל?","a":"ממה שחשוב לכל אחד מהם ומאיך ההחלטה תשפיע עליו","b":"מהטענות של כל אחד מהם ומאיזו מהן מבוססת יותר","sourceId":13},{"id":14,"axis":"JP","aPole":"J","facet":"planning","text":"מתכננים ארוחה משותפת בעוד שבוע. מה עדיף לך?","a":"לקבוע כבר עכשיו מי מביא מה","b":"להחליט קרוב למועד לפי מה שיתאים אז","sourceId":14},{"id":15,"axis":"EI","aPole":"I","facet":"processing","text":"צריך להסביר דעה בנושא מורכב, ויש אפשרות לבחור איך. מה נוח לך יותר?","a":"לנסח אותה בכתב לפני שמשוחחים עליה","b":"לפתח אותה בשיחה שבה אפשר לשאול ולהגיב","sourceId":15},{"id":16,"axis":"SN","aPole":"S","facet":"learning","text":"כשמסבירים לך רעיון מורכב, מה הכי עוזר לך לעקוב?","a":"דוגמה ממשית שממחישה בדיוק למה הכוונה","b":"דימוי או עיקרון רחב שמחבר את החלקים","sourceId":16},{"id":17,"axis":"JP","aPole":"J","facet":"sequence","text":"החלטת ללמוד משהו חדש בזמן הפנוי. איך נוח לך להתקדם?","a":"לחלק את הלמידה לשלבים וללכת לפי הסדר","b":"לבחור בכל פעם במה להעמיק לפי מה שמעניין אותי","sourceId":17},{"id":18,"axis":"SN","aPole":"S","facet":"experience","text":"קראת על דרך חיים שונה מאוד משלך. מה היית רוצה להכיר יותר מקרוב?","a":"איך נראים חיי היומיום: האוכל, הבתים והמנהגים","b":"אילו רעיונות ותפיסות עולם עומדים מאחורי דרך החיים","sourceId":18},{"id":19,"axis":"EI","aPole":"I","facet":"initiation","text":"נכנסת לקבוצה חדשה שמקבלת אותך בחום. מה מרגיש טבעי יותר?","a":"להכיר בהדרגה דרך כמה שיחות אישיות","b":"להיכנס מהר לשיחה הקבוצתית ולהכיר תוך כדי","sourceId":19},{"id":20,"axis":"TF","aPole":"F","facet":"values","text":"שתי אפשרויות מתאימות לך באותה מידה מבחינה מעשית. מה יעזור לך לבחור?","a":"לחשוב איזו מהן קרובה יותר למה שחשוב לי אישית","b":"להשוות את הנימוקים בעד ונגד כל אחת","sourceId":20},{"id":21,"axis":"SN","aPole":"N","facet":"possibilities","text":"קיבלת כלי חדש שאפשר להשתמש בו בדרכים שונות. מה מסקרן אותך קודם?","a":"אילו שימושים חדשים ולא צפויים אפשר להמציא לו","b":"מה הוא יודע לעשות בפועל ואיך משתמשים בו היטב","sourceId":21},{"id":22,"axis":"JP","aPole":"P","facet":"adaptability","text":"באמצע עיסוק בשעות הפנאי עולה רעיון למשהו אחר, ויש זמן לשניהם. מה טבעי לך?","a":"לעצור ולנסות את הרעיון החדש","b":"לסיים את מה שהתחלתי ואז לנסות את הרעיון החדש","sourceId":22},{"id":23,"axis":"TF","aPole":"T","facet":"decisions","text":"קיבלת החלטה שמשפיעה גם על אנשים קרובים. מה נותן לך יותר ביטחון בה?","a":"שיש לי נימוקים ברורים לבחירה שעשיתי","b":"שהבחירה מתאימה למה שחשוב לי ולאנשים הקרובים אליי","sourceId":23},{"id":24,"axis":"EI","aPole":"E","facet":"initiation","text":"במפגש הושיבו אותך ליד אדם שנראה נעים, ועדיין לא דיברתם. מה טבעי לך יותר?","a":"לפתוח בשיחה ולהתחיל להכיר","b":"לתת לשיחה להיפתח בהדרגה, בלי ליזום מיד","sourceId":24},{"id":25,"axis":"TF","aPole":"T","facet":"perspective","text":"כדי לפתור מחלוקת מתמשכת, מה יעזור לך יותר בהתחלה?","a":"להפריד בין הטענות ולבדוק מה מבוסס בכל אחת","b":"להבין מה חשוב לכל צד ומה עומד מאחורי עמדתו","sourceId":25},{"id":26,"axis":"EI","aPole":"E","facet":"recharge","text":"אחרי כמה שעות טובות של עיסוק לבד, מה לרוב מתחשק לך?","a":"לצאת קצת החוצה ולפגוש או לדבר עם אנשים","b":"להמשיך עוד זמן במרחב האישי הנעים שלי","sourceId":26},{"id":27,"axis":"JP","aPole":"P","facet":"sequence","text":"יש כמה דברים לעשות בבית, ואין סדר מחייב. איך נוח לך לגשת אליהם?","a":"לעבור מדבר לדבר לפי מה שמתחשק לי באותו רגע","b":"לבחור סדר ולסיים דבר אחד לפני שמתחילים את הבא","sourceId":27},{"id":28,"axis":"SN","aPole":"S","facet":"attention","text":"כשצריך לתאר חדר שהיה לך נעים בו, במה יתמקד התיאור שלך?","a":"באור, בצבעים, ברהיטים ובמה שהיה בחדר","b":"באווירה, באסוציאציות ובמה שהחדר הזכיר לי","sourceId":31},{"id":29,"axis":"EI","aPole":"I","facet":"privacy","text":"קרה לך משהו אישי ומשמח. מה בדרך כלל מתאים לך?","a":"לשמור אותו לעצמי בהתחלה ולשתף רק מעטים","b":"לשתף כמה אנשים קרובים די מהר","sourceId":29},{"id":30,"axis":"TF","aPole":"F","facet":"appreciation","text":"מישהו מודה לך על עזרה. איזה חלק בדבריו משמעותי לך יותר?","a":"שהרגיש שראיתי אותו והבנתי מה הוא צריך","b":"שהעזרה שלי פתרה את הבעיה בצורה טובה","sourceId":30},{"id":31,"axis":"SN","aPole":"S","facet":"interpretation","text":"בסרט מופיע רגע שאפשר להבין בכמה דרכים. מה מעניין אותך יותר?","a":"מה קרה בפועל ומה הדמויות אמרו ועשו","b":"איזו משמעות נוספת או סמל עשויים להיות ברגע הזה","sourceId":33},{"id":32,"axis":"JP","aPole":"J","facet":"preparation","text":"עומדים לצאת לכמה שעות מהבית. מה נוח לך יותר?","a":"להכין מראש את כל מה שצריך לקחת","b":"לאסוף את הדברים כשמגיע הזמן לצאת","sourceId":32},{"id":33,"axis":"EI","aPole":"I","facet":"stimulation","text":"אפשר לבלות שעה נעימה בבית קפה תוסס או בפינה שקטה. מה מושך אותך יותר?","a":"הפינה השקטה, שבה פחות קורה סביבי","b":"בית הקפה התוסס, שבו מרגישים את האנשים מסביב","sourceId":36},{"id":34,"axis":"SN","aPole":"N","facet":"possibilities","text":"כשעולה רעיון לשיפור מקום מוכר, מה מעסיק אותך קודם?","a":"איך המקום יכול להיראות בעתיד אם נחשוב אחרת","b":"מה פועל בו עכשיו ואיזה שינוי ממשי יועיל","sourceId":38},{"id":35,"axis":"TF","aPole":"F","facet":"support","text":"חבר מספר על יום קשה. מה התגובה הראשונה שטבעית לך?","a":"להקשיב ולתת מקום למה שהוא מרגיש","b":"לברר מה קרה ולחשוב איתו מה עשוי לעזור","sourceId":35},{"id":36,"axis":"JP","aPole":"J","facet":"pace","text":"יש לך שבוע להכין משהו למפגש חברים. איזה קצב מתאים לך יותר?","a":"להתחיל מוקדם ולהתקדם קצת בכל יום","b":"לרכז את ההכנה סמוך למפגש, כשכבר נכנסים לאווירה","sourceId":34},{"id":37,"axis":"SN","aPole":"N","facet":"communication","text":"חבר מבקש לשמוע על חוויה שלך. באיזו דרך טבעי לך לספר?","a":"לספר לו מה החוויה גרמה לי לחשוב ומה היא מזכירה לי","b":"לספר לו מה קרה, לפי הסדר, עם פרטים ותיאורים","sourceId":44},{"id":38,"axis":"EI","aPole":"E","facet":"expression","text":"בחבורה קרובה מבקשים ממך לספר סיפור שכולם יקשיבו לו. איך זה מרגיש לך?","a":"נעים לי להיות במרכז השיחה ולשתף את כולם","b":"נעים לי יותר לספר לאדם אחד מאשר לכל החבורה","sourceId":39},{"id":39,"axis":"JP","aPole":"P","facet":"routine","text":"קבעת לעשות משהו בשעות הפנאי, ובאותו יום מתחשק לך משהו אחר. מה טבעי לך?","a":"לשנות את התוכנית לפי מה שמתאים לי עכשיו","b":"להישאר עם התוכנית שבחרתי מראש","sourceId":37},{"id":40,"axis":"TF","aPole":"T","facet":"support","text":"מישהו מציע לך לשנות הרגל. איזה הסבר עשוי לשכנע אותך יותר?","a":"הסבר שמראה איך השינוי יעבוד ומה התועלת שלו","b":"הסבר שמחבר את השינוי לדברים שחשובים לי בחיים","sourceId":40},{"id":41,"axis":"EI","aPole":"E","facet":"stimulation","text":"יום פנוי עבר כמעט בלי קשר עם אחרים. מה בדרך כלל חסר לך בסופו?","a":"קצת נוכחות של אנשים והתרחשות סביבי","b":"לא בהכרח חסר לי משהו, השקט נעים לי","sourceId":43},{"id":42,"axis":"TF","aPole":"F","facet":"fairness","text":"יש כלל קבוע במפגש חברים, ומישהו מבקש לחרוג ממנו. מה השיקול הראשון שלך?","a":"למה החריגה חשובה לו ומה המשמעות שלה עבורו","b":"האם יש סיבה שאפשר להחיל גם על מקרים דומים","sourceId":45},{"id":43,"axis":"SN","aPole":"S","facet":"experience","text":"משהו קטן בבית לא פועל כרגיל. איך טבעי לך להתחיל לבדוק מה קרה?","a":"לבדוק אחד אחד את הפרטים שאפשר לראות ולנסות","b":"לחשוב על הסבר שיכול לחבר בין כל הסימנים","sourceId":46},{"id":44,"axis":"JP","aPole":"J","facet":"routine","text":"בשגרה שיש לך חופש לקבוע, מה מרגיש לך נוח יותר?","a":"לעשות דברים מסוימים בשעות קבועות","b":"לשנות את סדר היום לפי מה שמתאים בכל פעם","sourceId":47},{"id":45,"axis":"TF","aPole":"F","facet":"feedback","text":"חבר מבקש חוות דעת על בחירה שחשובה לו. איך טבעי לך לנסח הסתייגות?","a":"להסביר קודם שאני מבין מה חשוב לו, ואז לומר מה מטריד אותי","b":"לומר קודם מה הבעיה שאני רואה, ואז להסביר את הסיבה","sourceId":51},{"id":46,"axis":"JP","aPole":"J","facet":"closure","text":"סיימת משהו שיצרת להנאתך, והוא מוצלח בעיניך. מה נעים לך יותר?","a":"להחליט שהוא גמור ולעבור לדבר הבא","b":"להשאיר אותו פתוח לעוד שינויים שיעלו בהמשך","sourceId":52},{"id":47,"axis":"EI","aPole":"I","facet":"company","text":"יש לך תחביב שאפשר ליהנות ממנו לבד או יחד. מה בדרך כלל עדיף לך?","a":"לעסוק בו לבד, בקצב ובמרחב שלי","b":"לעסוק בו עם אחרים ולהחליף חוויות תוך כדי","sourceId":49},{"id":48,"axis":"SN","aPole":"N","facet":"interpretation","text":"בקריאת סיפור, מה נוטה לתפוס אותך יותר?","a":"הרעיונות, הסמלים והאפשרויות לפרשנות","b":"הפרטים החיים והתחושה של להיות בתוך ההתרחשות","sourceId":53},{"id":49,"axis":"JP","aPole":"P","facet":"preparation","text":"יוצאים למקום מוכר ולא חסר שם ציוד. איך נוח לך להתכונן?","a":"לקחת את הדברים הבסיסיים ולהחליט במקום מה עוד צריך","b":"לחשוב מראש על מה שאולי ארצה ולהכין בהתאם","sourceId":55},{"id":50,"axis":"SN","aPole":"N","facet":"application","text":"אפשר לקרוא על שימוש מעשי בתגלית או על מה שעוד עשוי להתאפשר בזכותה. מה מושך אותך יותר?","a":"לחשוב על האפשרויות העתידיות שהיא פותחת","b":"להבין איך אפשר להשתמש בה כבר היום","sourceId":59},{"id":51,"axis":"EI","aPole":"E","facet":"company","text":"בזמן עיסוק נינוח, מכר נעים מתחיל איתך שיחה לא דחופה. מה ההרגשה הראשונית שלך?","a":"נחמד לי שנוצרה הזדמנות לשיחה תוך כדי","b":"הייתי מעדיף להמשיך בעיסוק שלי בלי שיחה כרגע","sourceId":56},{"id":52,"axis":"TF","aPole":"T","facet":"conflict","text":"בני הבית לא מסכימים מה עדיף לעשות. איזה תפקיד טבעי לך לקחת בשיחה?","a":"לחדד את ההבדלים בין ההצעות כדי שיהיה קל להכריע","b":"למצוא מה משותף להצעות כדי שיהיה קל להגיע להסכמה","sourceId":54},{"id":53,"axis":"SN","aPole":"S","facet":"application","text":"בתחום שמעניין אותך, מה מושך אותך יותר?","a":"לשפר משהו קיים כך שיעבוד טוב יותר","b":"לחשוב על משהו חדש שעדיין לא ניסו","sourceId":64},{"id":54,"axis":"JP","aPole":"P","facet":"structure","text":"למשחק חברתי חדש מציעים לקבוע כללים יחד. מה מתאים לך יותר?","a":"להתחיל עם כמה כללים ולהוסיף לפי מה שיתעורר","b":"להסכים מראש על הכללים לפני שמתחילים לשחק","sourceId":58},{"id":55,"axis":"TF","aPole":"T","facet":"values","text":"שמעת הצעה שנשמעת טובה בהתחלה. מה טבעי לך לבדוק קודם?","a":"אילו חסרונות או קשיים אולי לא הביאו בחשבון","b":"מה יש בה שכדאי לתמוך בו ולעודד","sourceId":57},{"id":56,"axis":"EI","aPole":"I","facet":"privacy","text":"הצטרפת לחבורה נחמדה והאווירה פתוחה. כמה מעצמך טבעי לך לשתף בהתחלה?","a":"בעיקר דברים כלליים, ואת האישי לשמור להמשך ההיכרות","b":"גם מחשבות וחוויות אישיות, אם השיחה מזמינה זאת","sourceId":63}],"revision":"1.1.0-f21b74663d17"};
const MBTI_PROFILES = {"ISTJ":{"he":"מקשג","name":"המפקח / הלוגיסטיקן","description":"הצירוף הזה מציע העדפה לעבודה שקולה, לפרטים ממשיים ולהתקדמות בתוך מסגרת ברורה. ייתכן שנוח לך לברר מה נדרש, לבנות דרך מסודרת ולדאוג שגם הפרטים הקטנים יקבלו מענה.","strengths":["מעקב אחר פרטים והתחייבויות","תרגום ניסיון לשיטה שימושית","קבלת החלטות לפי קריטריונים עקביים"],"stretch":"כששיטה מוכרת עובדת, קל לפסול חלופה לפני שנותנים לה הזדמנות. כדאי לברר מתי הניסיון מועיל ומתי התנאים כבר השתנו.","relationships":"אכפתיות יכולה להתבטא אצלך בעשייה ובנוכחות עקבית. לפעמים כדאי לומר במילים את מה שמבחינתך כבר ברור מהמעשים.","work":"מטרה מוגדרת, אחריות ברורה וזמן להכנה עשויים לעזור לך להביא את המיטב.","experiment":"לבחור הרגל קטן ולנסות לו חלופה אחת, בלי להתחייב לאמץ אותה."},"ISFJ":{"he":"מקרג","name":"המגן","description":"כאן נפגשות תשומת לב לפרטים, התחשבות אישית וחיבה למסגרת. ייתכן שחשוב לך לזכור מה מועיל לאנשים סביבך וליצור עבורם תחושה של רציפות וביטחון, גם בלי לעמוד במרכז.","strengths":["זיכרון לפרטים אישיים שימושיים","תמיכה מעשית שמתאימה לאדם","התמדה בטיפוח קשרים ומסגרות"],"stretch":"הרצון לשמור על מה שטוב לאחרים עלול לדחוק את ההעדפות שלך. הבעת צורך אישי אינה מבטלת את ההתחשבות.","relationships":"מחוות קטנות עשויות להיות שפה טבעית עבורך. שיחה מפורשת על ציפיות יכולה לחסוך הנחות שאינן משותפות לשני הצדדים.","work":"סביבה מכבדת, משימות מוחשיות וציפיות ידועות עשויות להתאים לקצב שלך.","experiment":"לנסח בקשה אישית אחת באופן ברור, לפני שמציעים שוב עזרה."},"INFJ":{"he":"מערג","name":"הסנגור","description":"השילוב הזה נוטה לחבר התבוננות פנימית, חיפוש משמעות והתחשבות באנשים עם רצון להתקדם לכיוון ברור. ייתכן שחשוב לך להבין לא רק מה קורה, אלא גם מה עומד מאחוריו ולאן הוא מוביל.","strengths":["חיבור בין רעיונות לערכים","הקשבה למשמעויות שמאחורי הדברים","התמקדות בכיוון בעל משמעות אישית"],"stretch":"תמונה פנימית משכנעת אינה תמיד התמונה של האחר. כדאי לבדוק פרשנויות במקום להניח שהבנת בדיוק למה התכוונו.","relationships":"ייתכן שחשובות לך שיחות עומק וזמן לעיבוד. אפשר לבקש את שניהם במפורש, גם בלי לצפות שאחרים ינחשו.","work":"מרחב ריכוז, מטרה משמעותית ויכולת לתכנן את הדרך עשויים לתמוך בך.","experiment":"לבדוק פרשנות אחת באמצעות שאלה פשוטה: האם לזה התכוונת?"},"INTJ":{"he":"מעשג","name":"האדריכל","description":"התשובות בכיוון הזה מחברות חשיבה עצמאית, זיהוי דפוסים ובחינה עניינית עם רצון במבנה ובהכרעה. ייתכן שנוח לך לבנות תמונה רחבה ואז לחפש את הדרך ההגיונית שתהפוך אותה למציאות.","strengths":["בניית תמונה אסטרטגית","בחינת הנחות ומבנים","מיקוד מאמץ בכיוון ארוך טווח"],"stretch":"תוכנית בהירה בראש אינה בהכרח ברורה לאחרים. שיתוף בהנחות ובשיקולים יכול להיות חלק מהביצוע עצמו.","relationships":"עצמאות וישירות עשויות להיות חשובות לך. כדאי להשאיר מקום גם למה שאנשים מרגישים לפני שמציעים שיפור.","work":"בעיה מורכבת, חופש לחשוב ומטרות ברורות עשויים להיות שילוב נוח עבורך.","experiment":"להציג רעיון לפני שהוא מושלם ולבקש מאדם אחר לזהות הנחה חסרה."},"ISTP":{"he":"מקשפ","name":"האומן / הווירטואוז","description":"זהו שילוב של מרחב אישי, תשומת לב למה שקורה בפועל, בחינה הגיונית וגמישות. ייתכן שנוח לך להבין בעיה דרך התנסות ולבחור פתרון לפי המצב, בלי להעמיס עליו מסגרת מיותרת.","strengths":["איתור תקלות באופן ענייני","למידה דרך התנסות ישירה","התאמת פתרונות לתנאים בשטח"],"stretch":"פתרון שעובד ברגע זה אינו תמיד מסביר לאחרים מה יקרה בהמשך. מעט תיאום מראש יכול להגן על החופש שלך.","relationships":"ייתכן שנוח לך להראות אכפתיות דרך עזרה מעשית וזמן משותף. לפעמים הצד השני צריך גם לשמוע מה עובר עליך.","work":"עצמאות, בעיות מוחשיות ומרחב לשנות את דרך הפעולה עשויים להתאים לך.","experiment":"לשתף מישהו בצעד הבא שלך עוד לפני שהוא שואל."},"ISFP":{"he":"מקרפ","name":"ההרפתקן","description":"כאן נפגשים עיבוד פנימי, חוויה מוחשית, ערכים אישיים וגמישות. ייתכן שנוח לך להרגיש את הדברים מקרוב ולבחור בקצב שלך מה מתאים לך, בלי להפוך כל חוויה לתוכנית מסודרת.","strengths":["רגישות לפרטים בחוויה המיידית","נאמנות למה שחשוב לך","התחשבות אישית שאינה מחייבת במה"],"stretch":"שמירת האפשרויות פתוחות עשויה להקשות על אחרים להבין למה לצפות. אפשר לקבוע עוגן קטן בלי לוותר על גמישות.","relationships":"ייתכן שמעשים וחוויות משותפות קרובים לליבך. הבעת העדפות במילים נותנת לאחרים הזדמנות לכבד אותן.","work":"מרחב אישי, עשייה מוחשית וחופש בדרך הביצוע עשויים לעזור לך.","experiment":"לבחור התחייבות קטנה אחת לשבוע ולתת לה זמן מוגדר."},"INFP":{"he":"מערפ","name":"המתווך","description":"הצירוף הזה מחבר התבוננות פנימית, דמיון וערכים אישיים עם פתיחות לאפשרויות. ייתכן שחשוב לך למצוא דרך שנאמנה למה שיקר לך, ולראות מעבר למצב הקיים גם את מה שהוא יכול להיות.","strengths":["התבוננות מזוויות אפשריות שונות","חיבור בין רעיונות לערכים אישיים","מתן מקום לחוויה של אדם אחר"],"stretch":"כשיש הרבה אפשרויות משמעותיות, הבחירה באחת עלולה להרגיש כמו ויתור. צעד קטן אינו מחייב החלטה לכל החיים.","relationships":"ייתכן שחשובים לך כנות, עומק ומרחב להיות עצמך. שיתוף בצרכים קונקרטיים יכול לקרב יותר מרמזים.","work":"משמעות אישית, זמן לחשיבה וגמישות מסוימת בדרך עשויים לעזור לך להתמיד.","experiment":"להפוך רעיון יקר לך לפעולה שאפשר להשלים בעשרים דקות."},"INTP":{"he":"מעשפ","name":"הלוגיקאי / הפילוסוף","description":"זהו שילוב של מחשבה עצמאית, עניין בדפוסים, בחינה הגיונית ופתיחות. ייתכן שהסקרנות שלך מתעוררת כשאפשר לפרק הנחות, לבדוק הסברים ולגלות אפשרות שלא נראתה בהתחלה.","strengths":["בחינה של עקביות פנימית","יצירת הסברים וחיבורים חדשים","נכונות לעדכן רעיון כשמוצאים בו פער"],"stretch":"תמיד אפשר לחדד עוד, אבל לפעמים ערכו של רעיון מתברר רק כשמנסים אותו. כדאי להגדיר מה מספיק לניסוי ראשון.","relationships":"שיחה על רעיונות עשויה להיות דרך לחיבור. שווה לבדוק אם כרגע מבקשים ממך ניתוח, הקשבה או עזרה מעשית.","work":"שאלות מורכבות, זמן ללא הפרעות וחופש לבדוק חלופות עשויים להתאים לך.","experiment":"להגדיר שעת עצירה למחקר ולהוציא גרסה קטנה שאפשר לבחון."},"ESTP":{"he":"חקשפ","name":"היזם","description":"כאן נפגשים קשר עם הסביבה, התמקדות במציאות, שיקולים ענייניים וגמישות. ייתכן שנוח לך לפגוש מצב כפי שהוא, לנסות משהו ולתקן בהתאם למשוב שמגיע מהשטח.","strengths":["זיהוי אפשרויות מעשיות ברגע נתון","למידה מהירה דרך עשייה","שיחה ישירה שמקדמת פעולה"],"stretch":"הצעד הזמין ביותר אינו תמיד המתאים ביותר לטווח ארוך. עצירה קצרה יכולה לחשוף מחיר שלא רואים מיד.","relationships":"עשייה משותפת ושיחה חיה עשויות להיות טבעיות לך. כדאי לתת מקום גם לקצב עיבוד איטי משלך.","work":"מגע עם אנשים, משוב מיידי ומרחב לאלתור עשויים לעזור לך להתקדם.","experiment":"לפני פעולה חדשה, לרשום תוצאה אפשרית אחת להיום ואחת לעוד חודש."},"ESFP":{"he":"חקרפ","name":"הבדרן","description":"השילוב הזה מציע עניין באנשים, חוויה מוחשית, התחשבות וגמישות. ייתכן שקל לך להתחבר למה שקורה עכשיו ולשים לב כיצד אפשר להפוך את הרגע לנעים ומשמעותי יותר עבור המשתתפים.","strengths":["יצירת קשר דרך חוויה משותפת","תשומת לב לתגובות של אנשים בזמן אמת","התאמה גמישה למה שקורה סביבך"],"stretch":"מה שנעים ברגע זה עלול להשאיר משימה חשובה למועד לא נוח. עוגנים קטנים יכולים לפנות מקום להנאה בהמשך.","relationships":"ייתכן שחום, נוכחות ועשייה משותפת חשובים לך. שיחות שקטות יכולות לחשוף צרכים שאינם בולטים על פני השטח.","work":"סביבה אנושית, משימות מוחשיות ומגוון עשויים להיטיב איתך.","experiment":"לסיים משימה קטנה שקבעת מראש לפני שעוברים להזדמנות המפתה הבאה."},"ENFP":{"he":"חערפ","name":"הפעיל / האקטיביסט","description":"כאן מתחברים עיבוד דרך קשר עם אחרים, חיפוש אפשרויות, ערכים אישיים וגמישות. ייתכן ששיחה טובה מעוררת אצלך כיוונים חדשים, במיוחד כשהם מתחברים לאנשים או למשהו שחשוב לך.","strengths":["חיבור בין רעיונות ואנשים","זיהוי פוטנציאל שעדיין לא התממש","התלהבות שמזמינה השתתפות"],"stretch":"ריבוי כיוונים יכול לפזר את האנרגיה גם כשכולם טובים. בחירת כיוון זמני יכולה לעזור לרעיון אחד לקבל חיים.","relationships":"סקרנות וחילופי מחשבות עשויים להיות דרך טבעית לקרבה. כדאי לבדוק גם אילו התחייבויות קטנות הצד השני צריך.","work":"גיוון, משמעות ומרחב להציע דרכים חדשות עשויים להתאים לך.","experiment":"לבחור רעיון אחד לשבוע הקרוב ולהגדיר לו תוצר קטן ומועד."},"ENTP":{"he":"חעשפ","name":"הפולמוסן / המתווכח","description":"השילוב הזה מחבר חשיבה בקול, עניין באפשרויות, בדיקה עניינית ופתיחות. ייתכן ששיחה היא עבורך מעבדה לרעיונות: מציעים, מערערים ומשנים כדי למצוא זווית טובה יותר.","strengths":["יצירת חלופות לא שגרתיות","זיהוי הנחות שאפשר לאתגר","פיתוח רעיון באמצעות שיחה וביקורת"],"stretch":"בחינת טיעון לשם הסקרנות עלולה להיחוות כביקורת אישית. כדאי להבהיר את הכוונה ולברר אם הצד השני רוצה דיון כזה עכשיו.","relationships":"ייתכן שהחלפת רעיונות נותנת לך אנרגיה. הקשבה בלי להציע מיד זווית נגדית יכולה לפתוח סוג אחר של קרבה.","work":"שאלות פתוחות, שותפים לחשיבה וחופש לנסות חלופות עשויים להיטיב איתך.","experiment":"לבחור חלופה אחת ולבדוק אותה בפועל לפני שמציעים שלוש נוספות."},"ESTJ":{"he":"חקשג","name":"המנהל","description":"זהו חיבור בין מעורבות בסביבה, תשומת לב לעובדות, הכרעה עניינית ומסגרת. ייתכן שנוח לך להבהיר את המטרה, לסכם מה צריך לקרות וליצור סדר שמאפשר לאנשים להתקדם יחד.","strengths":["הפיכת מטרות למשימות מוגדרות","תיאום אחריות וציפיות","בחינת התקדמות לפי נתונים ברורים"],"stretch":"קצב החלטה מהיר עלול להקדים מידע או הסתייגות שעדיין לא נאמרו. הזמנה מפורשת להשמיע קושי יכולה לשפר את התוכנית.","relationships":"נאמנות ועזרה מעשית עשויות להיות חשובות לך. לא כל קושי שמספרים לך עליו דורש ארגון מחדש.","work":"יעדים ברורים, תיאום ומרחב לקדם ביצוע עשויים להתאים לך.","experiment":"לפני סיכום החלטה, לבקש מכל משתתף לציין דבר אחד שעוד לא נשקל."},"ESFJ":{"he":"חקרג","name":"היועץ","description":"כאן נפגשים קשר פעיל עם אנשים, תשומת לב לפרטים, התחשבות ומסגרת. ייתכן שחשוב לך שהציפיות יהיו ברורות ושהאנשים המעורבים ירגישו שיש מי שרואה אותם ודואג למפגש מוצלח.","strengths":["תיאום צרכים מעשיים של אנשים","יצירת תחושת שותפות","מעקב אחר פרטים שמקלים על אחרים"],"stretch":"ניסיון לדאוג לכולם עלול להפוך להסכמה אוטומטית. גבול ברור עוזר לשמור גם על הקשר וגם על הכוחות שלך.","relationships":"שיתוף, מחוות והדדיות עשויים להיות חשובים לך. כדאי לבדוק אם לאחרים יש דרך שונה להביע אכפתיות.","work":"שיתוף פעולה, תפקידים ידועים ומשוב אנושי עשויים לסייע לך.","experiment":"להחליף הסכמה מיידית אחת במשפט: אבדוק מה מתאים לי ואחזור עם תשובה."},"ENFJ":{"he":"חערג","name":"הגיבור","description":"הצירוף הזה מחבר מעורבות חברתית, ראיית אפשרויות, ערכים ורצון בכיוון ברור. ייתכן שנוח לך לחשוב יחד עם אחרים על מה שיכול לצמוח, ולעזור לרעיון משותף להפוך למחויבות מעשית.","strengths":["ניסוח כיוון שאנשים יכולים להתחבר אליו","זיהוי שאיפות וצרכים בשיחה","ארגון מאמץ סביב מטרה משותפת"],"stretch":"ראיית פוטנציאל באדם אינה אומרת שזה הכיוון שהוא רוצה. אפשר להציע תמיכה ולהשאיר את הבחירה בידיו.","relationships":"ייתכן שחשוב לך לדבר על משמעות ועל צמיחה משותפת. לפעמים קשר צריך פשוט מקום להיות, בלי יעד לשיפור.","work":"מטרה בעלת משמעות, קשר עם אנשים ותוכנית ברורה עשויים להתאים לך.","experiment":"לשאול אדם קרוב איזה סוג תמיכה הוא רוצה, ולפעול לפי תשובתו."},"ENTJ":{"he":"חעשג","name":"המפקד","description":"כאן מתחברים חשיבה דרך מעורבות, תמונה רחבה, הכרעה עניינית והעדפה למסגרת. ייתכן שנוח לך לזהות כיוון, להציב סדרי עדיפויות ולהניע שיחה שמסתיימת בהחלטה ובצעד הבא.","strengths":["חיבור בין אסטרטגיה להחלטות","תעדוף של מאמץ ומשאבים","הבהרת מטרות והנעת התקדמות"],"stretch":"כשברור לך מה צריך לקרות, קל להניח שגם לאחרים ברור ומוסכם. בדיקת ההבנה וההשפעה האנושית יכולה לחזק את הביצוע.","relationships":"ישירות ומחויבות עשויות להיות חשובות לך. אפשר להראות אכפתיות גם בהקשבה שאין בסופה פתרון.","work":"אתגר מורכב, אחריות ברורה ואפשרות לקדם כיוון עשויים לעזור לך.","experiment":"בדיון הבא, לשמוע את ההצעות של האחרים לפני שמציגים את ההכרעה שלך."}};
const MBTI_ILLUSTRATIONS = {"ISTJ":"data:image/svg+xml;base64,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","ISFJ":"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNDAgMjQwIiByb2xlPSJpbWciIGFyaWEtbGFiZWxsZWRieT0iaXNmai10aXRsZSIgYXJpYS1kZXNjcmliZWRieT0iaXNmai1kZXNjIj4KPHRpdGxlIGlkPSJpc2ZqLXRpdGxlIj5JU0ZKOiBUaGUgZ2FyZGVuZXIgcHJvdGVjdGluZyBhIHlvdW5nIHBsYW50PC90aXRsZT4KPGRlc2MgaWQ9ImlzZmotZGVzYyI+QSBraW5kbHkgYmFsZGluZywgYmVhcmRlZCBtYWxlIGdhcmRlbmVyIGluIGEgcm9zZSBjYXJkaWdhbiBjdXBzIGEgdGVycmFjb3R0YSBwb3QgaW4gYm90aCBoYW5kcy4gVHdvIGZyZXNoIGdyZWVuIGxlYXZlcyBhcmUgdGhlIGdlbnRsZSBmb2NhbCBwb2ludC48L2Rlc2M+CjxjaXJjbGUgY3g9IjEyMCIgY3k9IjEyMiIgcj0iODQiIGZpbGw9IiNGN0VBRUUiLz4KPGVsbGlwc2UgY3g9IjEyMCIgY3k9IjIxNiIgcng9IjY1IiByeT0iMyIgZmlsbD0iIzI2M0Q0OCIgb3BhY2l0eT0iLjA4Ii8+CjxnIGZpbGw9Im5vbmUiIHN0cm9rZT0iIzI2M0Q0OCIgc3Ryb2tlLXdpZHRoPSIxLjQiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCI+CjxnIHRyYW5zZm9ybT0idHJhbnNsYXRlKDExOSAwKSI+CjxnIGRhdGEtcGFydD0ibGVnIj4KPGcgZGF0YS1wYXJ0PSJzaG9lIiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgtMTMgMjA0KSByb3RhdGUoMCkgc2NhbGUoLTEgMSkiPgo8cGF0aCBkPSJNLTcuNSAtM0g3LjVRNy41IDAgOS41IDJMMTcgNC41UTIxIDUuNSAyMSA4VjEwSC03LjVRLTguNSAxMCAtOC41IDdaIiBmaWxsPSIjMjYzRDQ4Ii8+CjxwYXRoIGQ9Ik0tNi41IDhIMTkiIHN0cm9rZT0iI0ZGRjlFRCIgc3Ryb2tlLXdpZHRoPSIxIiBvcGFjaXR5PSIuMzIiLz4KPC9nPgo8cGF0aCBkPSJNLTIzIDE1MkgyUTEgMTY4LTMgMTgwTC01LjUgMjA0IEwtMjAuNSAyMDRRLTIzIDE4MS0yMyAxNTJaIiBmaWxsPSIjNDM1NTRDIiBkYXRhLXBhcnQ9InRyb3VzZXJzIi8+CjwvZz4KPGcgZGF0YS1wYXJ0PSJsZWciPgo8ZyBkYXRhLXBhcnQ9InNob2UiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDIxIDIwNCkgcm90YXRlKDApIHNjYWxlKDEgMSkiPgo8cGF0aCBkPSJNLTcuNSAtM0g3LjVRNy41IDAgOS41IDJMMTcgNC41UTIxIDUuNSAyMSA4VjEwSC03LjVRLTguNSAxMCAtOC41IDdaIiBmaWxsPSIjMjYzRDQ4Ii8+CjxwYXRoIGQ9Ik0tNi41IDhIMTkiIHN0cm9rZT0iI0ZGRjlFRCIgc3Ryb2tlLXdpZHRoPSIxIiBvcGFjaXR5PSIuMzIiLz4KPC9nPgo8cGF0aCBkPSJNMSAxNTJIMjNRMjQgMTcwIDI1IDE4NEwyOC41IDIwNCBMMTMuNSAyMDRROCAxODQgMyAxNzNMLTEgMTY2WiIgZmlsbD0iIzI2M0Q0OCIgZGF0YS1wYXJ0PSJ0cm91c2VycyIvPgo8L2c+CjwvZz4KPHBhdGggZD0iTTk0IDEwN1E3MiAxMjggODQgMTQ1TDEwNSAxNjEiIHN0cm9rZS13aWR0aD0iMTYuNiIvPgo8cGF0aCBkPSJNOTQgMTA3UTcyIDEyOCA4NCAxNDVMMTA1IDE2MSIgc3Ryb2tlPSIjOUE1MjYzIiBzdHJva2Utd2lkdGg9IjE0Ii8+CjxwYXRoIGQ9Ik0xNDMgMTA3UTE2NSAxMjggMTU0IDE0NkwxMzQgMTYxIiBzdHJva2Utd2lkdGg9IjE2LjYiLz4KPHBhdGggZD0iTTE0MyAxMDdRMTY1IDEyOCAxNTQgMTQ2TDEzNCAxNjEiIHN0cm9rZT0iIzlBNTI2MyIgc3Ryb2tlLXdpZHRoPSIxNCIvPgo8ZyB0cmFuc2Zvcm09InRyYW5zbGF0ZSgxMTkgMCkgcm90YXRlKDAgMCAxMjYpIj4KPHBhdGggZD0iTS0xMCA5NlEtMjYgOTctMjggMTA5TC0yNCAxNThRMCAxNjMgMjYgMTU2TDI1IDEwOVEyMyA5OSAxMCA5NloiIGZpbGw9IiM5QTUyNjMiLz4KPHBhdGggZD0iTS05IDk3IDAgMTA0IDEwIDk3IDEyIDE1Ni03IDE1OVoiIGZpbGw9IiNGRkY5RUQiIHN0cm9rZT0ibm9uZSIvPgo8cGF0aCBkPSJNLTExIDk2LTIgMTA0LTEwIDEyMi0yMCAxMDhaIiBmaWxsPSIjQkE3Nzg2IiBzdHJva2U9Im5vbmUiLz4KPHBhdGggZD0iTTExIDk2IDIgMTA0IDEyIDEyMSAyMSAxMDdaIiBmaWxsPSIjQkE3Nzg2IiBzdHJva2U9Im5vbmUiLz4KPHBhdGggZD0iTS0xMCAxMjQtMTEgMTU0TTEzIDEyNSAxNiAxNTMiIHN0cm9rZT0iI0ZGRjlFRCIgc3Ryb2tlLXdpZHRoPSIxIiBvcGFjaXR5PSIuMjgiLz4KPC9nPgo8ZyB0cmFuc2Zvcm09InRyYW5zbGF0ZSgxMTkgNjcpIHJvdGF0ZSgxKSI+CjxyZWN0IHg9Ii02IiB5PSIxNyIgd2lkdGg9IjEyIiBoZWlnaHQ9IjE2IiByeD0iMyIgZmlsbD0iI0UzQUY4NyIvPgo8cGF0aCBkPSJNLTUgMjFRMCAyNiA2IDIyVjI4UTAgMzAtNSAyN1oiIGZpbGw9IiNDOTg5NjMiIHN0cm9rZT0ibm9uZSIvPgo8ZWxsaXBzZSBjeD0iLTE2LjUiIGN5PSIzIiByeD0iMy41IiByeT0iNSIgZmlsbD0iI0UzQUY4NyIvPgo8ZWxsaXBzZSBjeD0iMTYuNSIgY3k9IjMiIHJ4PSIzLjUiIHJ5PSI1IiBmaWxsPSIjRTNBRjg3Ii8+CjxwYXRoIGQ9Ik0tMTYtMTJRLTE2LTI0IDAtMjRRMTYtMjQgMTYtMTJWN1ExNSAyMSAwIDI0US0xNCAyMi0xNiA4WiIgZmlsbD0iI0UzQUY4NyIvPgo8cGF0aCBkPSJNLTE2IDVRLTIxLTktMTUtMTZMLTEwLTIwVi0xM0wtMTItNlY1Wk0xMS0yMFEyMS0xMiAxNyA1TDEzIDRWLThaIiBmaWxsPSIjNjY1MTNGIiBzdHJva2U9IiM2NjUxM0YiLz4KPHBhdGggZD0iTS0xNSA2LTEwIDEwLTUgMTAgMCA4IDYgMTAgMTEgOSAxNSA1IDEzIDE2UTggMjQgMCAyNFEtMTAgMjItMTQgMTVaIiBmaWxsPSIjNjY1MTNGIiBzdHJva2U9IiM2NjUxM0YiLz4KPHBhdGggZD0iTS0xMS0yUS03LTQtMy0yTTQtMlE4LTQgMTItMiIgc3Ryb2tlPSIjNjY1MTNGIi8+CjxjaXJjbGUgY3g9Ii03IiBjeT0iMyIgcj0iMS4xNSIgZmlsbD0iIzI2M0Q0OCIgc3Ryb2tlPSJub25lIi8+CjxjaXJjbGUgY3g9IjgiIGN5PSIzIiByPSIxLjE1IiBmaWxsPSIjMjYzRDQ4IiBzdHJva2U9Im5vbmUiLz4KPHBhdGggZD0iTTEgNC0xIDkgMiAxMCIgc3Ryb2tlPSIjQzk4OTYzIiBzdHJva2Utd2lkdGg9IjEuMiIvPgo8cGF0aCBkPSJNLTUgMTRRMCAxOSA2IDE0IiBzdHJva2U9IiNGRkY5RUQiLz4KPC9nPgo8cGF0aCBkPSJNODMgMTQxUTg1IDE1MyAxMDggMTY2IiBzdHJva2Utd2lkdGg9IjE0LjYiLz4KPHBhdGggZD0iTTgzIDE0MVE4NSAxNTMgMTA4IDE2NiIgc3Ryb2tlPSIjOUE1MjYzIiBzdHJva2Utd2lkdGg9IjEyIi8+CjxwYXRoIGQ9Ik0xNTUgMTQxUTE1MSAxNTQgMTMyIDE2NiIgc3Ryb2tlLXdpZHRoPSIxNC42Ii8+CjxwYXRoIGQ9Ik0xNTUgMTQxUTE1MSAxNTQgMTMyIDE2NiIgc3Ryb2tlPSIjOUE1MjYzIiBzdHJva2Utd2lkdGg9IjEyIi8+CjxnIHN0cm9rZT0iIzk2NUM0MCI+CjxwYXRoIGQ9Ik0xMDQgMTQ2SDEzNUwxMzEgMTc0UTExOSAxNzggMTA5IDE3NFoiIGZpbGw9IiNCQTdDNTUiLz4KPHJlY3QgeD0iMTAxIiB5PSIxNDIiIHdpZHRoPSIzNyIgaGVpZ2h0PSI3IiByeD0iMiIgZmlsbD0iI0Q1OUE2QyIvPgo8cGF0aCBkPSJNMTE5IDE0MlYxMTMiIHN0cm9rZT0iIzU5Nzk1MyIgc3Ryb2tlLXdpZHRoPSIyIi8+CjxwYXRoIGQ9Ik0xMTggMTMxUTk3IDEzMyA5OCAxMTRRMTE3IDExMyAxMTggMTMxWiIgZmlsbD0iIzZBOTI1RSIgc3Ryb2tlPSJub25lIi8+CjxwYXRoIGQ9Ik0xMjAgMTIyUTExNyAxMDIgMTM4IDEwMlExMzkgMTIyIDEyMCAxMjJaIiBmaWxsPSIjOEJBOTc2IiBzdHJva2U9Im5vbmUiLz4KPHBhdGggZD0iTTEwNCAxMTkgMTE3IDEzMU0xMjEgMTE5IDEzMyAxMDciIHN0cm9rZT0iI0M3RDlBQiIgc3Ryb2tlLXdpZHRoPSIxLjIiLz4KPC9nPgo8Zz4KPHBhdGggZD0iTTk4IDE1OFExMDIgMTU1IDEwNyAxNjFMMTA5IDE2OSAxMTkgMTcxUTEyMiAxNzQgMTE4IDE3N0wxMDcgMTc1UTEwMCAxNzQgOTYgMTY3WiIgZmlsbD0iI0UzQUY4NyIvPgo8cGF0aCBkPSJNMTQwIDE1N1ExMzYgMTU1IDEzMyAxNjFMMTMwIDE2OSAxMjIgMTcxUTExOSAxNzQgMTIyIDE3N0wxMzQgMTc1UTE0MSAxNzMgMTQ0IDE2NloiIGZpbGw9IiNFM0FGODciLz4KPHBhdGggZD0iTTEwNyAxNjggMTEzIDE3Mk0xMzMgMTY4IDEyOCAxNzIiIHN0cm9rZT0iI0M5ODk2MyIgc3Ryb2tlLXdpZHRoPSIxIi8+CjwvZz4KPC9nPgo8L3N2Zz4K","INFJ":"data:image/svg+xml;base64,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","INTJ":"data:image/svg+xml;base64,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","ISTP":"data:image/svg+xml;base64,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","ISFP":"data:image/svg+xml;base64,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","INFP":"data:image/svg+xml;base64,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","INTP":"data:image/svg+xml;base64,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","ESTP":"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNDAgMjQwIiByb2xlPSJpbWciIGFyaWEtbGFiZWxsZWRieT0iZXN0cC10aXRsZSIgYXJpYS1kZXNjcmliZWRieT0iZXN0cC1kZXNjIj4KPHRpdGxlIGlkPSJlc3RwLXRpdGxlIj5FU1RQOiBUaGUgYWR2ZW50dXJlciBzdGVwcGluZyBvbnRvIGEgcm9jazwvdGl0bGU+CjxkZXNjIGlkPSJlc3RwLWRlc2MiPkEgY29uZmlkZW50IG1hbGUgYWR2ZW50dXJlciBpbiBhbiBvY2hyZSBqYWNrZXQgcmVzdHMgb25lIGZvb3Qgb24gYSByb2NrLiBTdW5nbGFzc2VzLCBhIHdyaXN0d2F0Y2ggYW5kIGEgY2FtZXJhIG9uIGEgY29ubmVjdGVkIG5lY2sgc3RyYXAgY29udmV5IHJlYWRpbmVzcyB0byBleHBsb3JlLjwvZGVzYz4KPGNpcmNsZSBjeD0iMTIwIiBjeT0iMTIyIiByPSI4NCIgZmlsbD0iI0ZGRjBERSIvPgo8ZWxsaXBzZSBjeD0iMTIwIiBjeT0iMjE2IiByeD0iNjUiIHJ5PSIzIiBmaWxsPSIjMjYzRDQ4IiBvcGFjaXR5PSIuMDgiLz4KPGcgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjMjYzRDQ4IiBzdHJva2Utd2lkdGg9IjEuNCIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIj4KPHBhdGggZD0iTTEzNCAyMTQgMTQzIDE5NSAxNjEgMTkwIDE4MyAxOTUgMjAyIDIxNFoiIGZpbGw9IiNDN0M1QjEiIHN0cm9rZT0ibm9uZSIvPgo8cGF0aCBkPSJNMTQzIDE5NSAxNjAgMTk4IDE2OCAyMDdNMTYxIDE5MCAxNzQgMjAxIiBzdHJva2U9IiM5QzlDOEMiIHN0cm9rZS13aWR0aD0iMS4yIi8+CjxnIGRhdGEtcGFydD0ibGVnIj4KPGcgZGF0YS1wYXJ0PSJzaG9lIiB0cmFuc2Zvcm09InRyYW5zbGF0ZSg5NyAyMDQpIHJvdGF0ZSgwKSBzY2FsZSgtMSAxKSI+CjxwYXRoIGQ9Ik0tNy41IC0zSDcuNVE3LjUgMCA5LjUgMkwxNyA0LjVRMjEgNS41IDIxIDhWMTBILTcuNVEtOC41IDEwIC04LjUgN1oiIGZpbGw9IiMyNjNENDgiLz4KPHBhdGggZD0iTS02LjUgOEgxOSIgc3Ryb2tlPSIjRkZGOUVEIiBzdHJva2Utd2lkdGg9IjEiIG9wYWNpdHk9Ii4zMiIvPgo8L2c+CjxwYXRoIGQ9Ik04NiAxNTFIMTExUTExMSAxNzEgMTA3IDE4NUwxMDQuNSAyMDQgTDg5LjUgMjA0UTg2IDE4MSA4NiAxNTFaIiBmaWxsPSIjMjYzRDQ4IiBkYXRhLXBhcnQ9InRyb3VzZXJzIi8+CjwvZz4KPGcgZGF0YS1wYXJ0PSJsZWciPgo8ZyBkYXRhLXBhcnQ9InNob2UiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDE0NyAxODQpIHJvdGF0ZSgwKSBzY2FsZSgxIDEpIj4KPHBhdGggZD0iTS03IC0zSDdRNyAwIDkgMkwxNyA0LjVRMjEgNS41IDIxIDhWMTBILTdRLTggMTAgLTggN1oiIGZpbGw9IiMyNjNENDgiLz4KPHBhdGggZD0iTS02IDhIMTkiIHN0cm9rZT0iI0ZGRjlFRCIgc3Ryb2tlLXdpZHRoPSIxIiBvcGFjaXR5PSIuMzIiLz4KPC9nPgo8cGF0aCBkPSJNMTA4IDE1MlExMzIgMTQ1IDE0NiAxNTVRMTU4IDE2MSAxNTcgMTcwTDE1NCAxODQgTDE0MCAxODRMMTM3IDE3M1ExMjQgMTc3IDExMyAxNzVMMTA2IDE2NFoiIGZpbGw9IiM0RDU2NUEiIGRhdGEtcGFydD0idHJvdXNlcnMiLz4KPC9nPgo8cGF0aCBkPSJNODcgMTA4UTcwIDEyNyA2NCAxNDgiIHN0cm9rZS13aWR0aD0iMTYuNiIvPgo8cGF0aCBkPSJNODcgMTA4UTcwIDEyNyA2NCAxNDgiIHN0cm9rZT0iI0I1NkIyNSIgc3Ryb2tlLXdpZHRoPSIxNCIvPgo8cGF0aCBkPSJNMTMzIDEwOFExNTIgMTIwIDE1MSAxNDUiIHN0cm9rZS13aWR0aD0iMTYuNiIvPgo8cGF0aCBkPSJNMTMzIDEwOFExNTIgMTIwIDE1MSAxNDUiIHN0cm9rZT0iI0I1NkIyNSIgc3Ryb2tlLXdpZHRoPSIxNCIvPgo8ZyB0cmFuc2Zvcm09InRyYW5zbGF0ZSgxMTAgMCkgcm90YXRlKDAgMCAxMjYpIj4KPHBhdGggZD0iTS0xMCA5NlEtMjYgOTctMjggMTA5TC0yNCAxNThRMCAxNjMgMjYgMTU2TDI1IDEwOVEyMyA5OSAxMCA5NloiIGZpbGw9IiNCNTZCMjUiLz4KPHBhdGggZD0iTS05IDk3IDAgMTA0IDEwIDk3IDEyIDE1Ni03IDE1OVoiIGZpbGw9IiNGRkY5RUQiIHN0cm9rZT0ibm9uZSIvPgo8cGF0aCBkPSJNLTExIDk2LTIgMTA0LTEwIDEyMi0yMCAxMDhaIiBmaWxsPSIjRDU5MTRCIiBzdHJva2U9Im5vbmUiLz4KPHBhdGggZD0iTTExIDk2IDIgMTA0IDEyIDEyMSAyMSAxMDdaIiBmaWxsPSIjRDU5MTRCIiBzdHJva2U9Im5vbmUiLz4KPHBhdGggZD0iTS0xMCAxMjQtMTEgMTU0TTEzIDEyNSAxNiAxNTMiIHN0cm9rZT0iI0ZGRjlFRCIgc3Ryb2tlLXdpZHRoPSIxIiBvcGFjaXR5PSIuMjgiLz4KPC9nPgo8ZyB0cmFuc2Zvcm09InRyYW5zbGF0ZSg2MSAxNTUpIHJvdGF0ZSgtMTApIj4KPHBhdGggZD0iTS01IDNWLTRRLTUtNy0yLTdIM1E3LTcgNy0zVjNRNiA4IDEgOFEtMyA4LTUgM1oiIGZpbGw9IiNCRjgyNUIiLz4KPHBhdGggZD0iTS01IDAtMS0yUTItMyAzIDBMMCAzIiBzdHJva2U9IiM5NjVDNDAiIHN0cm9rZS13aWR0aD0iMSIvPgo8L2c+CjxnIHRyYW5zZm9ybT0idHJhbnNsYXRlKDExMCA2Nykgcm90YXRlKC02KSI+CjxyZWN0IHg9Ii02IiB5PSIxNyIgd2lkdGg9IjEyIiBoZWlnaHQ9IjE2IiByeD0iMyIgZmlsbD0iI0JGODI1QiIvPgo8cGF0aCBkPSJNLTUgMjFRMCAyNiA2IDIyVjI4UTAgMzAtNSAyN1oiIGZpbGw9IiM5NjVDNDAiIHN0cm9rZT0ibm9uZSIvPgo8ZWxsaXBzZSBjeD0iLTE2LjUiIGN5PSIzIiByeD0iMy41IiByeT0iNSIgZmlsbD0iI0JGODI1QiIvPgo8ZWxsaXBzZSBjeD0iMTYuNSIgY3k9IjMiIHJ4PSIzLjUiIHJ5PSI1IiBmaWxsPSIjQkY4MjVCIi8+CjxwYXRoIGQ9Ik0tMTYtMTJRLTE2LTI0IDAtMjRRMTYtMjQgMTYtMTJWN1ExNSAyMSAwIDI0US0xNCAyMi0xNiA4WiIgZmlsbD0iI0JGODI1QiIvPgo8cGF0aCBkPSJNLTE2IDNRLTIwLTktMTYtMTdRLTEyLTI1IDAtMjVRMTQtMjYgMTctMTZMMTYgMkgxM1YtMTJRMC04LTEyLTEyVjNaIiBmaWxsPSIjNDAzRDM1IiBzdHJva2U9IiM0MDNEMzUiLz4KPHBhdGggZD0iTS0xMS0yUS03LTQtMy0yTTQtMlE4LTQgMTItMiIgc3Ryb2tlPSIjNDAzRDM1Ii8+CjxjaXJjbGUgY3g9Ii03IiBjeT0iMyIgcj0iMS4xNSIgZmlsbD0iIzI2M0Q0OCIgc3Ryb2tlPSJub25lIi8+CjxjaXJjbGUgY3g9IjgiIGN5PSIzIiByPSIxLjE1IiBmaWxsPSIjMjYzRDQ4IiBzdHJva2U9Im5vbmUiLz4KPHBhdGggZD0iTTEgNC0xIDkgMiAxMCIgc3Ryb2tlPSIjOTY1QzQwIiBzdHJva2Utd2lkdGg9IjEuMiIvPgo8cGF0aCBkPSJNLTE0LTFILTJMLTMgNlEtOCA5LTEyIDVaTTMtMUgxNUwxMyA2UTggOSA0IDVaIiBmaWxsPSIjMjYzRDQ4Ii8+CjxwYXRoIGQ9Ik0tMiAwSDNNLTEwIDBILTZNNyAwSDExIiBzdHJva2U9IiNGRkY5RUQiIHN0cm9rZS13aWR0aD0iMSIvPgo8cGF0aCBkPSJNLTUgMTRRMCAxOSA2IDE0Ii8+CjwvZz4KPHBhdGggZD0iTTEwMSAxMDUgMTE4IDE0ME0xMzAgMTA1IDEzNiAxNDEiIHN0cm9rZS13aWR0aD0iMi41Ii8+CjxnPgo8cmVjdCB4PSIxMTEiIHk9IjEzOCIgd2lkdGg9IjM0IiBoZWlnaHQ9IjI0IiByeD0iNCIgZmlsbD0iIzI2M0Q0OCIvPgo8cmVjdCB4PSIxMTkiIHk9IjEzNCIgd2lkdGg9IjEzIiBoZWlnaHQ9IjciIHJ4PSIyIiBmaWxsPSIjMjYzRDQ4Ii8+CjxjaXJjbGUgY3g9IjEyOSIgY3k9IjE1MCIgcj0iOCIgZmlsbD0iIzZEODc5MCIgc3Ryb2tlPSJub25lIi8+CjxjaXJjbGUgY3g9IjEyOSIgY3k9IjE1MCIgcj0iNC44IiBmaWxsPSIjRkZGOUVEIiBzdHJva2U9Im5vbmUiLz4KPGNpcmNsZSBjeD0iMTMwIiBjeT0iMTQ5IiByPSIyLjIiIGZpbGw9IiM2RDg3OTAiIHN0cm9rZT0ibm9uZSIvPgo8Y2lyY2xlIGN4PSIxMTYiIGN5PSIxNDMiIHI9IjEuNSIgZmlsbD0iI0U2QjY1RCIgc3Ryb2tlPSJub25lIi8+CjwvZz4KPGcgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoMTQ5IDE1MSkgcm90YXRlKDE2KSI+CjxwYXRoIGQ9Ik0tNSAzVi00US01LTctMi03SDNRNy03IDctM1YzUTYgOCAxIDhRLTMgOC01IDNaIiBmaWxsPSIjQkY4MjVCIi8+CjxwYXRoIGQ9Ik0tNSAwLTEtMlEyLTMgMyAwTDAgMyIgc3Ryb2tlPSIjOTY1QzQwIiBzdHJva2Utd2lkdGg9IjEiLz4KPC9nPgo8cmVjdCB4PSIxNDQiIHk9IjEzOCIgd2lkdGg9IjE1IiBoZWlnaHQ9IjUiIHJ4PSIyIiBmaWxsPSIjOUI1QjIwIi8+CjxyZWN0IHg9IjE0OSIgeT0iMTM3IiB3aWR0aD0iNiIgaGVpZ2h0PSI3IiByeD0iMiIgZmlsbD0iI0ZGRjlFRCIvPgo8L2c+Cjwvc3ZnPgo=","ESFP":"data:image/svg+xml;base64,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","ENFP":"data:image/svg+xml;base64,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","ENTP":"data:image/svg+xml;base64,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","ESTJ":"data:image/svg+xml;base64,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","ESFJ":"data:image/svg+xml;base64,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","ENFJ":"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNDAgMjQwIiByb2xlPSJpbWciIGFyaWEtbGFiZWxsZWRieT0iZW5mai10aXRsZSIgYXJpYS1kZXNjcmliZWRieT0iZW5mai1kZXNjIj4KPHRpdGxlIGlkPSJlbmZqLXRpdGxlIj5FTkZKOiBUaGUgZ3VpZGUgd2VsY29taW5nIGNvbm5lY3Rpb248L3RpdGxlPgo8ZGVzYyBpZD0iZW5mai1kZXNjIj5BIHNtaWxpbmcgYmVhcmRlZCBtYWxlIGd1aWRlIGluIGEgdGVhbCBqYWNrZXQgb3BlbnMgYm90aCBoYW5kcyBpbiB3ZWxjb21lLiBBIHNtYWxsIGhlYXJ0IGluIGEgc3BlZWNoIGJ1YmJsZSByZWluZm9yY2VzIGVtcGF0aHkgYW5kIGNvbm5lY3Rpb24uPC9kZXNjPgo8Y2lyY2xlIGN4PSIxMjAiIGN5PSIxMjIiIHI9Ijg0IiBmaWxsPSIjRTRGMkVGIi8+CjxlbGxpcHNlIGN4PSIxMjAiIGN5PSIyMTYiIHJ4PSI2NSIgcnk9IjMiIGZpbGw9IiMyNjNENDgiIG9wYWNpdHk9Ii4wOCIvPgo8ZyBmaWxsPSJub25lIiBzdHJva2U9IiMyNjNENDgiIHN0cm9rZS13aWR0aD0iMS40IiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiPgo8ZyB0cmFuc2Zvcm09InRyYW5zbGF0ZSgxMTggMCkiPgo8ZyBkYXRhLXBhcnQ9ImxlZyI+CjxnIGRhdGEtcGFydD0ic2hvZSIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoLTEzIDIwNCkgcm90YXRlKDApIHNjYWxlKC0xIDEpIj4KPHBhdGggZD0iTS03LjUgLTNINy41UTcuNSAwIDkuNSAyTDE3IDQuNVEyMSA1LjUgMjEgOFYxMEgtNy41US04LjUgMTAgLTguNSA3WiIgZmlsbD0iIzI2M0Q0OCIvPgo8cGF0aCBkPSJNLTYuNSA4SDE5IiBzdHJva2U9IiNGRkY5RUQiIHN0cm9rZS13aWR0aD0iMSIgb3BhY2l0eT0iLjMyIi8+CjwvZz4KPHBhdGggZD0iTS0yMyAxNTJIMlExIDE2OC0zIDE4MEwtNS41IDIwNCBMLTIwLjUgMjA0US0yMyAxODEtMjMgMTUyWiIgZmlsbD0iIzI2M0Q0OCIgZGF0YS1wYXJ0PSJ0cm91c2VycyIvPgo8L2c+CjxnIGRhdGEtcGFydD0ibGVnIj4KPGcgZGF0YS1wYXJ0PSJzaG9lIiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgyNSAyMDQpIHJvdGF0ZSgwKSBzY2FsZSgxIDEpIj4KPHBhdGggZD0iTS03LjUgLTNINy41UTcuNSAwIDkuNSAyTDE3IDQuNVEyMSA1LjUgMjEgOFYxMEgtNy41US04LjUgMTAgLTguNSA3WiIgZmlsbD0iIzI2M0Q0OCIvPgo8cGF0aCBkPSJNLTYuNSA4SDE5IiBzdHJva2U9IiNGRkY5RUQiIHN0cm9rZS13aWR0aD0iMSIgb3BhY2l0eT0iLjMyIi8+CjwvZz4KPHBhdGggZD0iTTEgMTUySDIzUTI0IDE3MCAyNSAxODRMMzIuNSAyMDQgTDE3LjUgMjA0UTggMTg0IDMgMTczTC0xIDE2NloiIGZpbGw9IiMzNDU2NUEiIGRhdGEtcGFydD0idHJvdXNlcnMiLz4KPC9nPgo8L2c+CjxwYXRoIGQ9Ik05NSAxMDcgNzUgMTM3UTcxIDE0MyA2MyAxMzhMMzkgMTI0IiBzdHJva2Utd2lkdGg9IjE2LjYiLz4KPHBhdGggZD0iTTk1IDEwNyA3NSAxMzdRNzEgMTQzIDYzIDEzOEwzOSAxMjQiIHN0cm9rZT0iIzI2NzM3NiIgc3Ryb2tlLXdpZHRoPSIxNCIvPgo8cGF0aCBkPSJNMTQxIDEwNyAxNjYgMTM0UTE3MSAxNDAgMTc4IDEzNEwyMDAgMTE4IiBzdHJva2Utd2lkdGg9IjE2LjYiLz4KPHBhdGggZD0iTTE0MSAxMDcgMTY2IDEzNFExNzEgMTQwIDE3OCAxMzRMMjAwIDExOCIgc3Ryb2tlPSIjMjY3Mzc2IiBzdHJva2Utd2lkdGg9IjE0Ii8+CjxnIHRyYW5zZm9ybT0idHJhbnNsYXRlKDExOCAwKSByb3RhdGUoMCAwIDEyNikiPgo8cGF0aCBkPSJNLTEwIDk2US0yNiA5Ny0yOCAxMDlMLTI0IDE1OFEwIDE2MyAyNiAxNTZMMjUgMTA5UTIzIDk5IDEwIDk2WiIgZmlsbD0iIzI2NzM3NiIvPgo8cGF0aCBkPSJNLTkgOTcgMCAxMDQgMTAgOTcgMTIgMTU2LTcgMTU5WiIgZmlsbD0iI0ZGRjlFRCIgc3Ryb2tlPSJub25lIi8+CjxwYXRoIGQ9Ik0tMTEgOTYtMiAxMDQtMTAgMTIyLTIwIDEwOFoiIGZpbGw9IiM0NzkzOTIiIHN0cm9rZT0ibm9uZSIvPgo8cGF0aCBkPSJNMTEgOTYgMiAxMDQgMTIgMTIxIDIxIDEwN1oiIGZpbGw9IiM0NzkzOTIiIHN0cm9rZT0ibm9uZSIvPgo8cGF0aCBkPSJNLTEwIDEyNC0xMSAxNTRNMTMgMTI1IDE2IDE1MyIgc3Ryb2tlPSIjRkZGOUVEIiBzdHJva2Utd2lkdGg9IjEiIG9wYWNpdHk9Ii4yOCIvPgo8L2c+CjxnIHRyYW5zZm9ybT0idHJhbnNsYXRlKDMxIDEyMikgcm90YXRlKC01NykiPgo8cGF0aCBkPSJNLTQgNi03LTFRLTktNS03LTZRLTUtNy0zLTNMLTItOVEtMi0xMiAwLTExTDMtNCA2LThROC05IDktN0w3IDJRNiA3IDIgOFoiIGZpbGw9IiNCRjgyNUIiLz4KPHBhdGggZD0iTS0zLTIgMSAyIiBzdHJva2U9IiM5NjVDNDAiIHN0cm9rZS13aWR0aD0iMSIvPgo8L2c+CjxnIHRyYW5zZm9ybT0idHJhbnNsYXRlKDIwNyAxMTMpIHJvdGF0ZSg0NykiPgo8cGF0aCBkPSJNLTQgNi03LTFRLTktNS03LTZRLTUtNy0zLTNMLTItOVEtMi0xMiAwLTExTDMtNCA2LThROC05IDktN0w3IDJRNiA3IDIgOFoiIGZpbGw9IiNCRjgyNUIiLz4KPHBhdGggZD0iTS0zLTIgMSAyIiBzdHJva2U9IiM5NjVDNDAiIHN0cm9rZS13aWR0aD0iMSIvPgo8L2c+CjxnIHRyYW5zZm9ybT0idHJhbnNsYXRlKDExOCA2Nikgcm90YXRlKDApIj4KPHJlY3QgeD0iLTYiIHk9IjE3IiB3aWR0aD0iMTIiIGhlaWdodD0iMTYiIHJ4PSIzIiBmaWxsPSIjQkY4MjVCIi8+CjxwYXRoIGQ9Ik0tNSAyMVEwIDI2IDYgMjJWMjhRMCAzMC01IDI3WiIgZmlsbD0iIzk2NUM0MCIgc3Ryb2tlPSJub25lIi8+CjxlbGxpcHNlIGN4PSItMTYuNSIgY3k9IjMiIHJ4PSIzLjUiIHJ5PSI1IiBmaWxsPSIjQkY4MjVCIi8+CjxlbGxpcHNlIGN4PSIxNi41IiBjeT0iMyIgcng9IjMuNSIgcnk9IjUiIGZpbGw9IiNCRjgyNUIiLz4KPHBhdGggZD0iTS0xNi0xMlEtMTYtMjQgMC0yNFExNi0yNCAxNi0xMlY3UTE1IDIxIDAgMjRRLTE0IDIyLTE2IDhaIiBmaWxsPSIjQkY4MjVCIi8+CjxwYXRoIGQ9Ik0tMTYgNFEtMjMgMC0yMC03US0yNS0xNC0xOC0xOFEtMjEtMjYtMTEtMjZRLTUtMzMgMi0yOFExMC0zMyAxNS0yNlEyNC0yNSAyMC0xN1EyNS0xMCAxOC01TDE1IDMgMTItN1E1LTQgMC0xMFEtNS01LTEyLTdMLTEyIDRaIiBmaWxsPSIjMzgzOTMyIiBzdHJva2U9IiMzODM5MzIiLz4KPHBhdGggZD0iTS0xNSA2LTEwIDEwLTUgMTAgMCA4IDYgMTAgMTEgOSAxNSA1IDEzIDE2UTggMjQgMCAyNFEtMTAgMjItMTQgMTVaIiBmaWxsPSIjMzgzOTMyIiBzdHJva2U9IiMzODM5MzIiLz4KPHBhdGggZD0iTS0xMS0yUS03LTQtMy0yTTQtMlE4LTQgMTItMiIgc3Ryb2tlPSIjMzgzOTMyIi8+CjxjaXJjbGUgY3g9Ii03IiBjeT0iMyIgcj0iMS4xNSIgZmlsbD0iIzI2M0Q0OCIgc3Ryb2tlPSJub25lIi8+CjxjaXJjbGUgY3g9IjgiIGN5PSIzIiByPSIxLjE1IiBmaWxsPSIjMjYzRDQ4IiBzdHJva2U9Im5vbmUiLz4KPHBhdGggZD0iTTEgNC0xIDkgMiAxMCIgc3Ryb2tlPSIjOTY1QzQwIiBzdHJva2Utd2lkdGg9IjEuMiIvPgo8cGF0aCBkPSJNLTUgMTRRMCAxOSA2IDE0IiBzdHJva2U9IiNGRkY5RUQiLz4KPC9nPgo8Zz4KPHBhdGggZD0iTTE2OSA0MUgxOTZRMjA1IDQxIDIwNSA1MFY2NVEyMDUgNzMgMTk2IDczSDE4MkwxNzMgODFWNzNIMTY5UTE2MSA3MyAxNjEgNjVWNTBRMTYxIDQxIDE2OSA0MVoiIGZpbGw9IiMyNjczNzYiIHN0cm9rZT0ibm9uZSIvPgo8cGF0aCBkPSJNMTc1IDU0UTE3OCA0OSAxODMgNTRRMTg5IDQ5IDE5MiA1NFExOTQgNTkgMTgzIDY2UTE3MiA2MCAxNzUgNTRaIiBmaWxsPSIjRkZGOUVEIiBzdHJva2U9Im5vbmUiLz4KPC9nPgo8L2c+Cjwvc3ZnPgo=","ENTJ":"data:image/svg+xml;base64,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"};
const MBTI_PALETTES = {"INTJ":{"accent":"#43558B","soft":"#EBEDF7","darkAccent":"#AFBAF4","darkSoft":"#252D49"},"INTP":{"accent":"#745F8B","soft":"#F0EBF5","darkAccent":"#CEB4E6","darkSoft":"#362A43"},"ENTJ":{"accent":"#933F56","soft":"#F7E9ED","darkAccent":"#F2A9BA","darkSoft":"#482935"},"ENTP":{"accent":"#A4502B","soft":"#F9ECDF","darkAccent":"#F5B48C","darkSoft":"#493124"},"INFJ":{"accent":"#3B6C59","soft":"#E7F1EB","darkAccent":"#9ED4B7","darkSoft":"#263D33"},"INFP":{"accent":"#5E7034","soft":"#EFF2E2","darkAccent":"#C6D598","darkSoft":"#363D25"},"ENFJ":{"accent":"#267376","soft":"#E4F2EF","darkAccent":"#98DADB","darkSoft":"#203D40"},"ENFP":{"accent":"#89641B","soft":"#FBF2D8","darkAccent":"#EAC66F","darkSoft":"#443921"},"ISTJ":{"accent":"#476778","soft":"#E8EFF3","darkAccent":"#ABCADB","darkSoft":"#293942"},"ISFJ":{"accent":"#9A5263","soft":"#F7EAEE","darkAccent":"#EDB3C2","darkSoft":"#472D37"},"ESTJ":{"accent":"#345A8B","soft":"#E7EEF7","darkAccent":"#A9C7F2","darkSoft":"#26354B"},"ESFJ":{"accent":"#A1503E","soft":"#FAEAE3","darkAccent":"#F3B29C","darkSoft":"#4B302A"},"ISTP":{"accent":"#317469","soft":"#E4F2EE","darkAccent":"#98D6C8","darkSoft":"#243F38"},"ISFP":{"accent":"#795B98","soft":"#F2EAF9","darkAccent":"#D3B6F1","darkSoft":"#3B2D4C"},"ESTP":{"accent":"#9B5B20","soft":"#FFF0DE","darkAccent":"#F7C286","darkSoft":"#4C3724"},"ESFP":{"accent":"#A3477A","soft":"#F9E9F2","darkAccent":"#F0AED4","darkSoft":"#492C40"}};</script>
<script>/* Shared by the standalone page and Node verification. No fitted persona weights. */
(function (root) {
  'use strict';
  const axes = [
    { id: 'EI', title: 'מאיפה מגיעה האנרגיה', labels: ['מוחצן', 'מופנם'], explanations: ['מפגש עם אנשים ועיבוד בקול', 'מרחב אישי ועיבוד פנימי'] },
    { id: 'SN', title: 'איך קולטים את העולם', labels: ['קונקרטי', 'עיוני'], explanations: ['פרטים מוחשיים וניסיון ישיר', 'דפוסים, רעיונות ואפשרויות'] },
    { id: 'TF', title: 'מה מנחה החלטות', labels: ['שכלתני', 'רגשי'], explanations: ['עקביות, עקרונות ושיקולים ענייניים', 'ערכים אישיים וההשפעה על אנשים'] },
    { id: 'JP', title: 'איך ניגשים לחיי היום-יום', labels: ['גבולני', 'פתוח'], explanations: ['מסגרת, תכנון וסגירת קצוות', 'גמישות, התאמה והשארת אפשרויות'] }
  ];
  const hebrew = { E: 'ח', I: 'מ', S: 'ק', N: 'ע', T: 'ש', F: 'ר', J: 'ג', P: 'פ', X: '?' };
  function score(questions, answers) {
    if (!Array.isArray(answers) || answers.length !== questions.length || Array.from(answers).some(a => !Number.isInteger(a) || a < 1 || a > 5)) {
      throw new Error('יש להשיב על כל השאלות בתשובות בין 1 ל-5');
    }
    const results = axes.map(axis => {
      let sum = 0, count = 0, neutral = 0, first = 0, second = 0;
      questions.forEach((q, i) => {
        if (q.axis !== axis.id) return;
        const value = (3 - answers[i]) * (q.aPole === axis.id[0] ? 1 : -1);
        sum += value; count++;
        if (!value) neutral++; else if (value > 0) first++; else second++;
      });
      if (!count) throw new Error('Missing axis: ' + axis.id);
      const normalized = sum / (count * 2);
      const firstPercent = Math.round(50 + 50 * normalized);
      return { ...axis, sum, count, neutral, first, second, normalized, firstPercent,
        secondPercent: 100 - firstPercent, letter: sum === 0 ? 'X' : sum > 0 ? axis.id[0] : axis.id[1],
        close: Math.abs(normalized) <= 0.25,
        label: sum === 0 ? 'ללא העדפה מכריעה' : Math.abs(normalized) <= 0.25 ? 'נטייה קלה' : Math.abs(normalized) <= 0.6 ? 'נטייה בינונית' : 'נטייה בולטת' };
    });
    const code = results.map(a => a.letter).join('');
    const candidates = results.reduce((codes, a) => codes.flatMap(c => (a.close ? [...a.id] : [a.letter]).map(l => c + l)), ['']);
    candidates.sort((a, b) => distance(a) - distance(b) || a.localeCompare(b));
    function distance(type) { return results.reduce((total, axis, i) => total + (1 - (type[i] === axis.id[0] ? 1 : -1) * axis.normalized), 0); }
    return { code, hebrewCode: [...code].map(c => hebrew[c]).join(''), axes: results, candidates,
      neutralCount: answers.filter(a => a === 3).length,
      straightLine: new Set(answers).size === 1 };
  }
  const api = { axes, hebrew, score };
  if (typeof module !== 'undefined' && module.exports) module.exports = api;
  else root.MBTI = api;
})(typeof globalThis !== 'undefined' ? globalThis : this);
</script>
<script>(() => {
  'use strict';
  const $ = id => document.getElementById(id);
  const questions = MBTI_DATA.questions;
  const key = 'nhlocal.16-types.v1';
  const themeKey = 'nhlocal.16-types.theme';
  const systemTheme = matchMedia('(prefers-color-scheme: dark)');
  let explicitTheme = null;
  try { const saved = localStorage.getItem(themeKey); if (saved === 'light' || saved === 'dark') explicitTheme = saved; } catch {}
  function applyTheme(theme) {
    document.documentElement.dataset.theme = theme;
    const dark = theme === 'dark';
    $('theme-toggle').setAttribute('aria-pressed', String(dark));
    $('theme-toggle').title = dark ? 'מעבר למצב בהיר' : 'מעבר למצב אפל';
    $('theme-color').content = dark ? '#171d28' : '#fcf7f1';
  }
  applyTheme(explicitTheme || (systemTheme.matches ? 'dark' : 'light'));
  $('theme-toggle').addEventListener('click', () => {
    explicitTheme = document.documentElement.dataset.theme === 'dark' ? 'light' : 'dark';
    applyTheme(explicitTheme);
    try { localStorage.setItem(themeKey, explicitTheme); } catch {}
  });
  systemTheme.addEventListener('change', event => { if (!explicitTheme) applyTheme(event.matches ? 'dark' : 'light'); });
  const optionLabels = ["בבירור א'", "נוטה ל-א'", 'לא ברור', "נוטה ל-ב'", "בבירור ב'"];
  const fullLabels = ["בבירור א', העדפה ברורה לאפשרות א'", "נוטה ל-א', העדפה קלה לאפשרות א'", 'לא ברור, אין העדפה ברורה בין האפשרויות', "נוטה ל-ב', העדפה קלה לאפשרות ב'", "בבירור ב', העדפה ברורה לאפשרות ב'"];
  let answers = Array(questions.length).fill(null), current = 0, screen = 'welcome', returnToReview = false, result = null, storageWorks = true, resetStartsQuiz = false, toastTimer;
  const esc = value => String(value).replace(/[&<>"']/g, char => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[char]));
  const answered = () => answers.filter(a => a !== null).length;
  function storageFailure() {
    storageWorks = false;
    $('storage-status').hidden = false;
    $('storage-status').textContent = 'השמירה בדפדפן אינה זמינה כרגע. אפשר להמשיך, אבל רענון או סגירה של הדף עלולים למחוק את ההתקדמות';
    $('pause').textContent = 'יציאה מהשאלון';
  }
  function load() {
    try {
      const raw = localStorage.getItem(key);
      if (!raw) return;
      const saved = JSON.parse(raw);
      if (!saved || saved.version !== MBTI_DATA.revision || !Array.isArray(saved.answers) || saved.answers.length !== questions.length || !saved.answers.every(a => a === null || (Number.isInteger(a) && a >= 1 && a <= 5)) || !Number.isInteger(saved.current) || saved.current < 0 || saved.current >= questions.length) {
        localStorage.removeItem(key); return;
      }
      answers = saved.answers; current = saved.current;
    } catch (error) {
      if (error instanceof SyntaxError) { try { localStorage.removeItem(key); } catch { storageFailure(); } }
      else storageFailure();
    }
  }
  function save() {
    if (!storageWorks) return;
    try { localStorage.setItem(key, JSON.stringify({version: MBTI_DATA.revision, answers, current})); }
    catch { storageFailure(); }
  }
  function show(id, focusId) {
    screen = id;
    ['welcome','quiz','review','results'].forEach(name => { $(name).hidden = name !== id; });
    if (focusId) $(focusId).focus({preventScroll:true});
    window.scrollTo({top:0,behavior:'instant'});
  }
  function welcome() {
    const count = answered();
    $('start').hidden = count > 0;
    $('resume').hidden = count === 0;
    $('fresh').hidden = count === 0;
    $('resume').querySelector('span').textContent = count === questions.length ? 'חזרה לתוצאה שלי' : 'להמשיך מאיפה שעצרתי';
    show('welcome');
  }
  function updateProgress() {
    $('progress').max = questions.length;
    $('progress').value = answered();
    $('progress-text').textContent = `${answered()} מתוך ${questions.length} נענו`;
  }
  function renderQuestion() {
    const q = questions[current], chapter = Math.floor(current / 8);
    $('chapter-label').textContent = `פרק ${chapter + 1} מתוך ${MBTI_DATA.chapters.length} · ${MBTI_DATA.chapters[chapter]}`;
    $('question-counter').textContent = `שאלה ${current + 1} מתוך ${questions.length}`;
    $('question-heading').textContent = q.text;
    $('option-a').textContent = q.a; $('option-b').textContent = q.b;
    $('answer-options').innerHTML = optionLabels.map((label, i) => `<label class="answer-choice"><input type="radio" name="answer" value="${i+1}" aria-label="${esc(fullLabels[i])}" ${answers[current] === i+1 ? 'checked' : ''}><span><i aria-hidden="true"></i>${label}</span></label>`).join('');
    $('previous').disabled = current === 0;
    $('next').querySelector('span').textContent = returnToReview ? 'שמירה וחזרה למפה' : current === questions.length - 1 ? 'לתוצאות' : 'הבא';
    $('answer-error').hidden = true;
    updateProgress(); save();
    show('quiz', 'question-heading');
    $('announcement').textContent = `שאלה ${current+1} מתוך ${questions.length}. ${MBTI_DATA.chapters[chapter]}`;
  }
  function start() { current = 0; returnToReview = false; renderQuestion(); }
  function review() {
    $('review-count').textContent = `${answered()} מתוך ${questions.length} שאלות נענו`;
    $('review-list').innerHTML = MBTI_DATA.chapters.map((chapter, c) => `<section class="review-group"><h3>${c+1}. ${esc(chapter)}</h3>${questions.slice(c*8,c*8+8).map(q => {
      const a = answers[q.id-1];
      return `<button class="review-question" data-index="${q.id-1}"><b>${q.id}.</b> ${esc(q.text)}<small>${a === null ? 'עדיין לא נענתה' : esc(fullLabels[a-1]) + (a === 3 ? '' : ': ' + esc(a < 3 ? q.a : q.b))}</small></button>`;
    }).join('')}</section>`).join('');
    $('review-finish').querySelector('span').textContent = answered() === questions.length ? 'לתוצאות' : `להמשיך לשאלות שנותרו (${questions.length - answered()})`;
    show('review', 'review-heading');
  }
  function typeStyle(code) {
    const p = MBTI_PALETTES[code];
    return p ? `--type-light-accent:${p.accent};--type-light-soft:${p.soft};--type-dark-accent:${p.darkAccent};--type-dark-soft:${p.darkSoft}` : '';
  }
  function profileHTML(code, preview = false) {
    const p = MBTI_PROFILES[code];
    const words = [...code].map((letter,i) => MBTI.axes[i].labels[MBTI.axes[i].id.indexOf(letter)]).join(' · ');
    return `<div class="type-profile ${preview ? 'preview-card' : ''}" style="${typeStyle(code)}"><div class="profile-top"><div class="profile-identity"><div class="profile-codes"><bdi class="type-code">${code}</bdi><span class="he-code">${p.he}</span></div><h3 class="profile-name">${esc(p.name)}</h3><p>${words}</p></div><img class="profile-character" src="${MBTI_ILLUSTRATIONS[code]}" alt="" width="210" height="210"></div><p>${esc(p.description)}</p><h4>העדפות וחוזקות אפשריות</h4><ul>${p.strengths.map(s => `<li>${esc(s)}</li>`).join('')}</ul><h4>נקודה למחשבה</h4><p>${esc(p.stretch)}</p><h4>בקשרים עם אנשים</h4><p>${esc(p.relationships)}</p><h4>בלמידה ובעשייה</h4><p>${esc(p.work)}</p><div class="experiment"><h4>אפשר לנסות השבוע</h4><p>${esc(p.experiment)}</p></div></div>`;
  }
  function typeButton(code) {
    const p = MBTI_PROFILES[code];
    return `<button type="button" class="type-chip" style="${typeStyle(code)}" data-type="${code}" aria-pressed="false" aria-controls="type-preview"><img class="type-character" src="${MBTI_ILLUSTRATIONS[code]}" alt="" width="96" height="96" loading="lazy"><span class="type-chip-codes"><bdi dir="ltr">${code}</bdi><span>${p.he}</span></span><span class="type-chip-name">${esc(p.name)}</span></button>`;
  }
  function previewType(code) {
    document.querySelectorAll('[data-type]').forEach(button => button.setAttribute('aria-pressed', String(button.dataset.type === code)));
    $('type-preview').innerHTML = profileHTML(code, true);
  }
  function results() {
    if (answered() !== questions.length) { current = answers.indexOf(null); returnToReview = false; renderQuestion(); return; }
    result = MBTI.score(questions, answers);
    const tied = result.code.includes('X');
    $('results').style.cssText = typeStyle(result.code);
    $('result-heading').textContent = tied ? 'לא התקבלה העדפה בכל הצירים' : `הכיוון שלך: ${MBTI_PROFILES[result.code].name}`;
    $('result-subtitle').textContent = tied ? 'בחלק מהצירים אין כרגע העדפה מכריעה. אפשר לעיין בפירוט ולהשוות בין התיאורים' : 'הפרופיל שעולה מהתשובות שלך';
    $('profile-card').innerHTML = tied ? `<div class="profile-top"><bdi class="type-code">${result.code}</bdi></div><h3>אין טיפוס יחיד בתוצאה הזו</h3><p>האות X מסמנת ציר שבו התקבל שוויון. לא בחרנו עבורך צד שרירותי, ולכן אין כאן תיאור של טיפוס יחיד.</p><p>אפשר לעיין בצירופים המוצעים בהמשך, ולחשוב איזו העדפה חוזרת בחיים שלך כשיש חופש לבחור.</p><div class="experiment"><h4>אפשר לנסות השבוע</h4><p>לתעד שלושה רגעים של בחירה חופשית: מה בחרת, למה, והאם זו הייתה העדפה או דרישה של המצב.</p></div>` : profileHTML(result.code);
    $('axis-results').innerHTML = result.axes.map(a => {
      const winner = a.id.indexOf(a.letter);
      const percentages = [a.firstPercent, a.secondPercent];
      const emphasis = i => i === winner ? ' is-dominant' : '';
      const summary = winner < 0 ? 'אין העדפה לצד מסוים' : `${a.close ? 'נטייה קלה' : 'הנטייה שלך'}: ${a.labels[winner]}`;
      return `<section class="axis-row"><div class="axis-title"><b>${a.title}</b></div><div class="axis-labels">${a.labels.map((label,i) => `<div class="axis-pole${emphasis(i)}"><strong>${label}</strong><bdi dir="ltr">${a.id[i]} · ${percentages[i]}%</bdi></div>`).join('')}</div><div class="axis-bar" role="img" aria-label="${a.labels[0]} ${a.firstPercent} אחוז, ${a.labels[1]} ${a.secondPercent} אחוז">${percentages.map((value,i) => `<i class="${emphasis(i).trim()}" style="width:${value}%"></i>`).join('')}</div><p class="axis-explain"><strong>${summary}</strong>${winner < 0 ? '' : `<br>${a.explanations[winner]}`}</p></section>`;
    }).join('');
    const notices = [];
    if (result.neutralCount >= questions.length / 2) notices.push('בחלק גדול מהשאלות נבחר האמצע. ייתכן ששתי האפשרויות מתאימות לך או שההעדפות משתנות בין מצבים. כדאי לתת לתיאורים משקל מוגבל');
    if (result.straightLine && result.neutralCount === 0) notices.push('נבחרה אותה עמדה בכל השאלות. מכיוון שכיוון האפשרויות מתחלף, התוצאה מאוזנת. כדאי לעבור על התשובות ולבדוק שהבחירות מבטאות את ההעדפות שלך');
    const close = result.axes.filter(a => a.close);
    if (close.length && !tied) notices.push(`בצירים ${close.map(a=>a.labels.join(' / ')).join(', ')} הנטייה קרובה לאמצע. שינוי בכמה תשובות עשוי לשנות את האות המתאימה`);
    $('result-notice').hidden = notices.length === 0;
    $('result-notice').innerHTML = notices.map(n => `<p>${esc(n)}</p>`).join('');
    const nearby = result.candidates.filter(c => c !== result.code);
    $('nearby').hidden = nearby.length === 0;
    $('nearby-explanation').textContent = 'בצירים הקרובים לאמצע כדאי להשוות גם לתיאורים האלה';
    $('nearby-types').innerHTML = nearby.map(typeButton).join('');
    $('type-picker').innerHTML = Object.keys(MBTI_PROFILES).map(typeButton).join('');
    previewType(tied ? result.candidates[0] : result.code);
    save(); show('results', 'result-heading');
  }
  function resultText() {
    const lines = ['16 הטיפוסים | שאלון עצמאי להיכרות עצמית', '', `הצירוף: ${result.code} (${result.hebrewCode})`];
    if (MBTI_PROFILES[result.code]) {
      const p = MBTI_PROFILES[result.code];
      lines.push(p.name, '', p.description, '', 'חוזקות אפשריות:', ...p.strengths.map(s=>'• '+s), '', 'נקודה למחשבה:',p.stretch,'','בקשרים:',p.relationships,'','בלמידה ובעשייה:',p.work,'','ניסוי קטן:',p.experiment);
    } else lines.push('X מסמן שוויון בציר. לא נבחר טיפוס יחיד');
    lines.push('', 'ההעדפות שלך בארבעת התחומים:');
    result.axes.forEach(a => lines.push(`${a.labels[0]} ${a.firstPercent}% | ${a.labels[1]} ${a.secondPercent}% (${a.label})`));
    if (result.candidates.length > 1) lines.push('', 'צירופים להשוואה: ' + result.candidates.join(', '));
    if (!$('result-notice').hidden) lines.push('', $('result-notice').textContent);
    lines.push('', 'האחוזים הם ציוני נטייה מהתשובות, לא הסתברות או מדד ליכולת. שאלון זה אינו מבחן MBTI רשמי ולא עבר תיקוף פסיכומטרי. התוצאה אינה אבחון.', `גרסת שאלון: ${MBTI_DATA.revision}`);
    return lines.join('\n');
  }
  function toast(message) { $('toast').textContent = message; $('toast').hidden = false; clearTimeout(toastTimer); toastTimer = setTimeout(() => {$('toast').hidden = true;}, 5000); }
  function askReset(startAfter) {
    resetStartsQuiz = startAfter;
    $('reset-dialog').setAttribute('aria-labelledby','reset-title');
    $('confirm-reset').textContent = startAfter ? 'למחוק ולהתחיל מחדש' : 'למחוק את התשובות';
    $('reset-dialog').showModal();
  }
  $('start').addEventListener('click',start);
  $('resume').addEventListener('click',()=>{ returnToReview=false; answered()===questions.length ? results() : renderQuestion(); });
  $('pause').addEventListener('click',()=>{save();welcome();$('resume').focus();});
  $('answer-options').addEventListener('change',event=>{ if(event.target.name !== 'answer') return; answers[current]=Number(event.target.value);$('answer-error').hidden=true;save();updateProgress();});
  $('quiz-form').addEventListener('submit',event=>{
    event.preventDefault();
    if(answers[current]===null){$('answer-error').hidden=false;$('answer-options').querySelector('input').focus();return;}
    if(returnToReview){returnToReview=false;review();return;}
    if(current===questions.length-1){results();return;}
    current++;renderQuestion();
  });
  $('previous').addEventListener('click',()=>{if(current>0){current--;renderQuestion();}});
  $('review-link').addEventListener('click',review);
  $('review-list').addEventListener('click',event=>{const button=event.target.closest('[data-index]');if(!button)return;current=Number(button.dataset.index);returnToReview=true;renderQuestion();});
  $('review-back').addEventListener('click',()=>{returnToReview=false;renderQuestion();});
  $('review-finish').addEventListener('click',results);
  $('edit').addEventListener('click',review);
  $('type-picker').addEventListener('click', event => {
    const button = event.target.closest('[data-type]');
    if (!button) return;
    previewType(button.dataset.type);
    $('type-preview').focus({preventScroll:true});
    $('type-preview').scrollIntoView({block:'start',behavior:'instant'});
  });
  $('nearby-types').addEventListener('click',event=>{const button=event.target.closest('[data-type]');if(!button)return;document.querySelector('.explore').open=true;previewType(button.dataset.type);$('type-preview').focus({preventScroll:true});$('type-preview').scrollIntoView({block:'start',behavior:'instant'});});
  $('download').addEventListener('click',()=>{const blob=new Blob(['\ufeff'+resultText()],{type:'text/plain;charset=utf-8'});const url=URL.createObjectURL(blob);const link=document.createElement('a');link.href=url;link.download=`16-types-${result.code}.txt`;document.body.appendChild(link);link.click();link.remove();setTimeout(()=>URL.revokeObjectURL(url),1000);toast('הסיכום מוכן להורדה');});
  $('copy').addEventListener('click',async()=>{try{await navigator.clipboard.writeText(resultText());toast('הסיכום הועתק');}catch{toast('ההעתקה אינה זמינה בדפדפן הזה. אפשר לשמור את התוצאה כקובץ');}});
  $('print').addEventListener('click',()=>window.print());
  $('fresh').addEventListener('click',()=>askReset(true));
  $('restart').addEventListener('click',()=>askReset(true));
  $('erase').addEventListener('click',()=>askReset(false));
  $('cancel-reset').addEventListener('click',()=>$('reset-dialog').close());
  $('confirm-reset').addEventListener('click',()=>{
    let removed=true;
    try{localStorage.removeItem(key);}catch{removed=false;storageFailure();}
    answers=Array(questions.length).fill(null);current=0;result=null;returnToReview=false;
    $('reset-dialog').close();
    if(resetStartsQuiz)start();else{welcome();$('start').focus();}
    toast(removed?'התשובות הקודמות נמחקו':'התשובות אופסו בדף. מחיקת האחסון חסומה; אפשר לנקות את נתוני האתר בהגדרות הדפדפן');
  });
  $('about-toggle').addEventListener('click',()=>{const open=$('method').hidden;$('method').hidden=!open;$('about-toggle').setAttribute('aria-expanded',String(open));});
  load(); welcome();
})();
</script>
</body>
</html>
"; diff --git a/assets/illustrations/16-types/ENFJ.svg b/assets/illustrations/16-types/ENFJ.svg index 076e53c..ffcad32 100644 --- a/assets/illustrations/16-types/ENFJ.svg +++ b/assets/illustrations/16-types/ENFJ.svg @@ -5,15 +5,19 @@ - - - - - - - - - + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/ENFP.svg b/assets/illustrations/16-types/ENFP.svg index ab4b174..47f718d 100644 --- a/assets/illustrations/16-types/ENFP.svg +++ b/assets/illustrations/16-types/ENFP.svg @@ -4,15 +4,19 @@ - - - - - - - - - + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/ENTJ.svg b/assets/illustrations/16-types/ENTJ.svg index ee7e720..d1be5d9 100644 --- a/assets/illustrations/16-types/ENTJ.svg +++ b/assets/illustrations/16-types/ENTJ.svg @@ -6,15 +6,19 @@ - - - - - - - - - + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/ENTP.svg b/assets/illustrations/16-types/ENTP.svg index 41891f9..8728efc 100644 --- a/assets/illustrations/16-types/ENTP.svg +++ b/assets/illustrations/16-types/ENTP.svg @@ -4,15 +4,19 @@ - - - - - - - - - + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/ESFJ.svg b/assets/illustrations/16-types/ESFJ.svg index a95055b..14d7fff 100644 --- a/assets/illustrations/16-types/ESFJ.svg +++ b/assets/illustrations/16-types/ESFJ.svg @@ -5,15 +5,19 @@ - - - - - - - - - + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/ESFP.svg b/assets/illustrations/16-types/ESFP.svg index 50b39e5..d012dd7 100644 --- a/assets/illustrations/16-types/ESFP.svg +++ b/assets/illustrations/16-types/ESFP.svg @@ -4,15 +4,21 @@ - - - - - + + + + + - - - + + + + + + + + + @@ -55,6 +61,5 @@ - diff --git a/assets/illustrations/16-types/ESTJ.svg b/assets/illustrations/16-types/ESTJ.svg index 78a4409..ef5e374 100644 --- a/assets/illustrations/16-types/ESTJ.svg +++ b/assets/illustrations/16-types/ESTJ.svg @@ -5,15 +5,19 @@ - - - - - + + + + - - - + + + + + + + + diff --git a/assets/illustrations/16-types/ESTP.svg b/assets/illustrations/16-types/ESTP.svg index e2f8c47..4fabbcc 100644 --- a/assets/illustrations/16-types/ESTP.svg +++ b/assets/illustrations/16-types/ESTP.svg @@ -6,15 +6,19 @@ - - - - - + + + + - - - + + + + + + + + diff --git a/assets/illustrations/16-types/INFJ.svg b/assets/illustrations/16-types/INFJ.svg index 884727a..b893227 100644 --- a/assets/illustrations/16-types/INFJ.svg +++ b/assets/illustrations/16-types/INFJ.svg @@ -5,15 +5,19 @@ - - - - - - - - - + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/INFP.svg b/assets/illustrations/16-types/INFP.svg index 46fc0e5..24a4990 100644 --- a/assets/illustrations/16-types/INFP.svg +++ b/assets/illustrations/16-types/INFP.svg @@ -6,15 +6,19 @@ - - - - - - - - - + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/INTJ.svg b/assets/illustrations/16-types/INTJ.svg index bb8abc4..2c876b5 100644 --- a/assets/illustrations/16-types/INTJ.svg +++ b/assets/illustrations/16-types/INTJ.svg @@ -5,15 +5,19 @@ - - - - - + + + + - - - + + + + + + + + diff --git a/assets/illustrations/16-types/INTP.svg b/assets/illustrations/16-types/INTP.svg index c3bd350..fe22087 100644 --- a/assets/illustrations/16-types/INTP.svg +++ b/assets/illustrations/16-types/INTP.svg @@ -6,15 +6,19 @@ - - - - - + + + + - - - + + + + + + + + diff --git a/assets/illustrations/16-types/ISFJ.svg b/assets/illustrations/16-types/ISFJ.svg index 2be4c6e..94af867 100644 --- a/assets/illustrations/16-types/ISFJ.svg +++ b/assets/illustrations/16-types/ISFJ.svg @@ -5,15 +5,19 @@ - - - - - - - - - + + + + + + + + + + + + + diff --git a/assets/illustrations/16-types/ISFP.svg b/assets/illustrations/16-types/ISFP.svg index ee0214c..b543602 100644 --- a/assets/illustrations/16-types/ISFP.svg +++ b/assets/illustrations/16-types/ISFP.svg @@ -6,15 +6,19 @@ - - - - - + + + + - - - + + + + + + + + diff --git a/assets/illustrations/16-types/ISTJ.svg b/assets/illustrations/16-types/ISTJ.svg index dce331b..146fc91 100644 --- a/assets/illustrations/16-types/ISTJ.svg +++ b/assets/illustrations/16-types/ISTJ.svg @@ -5,15 +5,19 @@ - - - - - + + + + - - - + + + + + + + + diff --git a/assets/illustrations/16-types/ISTP.svg b/assets/illustrations/16-types/ISTP.svg index 0df9b1f..dd70104 100644 --- a/assets/illustrations/16-types/ISTP.svg +++ b/assets/illustrations/16-types/ISTP.svg @@ -4,15 +4,19 @@ - - - - - - - - - + + + + + + + + + + + + + diff --git a/tools/the_16_types.html b/tools/the_16_types.html index 6f018af..e70d09a 100644 --- a/tools/the_16_types.html +++ b/tools/the_16_types.html @@ -564,7 +564,7 @@

למחוק את התשובות?

התשובות והתוצאה השמורות בדפדפן הזה יימחקו. אפשר לבטל ולהמשיך מהמצב הקיים.