<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>輪郭 &#8211; Tranquilvæj</title>
	<atom:link href="https://tranquilguides.com/tag/outline/feed/" rel="self" type="application/rss+xml" />
	<link>https://tranquilguides.com</link>
	<description>記憶と身体、時間と不在をめぐる体験</description>
	<lastBuildDate>Sat, 12 Sep 2026 07:39:56 +0000</lastBuildDate>
	<language>ja</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.1.4</generator>

<image>
	<url>https://i0.wp.com/tranquilguides.com/wp-content/uploads/2026/01/cropped-IMG_3364.jpeg?fit=32%2C32&#038;ssl=1</url>
	<title>輪郭 &#8211; Tranquilvæj</title>
	<link>https://tranquilguides.com</link>
	<width>32</width>
	<height>32</height>
</image> 
<site xmlns="com-wordpress:feed-additions:1">251661265</site>	<item>
		<title>行動の輪郭診断</title>
		<link>https://tranquilguides.com/behavior-outline/</link>
					<comments>https://tranquilguides.com/behavior-outline/#respond</comments>
		
		<dc:creator><![CDATA[案内人のアシカ]]></dc:creator>
		<pubDate>Tue, 21 Jul 2026 13:25:19 +0000</pubDate>
				<category><![CDATA[生存ログ]]></category>
		<category><![CDATA[自己]]></category>
		<category><![CDATA[行動]]></category>
		<category><![CDATA[診断]]></category>
		<category><![CDATA[輪郭]]></category>
		<guid isPermaLink="false">https://tranquilguides.com/?p=1562</guid>

					<description><![CDATA[<p><img src="https://i0.wp.com/tranquilguides.com/wp-content/uploads/2026/07/unconscious-behavior-diagnosis-featured.jpg?fit=1024%2C576&ssl=1" class="webfeedsFeaturedVisual" /></p>気づけば、いつもしていること。24問を通して、日常で無意識に繰り返している行動を20の傾向と行動マップで静かに可視化します。]]></description>
										<content:encoded><![CDATA[<p><img src="https://i0.wp.com/tranquilguides.com/wp-content/uploads/2026/07/unconscious-behavior-diagnosis-featured.jpg?fit=1024%2C576&ssl=1" class="webfeedsFeaturedVisual" /></p>
<!-- Tranquil Guides｜無意識な行動診断（カスタムHTMLブロック用） -->
<style>

    /* =========================================================
       Tranquil Guides / Unconscious Action Diagnosis
       Standalone + WordPress-friendly scoped styles
       ========================================================= */
    #tg-uda {
      --bg: #efeee9;
      --paper: #f8f7f2;
      --paper-strong: #fffefa;
      --ink: #232522;
      --muted: #74766f;
      --line: #d8d8d0;
      --accent: #6d7869;
      --accent-dark: #4e584b;
      --soft: #e6e8e1;
      --focus: #253627;
      --danger: #8a3d39;
      --shadow: 0 24px 70px rgba(25, 30, 24, 0.08);
      --radius: 26px;
      color: var(--ink);
      font-family:
        -apple-system, BlinkMacSystemFont, "Hiragino Sans",
        "Hiragino Kaku Gothic ProN", "Yu Gothic", "Meiryo", sans-serif;
      line-height: 1.8;
      text-rendering: optimizeLegibility;
      -webkit-font-smoothing: antialiased;
    }


    /* WordPress/SWELLのブロック外余白を打ち消し、診断本体だけを表示 */
    #tg-uda {
      display: block;
      width: 100%;
      margin: 0 !important;
      padding: 0 !important;
    }

    #tg-uda > .tg-app,
    #tg-uda .tg-wrap,
    #tg-uda .tg-shell,
    #tg-uda .tg-screen {
      margin-bottom: 0 !important;
    }

    #tg-uda + p:empty,
    #tg-uda + .wp-block-spacer,
    .wp-block-html:has(#tg-uda) + .wp-block-spacer {
      display: none !important;
    }

    #tg-uda,
    #tg-uda *,
    #tg-uda *::before,
    #tg-uda *::after {
      box-sizing: border-box;
    }

    #tg-uda button {
      font: inherit;
    }

    #tg-uda button,
    #tg-uda a {
      -webkit-tap-highlight-color: transparent;
    }

    #tg-uda [hidden] {
      display: none !important;
    }

    #tg-uda .tg-app {
      margin: 0;
      padding: 0;
      background: transparent;
    }

    #tg-uda .tg-wrap {
      width: 100%;
      margin: 0;
    }

    #tg-uda .tg-shell {
      overflow: hidden;
      border: 0;
      border-radius: 0;
      background: transparent;
      box-shadow: none;
      backdrop-filter: none;
    }

    #tg-uda .tg-screen {
      display: none;
      padding: clamp(28px, 5vw, 56px);
      background: var(--paper);
      border-radius: 26px;
    }

    #tg-uda .tg-screen.is-active {
      display: block;
      animation: tg-fade 0.35s ease both;
    }

    #tg-uda .tg-hero.tg-screen.is-active,
    #tg-uda .tg-loading.tg-screen.is-active {
      display: grid;
    }

    #tg-uda .tg-hero {
      position: relative;
      min-height: 0;
      align-content: start;
      padding: clamp(28px, 5vw, 56px);
      background: var(--paper);
      border-radius: 26px;
    }

    #tg-uda .tg-eyebrow {
      color: var(--muted);
      font-size: 12px;
      letter-spacing: 0.18em;
      text-transform: uppercase;
    }

    #tg-uda h1,
    #tg-uda h2,
    #tg-uda h3,
    #tg-uda p {
      overflow-wrap: anywhere;
    }

    #tg-uda h1 {
      max-width: 760px;
      margin: 18px 0 26px;
      font-size: clamp(34px, 7vw, 72px);
      line-height: 1.08;
      letter-spacing: -0.035em;
    }

    #tg-uda .tg-lead {
      max-width: 680px;
      margin: 0 0 34px;
      color: #50534e;
      font-size: clamp(15px, 2vw, 19px);
    }

    #tg-uda .tg-meta {
      display: flex;
      flex-wrap: wrap;
      gap: 10px;
      margin-bottom: 34px;
    }

    #tg-uda .tg-chip {
      padding: 8px 12px;
      border: 1px solid var(--line);
      border-radius: 999px;
      background: rgba(255, 255, 255, 0.45);
      font-size: 13px;
    }

    #tg-uda .tg-primary,
    #tg-uda .tg-secondary,
    #tg-uda .tg-quiet {
      min-height: 48px;
      padding: 13px 22px;
      border-radius: 999px;
      cursor: pointer;
      transition:
        transform 0.2s ease,
        box-shadow 0.2s ease,
        background 0.2s ease,
        border-color 0.2s ease;
    }

    #tg-uda .tg-primary {
      border: 1px solid var(--ink);
      background: var(--ink);
      color: #fff;
    }

    #tg-uda .tg-secondary {
      border: 1px solid var(--line);
      background: var(--paper-strong);
      color: var(--ink);
    }

    #tg-uda .tg-quiet {
      border: 1px solid transparent;
      background: transparent;
      color: var(--muted);
    }

    #tg-uda .tg-primary:hover,
    #tg-uda .tg-secondary:hover {
      transform: translateY(-2px);
      box-shadow: 0 10px 30px rgba(0, 0, 0, 0.12);
    }

    #tg-uda button:focus-visible {
      outline: 3px solid color-mix(in srgb, var(--focus) 42%, transparent);
      outline-offset: 4px;
    }

    #tg-uda button:disabled {
      cursor: wait;
      opacity: 0.64;
      transform: none;
      box-shadow: none;
    }

    #tg-uda .tg-orbit {
      pointer-events: none;
      position: absolute;
      top: 12%;
      right: 7%;
      width: 220px;
      height: 220px;
      border: 1px solid var(--line);
      border-radius: 50%;
      opacity: 0.7;
    }

    #tg-uda .tg-orbit::before,
    #tg-uda .tg-orbit::after {
      content: "";
      position: absolute;
      border: 1px solid var(--line);
      border-radius: 50%;
    }

    #tg-uda .tg-orbit::before {
      inset: 36px;
    }

    #tg-uda .tg-orbit::after {
      inset: 78px;
      background: var(--accent);
    }

    #tg-uda .tg-progress-row {
      display: flex;
      align-items: center;
      gap: 18px;
      margin-bottom: 28px;
    }

    #tg-uda .tg-progress {
      flex: 1;
      height: 7px;
      overflow: hidden;
      border-radius: 99px;
      background: #e2e2da;
    }

    #tg-uda .tg-progress > span {
      display: block;
      width: 0;
      height: 100%;
      border-radius: 99px;
      background: var(--accent);
      transition: width 0.35s ease;
    }

    #tg-uda .tg-count {
      color: var(--muted);
      font-size: 13px;
      white-space: nowrap;
    }

    #tg-uda .tg-question {
      max-width: 800px;
      margin: 18px 0 30px;
      font-size: clamp(24px, 4vw, 42px);
      line-height: 1.35;
      letter-spacing: -0.02em;
    }

    #tg-uda .tg-answers {
      display: grid;
      grid-template-columns: repeat(2, minmax(0, 1fr));
      gap: 14px;
    }

    #tg-uda .tg-answer {
      min-height: 92px;
      padding: 20px;
      border: 1px solid var(--line);
      border-radius: 18px;
      background: var(--paper-strong);
      color: var(--ink);
      text-align: left;
      cursor: pointer;
      transition:
        transform 0.2s ease,
        border-color 0.2s ease,
        background 0.2s ease;
    }

    #tg-uda .tg-answer:hover {
      transform: translateY(-2px);
      border-color: #93998e;
    }

    #tg-uda .tg-answer[aria-pressed="true"] {
      border-color: var(--accent-dark);
      background: var(--soft);
    }

    #tg-uda .tg-quiz-nav {
      display: flex;
      justify-content: space-between;
      gap: 14px;
      margin-top: 24px;
    }

    #tg-uda .tg-loading {
      min-height: 320px;
      place-items: center;
      text-align: center;
    }

    #tg-uda .tg-loader-ring {
      width: 110px;
      height: 110px;
      margin: 0 auto 24px;
      border: 1px solid var(--line);
      border-top-color: var(--accent);
      border-radius: 50%;
      animation: tg-spin 1.2s linear infinite;
    }

    #tg-uda .tg-result-head {
      display: grid;
      grid-template-columns: 1.2fr 0.8fr;
      align-items: end;
      gap: 34px;
      padding-bottom: 36px;
      border-bottom: 1px solid var(--line);
    }

    #tg-uda .tg-result-title {
      margin: 12px 0 20px;
      font-size: clamp(42px, 7vw, 78px);
      line-height: 1.06;
      letter-spacing: -0.045em;
    }

    #tg-uda .tg-result-copy {
      max-width: 650px;
      color: #555951;
    }

    #tg-uda .tg-score-badge {
      display: grid;
      place-items: center;
      aspect-ratio: 1;
      border: 1px solid var(--line);
      border-radius: 50%;
      background:
        radial-gradient(circle, var(--paper) 0 45%, #e7e9e2 46% 47%, transparent 48%);
      text-align: center;
    }

    #tg-uda .tg-score-badge strong {
      display: block;
      font-size: 58px;
      line-height: 1;
    }

    #tg-uda .tg-score-badge span {
      display: block;
      color: var(--muted);
      font-size: 12px;
    }

    #tg-uda .tg-section {
      padding: 42px 0;
      border-bottom: 1px solid var(--line);
    }

    #tg-uda .tg-section h2 {
      margin: 0 0 8px;
      font-size: 22px;
    }

    #tg-uda .tg-section-intro {
      margin: 0 0 24px;
      color: var(--muted);
    }

    #tg-uda .tg-bars {
      display: grid;
      gap: 13px;
    }

    #tg-uda .tg-bar-row {
      display: grid;
      grid-template-columns: 110px 1fr 44px;
      align-items: center;
      gap: 12px;
    }

    #tg-uda .tg-bar {
      height: 10px;
      overflow: hidden;
      border-radius: 99px;
      background: #e1e2dc;
    }

    #tg-uda .tg-bar i {
      display: block;
      width: 0;
      height: 100%;
      border-radius: 99px;
      background: var(--accent);
      transition: width 0.7s ease;
    }

    #tg-uda .tg-bar-row b {
      font-size: 13px;
      text-align: right;
    }

    #tg-uda .tg-map-wrap {
      display: grid;
      grid-template-columns: minmax(0, 1.1fr) minmax(250px, 0.9fr);
      align-items: center;
      gap: 28px;
    }

    #tg-uda #tg-radar {
      width: 100%;
      height: auto;
      max-height: 440px;
      overflow: visible;
    }

    #tg-uda .tg-legend {
      display: grid;
      gap: 10px;
    }

    #tg-uda .tg-legend-item {
      display: flex;
      justify-content: space-between;
      gap: 14px;
      padding: 9px 0;
      border-bottom: 1px dashed var(--line);
    }

    #tg-uda .tg-pairs {
      display: grid;
      grid-template-columns: 1fr 1fr;
      gap: 18px;
    }

    #tg-uda .tg-pair-card {
      padding: 22px;
      border: 1px solid var(--line);
      border-radius: 20px;
      background: var(--paper-strong);
    }

    #tg-uda .tg-pair-card h3 {
      margin: 0 0 12px;
      font-size: 17px;
    }

    #tg-uda .tg-tags {
      display: flex;
      flex-wrap: wrap;
      gap: 9px;
    }

    #tg-uda .tg-tag {
      padding: 8px 11px;
      border-radius: 999px;
      background: var(--soft);
      font-size: 13px;
    }

    #tg-uda .tg-actions {
      display: flex;
      flex-wrap: wrap;
      gap: 12px;
      padding-top: 34px;
    }

    #tg-uda .tg-note,
    #tg-uda .tg-status {
      margin-top: 24px;
      color: var(--muted);
      font-size: 13px;
    }

    #tg-uda .tg-status {
      min-height: 1.8em;
      color: var(--accent-dark);
    }

    #tg-uda .tg-noscript {
      padding: 22px;
      border: 1px solid #d9b3ae;
      border-radius: 16px;
      background: #fff7f5;
      color: var(--danger);
    }

    @keyframes tg-spin {
      to { transform: rotate(360deg); }
    }

    @keyframes tg-fade {
      from { opacity: 0; transform: translateY(6px); }
      to { opacity: 1; transform: translateY(0); }
    }

    @media (max-width: 720px) {
      #tg-uda .tg-app {
        padding: 0;
      }

      #tg-uda .tg-wrap {
        width: 100%;
      }

      #tg-uda .tg-shell {
        border-radius: 0;
      }

      #tg-uda .tg-hero {
        min-height: 0;
        padding: 32px 22px;
      }

      #tg-uda .tg-orbit {
        top: 26px;
        right: -18px;
        width: 118px;
        height: 118px;
        opacity: 0.32;
      }

      #tg-uda .tg-orbit::before { inset: 24px; }
      #tg-uda .tg-orbit::after { inset: 52px; }

      #tg-uda h1 {
        max-width: 92%;
        font-size: clamp(36px, 12vw, 54px);
      }

      #tg-uda .tg-lead {
        max-width: 94%;
      }

      #tg-uda .tg-screen {
        padding: 32px 22px;
        border-radius: 20px;
      }

      #tg-uda .tg-answers,
      #tg-uda .tg-result-head,
      #tg-uda .tg-map-wrap,
      #tg-uda .tg-pairs {
        grid-template-columns: 1fr;
      }

      #tg-uda .tg-answer {
        min-height: 82px;
        padding: 17px 18px;
      }

      #tg-uda .tg-result-title {
        font-size: clamp(42px, 13vw, 64px);
      }

      #tg-uda .tg-score-badge {
        width: 176px;
        justify-self: center;
      }

      #tg-uda .tg-bar-row {
        grid-template-columns: 82px minmax(0, 1fr) 34px;
        gap: 9px;
      }

      #tg-uda .tg-bar-row span {
        font-size: 13px;
      }

      #tg-uda .tg-actions {
        display: grid;
      }

      #tg-uda .tg-actions button {
        width: 100%;
      }
    }

    @media (max-width: 390px) {
      #tg-uda .tg-meta {
        gap: 7px;
      }

      #tg-uda .tg-chip {
        padding: 7px 10px;
        font-size: 12px;
      }

      #tg-uda .tg-question {
        font-size: 26px;
      }

      #tg-uda .tg-bar-row {
        grid-template-columns: 76px minmax(0, 1fr) 30px;
      }

      #tg-uda .tg-bar-row span {
        font-size: 12px;
      }
    }

    @media (prefers-reduced-motion: reduce) {
      #tg-uda *,
      #tg-uda *::before,
      #tg-uda *::after {
        scroll-behavior: auto !important;
        animation-duration: 0.001ms !important;
        animation-iteration-count: 1 !important;
        transition-duration: 0.001ms !important;
      }
    }
  
</style>

<div id="tg-uda">
<main class="tg-app">
<div class="tg-wrap">
<div class="tg-shell">
<noscript>
<div class="tg-screen" style="display:block">
<p class="tg-noscript">この診断を利用するにはJavaScriptを有効にしてください。</p>
</div>
</noscript>
<section aria-labelledby="tg-start-title" class="tg-hero tg-screen is-active" id="tg-start">
<div aria-hidden="true" class="tg-orbit"></div>
<div class="tg-eyebrow">Experimental Diagnosis</div>
<h1 id="tg-start-title">気づけば、いつもしていること。</h1>
<p class="tg-lead">
              これは性格や能力を決めるものではなく、日常の中で無意識に繰り返している
              「行動の向き」を見つけるための診断です。
            </p>
<div aria-label="診断概要" class="tg-meta">
<span class="tg-chip">24問</span>
<span class="tg-chip">4択</span>
<span class="tg-chip">20の行動傾向</span>
<span class="tg-chip">約4〜6分</span>
</div>
<div>
<button class="tg-primary" id="tg-start-btn" type="button">診断をはじめる</button>
</div>
</section>
<section aria-labelledby="tg-question" aria-live="polite" class="tg-screen" id="tg-quiz">
<div class="tg-progress-row">
<div aria-label="診断の進捗" aria-valuemax="24" aria-valuemin="0" aria-valuenow="0" class="tg-progress" role="progressbar">
<span id="tg-progress-bar"></span>
</div>
<div class="tg-count" id="tg-count"></div>
</div>
<div class="tg-eyebrow">無意識な行動診断（試作版）</div>
<h2 class="tg-question" id="tg-question" tabindex="-1"></h2>
<div aria-label="回答を選択" class="tg-answers" id="tg-answers" role="group"></div>
<div class="tg-quiz-nav">
<button class="tg-quiet" id="tg-back-btn" type="button">前の質問へ</button>
<button class="tg-quiet" id="tg-reset-btn" type="button">最初からやり直す</button>
</div>
</section>
<section aria-live="polite" class="tg-screen tg-loading" id="tg-loading">
<div>
<div aria-hidden="true" class="tg-loader-ring"></div>
<div class="tg-eyebrow" id="tg-loading-label">あなたの行動を整理しています…</div>
</div>
</section>
<section aria-labelledby="tg-result-title" class="tg-screen" id="tg-result">
<div class="tg-result-head">
<div>
<div class="tg-eyebrow">あなたに最も自然に現れた行動</div>
<h2 class="tg-result-title" id="tg-result-title" tabindex="-1"></h2>
<p class="tg-result-copy" id="tg-result-copy"></p>
</div>
<div aria-label="主傾向スコア" class="tg-score-badge">
<div>
<strong id="tg-main-score">0</strong>
<span>/ 100</span>
</div>
</div>
</div>
<div class="tg-section">
<h2>20の行動パラメータ</h2>
<p class="tg-section-intro">
                高いほど、今回の回答でその行動が比較的強く現れました。
              </p>
<div class="tg-bars" id="tg-bars"></div>
</div>
<div class="tg-section">
<h2>行動マップ</h2>
<p class="tg-section-intro">
                上位8項目を、ひとつの輪郭として可視化しています。
              </p>
<div class="tg-map-wrap">
<svg aria-labelledby="tg-radar-title tg-radar-desc" id="tg-radar" role="img" viewBox="0 0 520 520">
<title id="tg-radar-title">上位8つの行動傾向</title>
<desc id="tg-radar-desc">回答結果から算出した行動傾向のレーダーチャートです。</desc>
</svg>
<div class="tg-legend" id="tg-legend"></div>
</div>
</div>
<div class="tg-section">
<div class="tg-pairs">
<div class="tg-pair-card">
<h3>近い行動</h3>
<div class="tg-tags" id="tg-near-tags"></div>
</div>
<div class="tg-pair-card">
<h3>今は少し遠い行動</h3>
<div class="tg-tags" id="tg-far-tags"></div>
</div>
</div>
</div>
<div class="tg-actions">
<button class="tg-primary" id="tg-retry-btn" type="button">もう一度診断する</button>
<button class="tg-secondary" id="tg-copy-btn" type="button">結果をコピー</button>
<button class="tg-secondary" id="tg-share-btn" type="button">結果を共有</button>
<button class="tg-secondary" id="tg-download-btn" type="button">結果を保存</button>
</div>
<p aria-live="polite" class="tg-status" id="tg-status" role="status"></p>
<p class="tg-note">
              この結果は固定された性格を断定するものではありません。
              今の生活、環境、体調、役割によって、行動の現れ方は変化します。
            </p>
</section>
</div>
</div>
</main>
</div>

<script>

    (() => {
      "use strict";

      const ROOT = document.getElementById("tg-uda");
      if (!ROOT) return;

      const TRAITS = {
        observe: "観察する",
        collect: "集める",
        create: "作る",
        design: "設計する",
        record: "残す",
        nurture: "育てる",
        organize: "整える",
        break: "壊す",
        repair: "直す",
        discover: "見つける",
        protect: "守る",
        challenge: "挑戦する",
        savor: "味わう",
        play: "遊ぶ",
        think: "考える",
        communicate: "伝える",
        analyze: "分析する",
        imagine: "想像する",
        connect: "繋げる",
        help: "助ける"
      };

      const DEFINITIONS = {
        observe: ["観察する人", "変化や細部を受け取り、すぐに判断せず見つめる行動が自然に現れます。"],
        collect: ["集める人", "物・情報・言葉・記憶を、自分なりのまとまりとして蓄える行動が自然に現れます。"],
        create: ["作る人", "考えや感覚を、目に見える形へ変える行動が自然に現れます。"],
        design: ["設計する人", "全体の構造や流れを考え、関係を組み立てる行動が自然に現れます。"],
        record: ["残す人", "消えてしまう前に、出来事や感覚を記録する行動が自然に現れます。"],
        nurture: ["育てる人", "時間をかけて変化を見守り、少しずつ支える行動が自然に現れます。"],
        organize: ["整える人", "散らばった物事を分類し、扱いやすい状態へ整える行動が自然に現れます。"],
        break: ["壊す人", "既存の前提や形をいったん崩し、新しい余地をつくる行動が自然に現れます。"],
        repair: ["直す人", "不具合や違和感を見つけ、よりよく機能する状態へ戻す行動が自然に現れます。"],
        discover: ["見つける人", "まだ知られていない場所・意味・可能性を探す行動が自然に現れます。"],
        protect: ["守る人", "大切なものが傷つかないように、境界や環境を整える行動が自然に現れます。"],
        challenge: ["挑戦する人", "未知や難しさへ踏み込み、変化を起こす行動が自然に現れます。"],
        savor: ["味わう人", "急いで結論にせず、感覚や時間を深く受け取る行動が自然に現れます。"],
        play: ["遊ぶ人", "正解や効率から離れ、自由な試行や偶然を楽しむ行動が自然に現れます。"],
        think: ["考える人", "出来事の意味や背景を、自分の内側で掘り下げる行動が自然に現れます。"],
        communicate: ["伝える人", "自分が受け取ったことを、言葉や表現で誰かへ届ける行動が自然に現れます。"],
        analyze: ["分析する人", "要素を分け、因果や仕組みを明らかにする行動が自然に現れます。"],
        imagine: ["想像する人", "目の前にない可能性や物語を思い描く行動が自然に現れます。"],
        connect: ["繋げる人", "人・情報・考えの間に関係をつくる行動が自然に現れます。"],
        help: ["助ける人", "困りごとを見つけ、負担を減らすために動く行動が自然に現れます。"]
      };

      const QUESTIONS = [
        { q: "知らない街を歩いているとき、気づけば最初にしていることは？", a: [
          { t: "建物や人の動きを静かに眺める", s: { observe: 3, analyze: 1, discover: 1 } },
          { t: "気になる路地や店を見つけて入ってみる", s: { discover: 3, challenge: 1, play: 1 } },
          { t: "地図や案内を見て歩き方を組み立てる", s: { design: 3, organize: 2 } },
          { t: "写真やメモで、その場の記憶を残す", s: { record: 3, observe: 1, create: 1 } }
        ]},
        { q: "本屋に入ると、自然と目が向くのは？", a: [
          { t: "装丁や棚の並び方", s: { observe: 2, design: 2, organize: 1 } },
          { t: "知らなかった分野や新しい言葉", s: { discover: 2, think: 2, analyze: 1 } },
          { t: "あとで読み返したい本", s: { collect: 3, record: 1 } },
          { t: "誰かに勧めたくなる本", s: { communicate: 2, connect: 2, help: 1 } }
        ]},
        { q: "面白いことを知った直後、いちばん起こりやすい行動は？", a: [
          { t: "さらに調べて仕組みを理解する", s: { analyze: 3, think: 2 } },
          { t: "誰かに話したり共有したりする", s: { communicate: 3, connect: 1 } },
          { t: "保存して、あとで見返せるようにする", s: { record: 2, collect: 2, organize: 1 } },
          { t: "自分なりの形で試してみる", s: { create: 2, challenge: 2, play: 1 } }
        ]},
        { q: "部屋が少し散らかっているとき、最初に手をつけるなら？", a: [
          { t: "物の定位置を決め直す", s: { organize: 3, design: 2 } },
          { t: "壊れている物や不便な箇所を直す", s: { repair: 3, help: 1 } },
          { t: "思い切って不要な物を手放す", s: { break: 2, organize: 2 } },
          { t: "そのまま眺め、何が気になるのか考える", s: { observe: 2, think: 2, analyze: 1 } }
        ]},
        { q: "友人が悩みを話しているとき、自然にしているのは？", a: [
          { t: "まず最後まで聞く", s: { observe: 2, help: 2, protect: 1 } },
          { t: "状況を整理して原因を考える", s: { analyze: 3, think: 1, organize: 1 } },
          { t: "具体的な解決策を一緒に考える", s: { help: 3, repair: 2 } },
          { t: "別の人や場所につなげる", s: { connect: 3, help: 1 } }
        ]},
        { q: "旅行の写真を見返すとき、気になりやすいのは？", a: [
          { t: "そのときの空気や音まで思い出せる写真", s: { savor: 3, record: 2 } },
          { t: "撮影した場所や順番", s: { organize: 2, analyze: 1, record: 1 } },
          { t: "人が気づかなそうな細部", s: { observe: 3, discover: 1 } },
          { t: "誰かに見せたくなる一枚", s: { communicate: 2, create: 1, connect: 1 } }
        ]},
        { q: "新しい道具を手に入れたとき、最初にすることは？", a: [
          { t: "仕組みや設定を細かく確認する", s: { analyze: 3, design: 1 } },
          { t: "すぐに何かを作ってみる", s: { create: 3, play: 1 } },
          { t: "長く使えるように手入れ方法を調べる", s: { protect: 2, nurture: 2, repair: 1 } },
          { t: "他の道具との組み合わせを試す", s: { connect: 2, design: 2, challenge: 1 } }
        ]},
        { q: "予定のない休日、気づけばしていることは？", a: [
          { t: "散歩しながら景色や人を眺める", s: { observe: 3, savor: 1 } },
          { t: "気になっていたことを調べ続ける", s: { think: 2, analyze: 2, discover: 1 } },
          { t: "部屋やデータを整理する", s: { organize: 3, record: 1 } },
          { t: "思いついたものを作る", s: { create: 3, imagine: 1 } }
        ]},
        { q: "何かがうまく動かないとき、最初の反応に近いのは？", a: [
          { t: "原因を切り分ける", s: { analyze: 3, repair: 1 } },
          { t: "別の方法を組み立てる", s: { design: 3, challenge: 1 } },
          { t: "一度ばらして考え直す", s: { break: 2, repair: 2, think: 1 } },
          { t: "誰かの事例や知恵を探す", s: { discover: 2, connect: 1, collect: 1 } }
        ]},
        { q: "カフェでひとりで過ごすとき、自然にしているのは？", a: [
          { t: "味や香り、空間をゆっくり感じる", s: { savor: 3, observe: 1 } },
          { t: "周囲の会話や人の動きを眺める", s: { observe: 3, imagine: 1 } },
          { t: "考えごとやメモをまとめる", s: { think: 2, record: 2 } },
          { t: "次にしたいことを組み立てる", s: { design: 2, organize: 2 } }
        ]},
        { q: "人から褒められたとき、いちばん嬉しいのは？", a: [
          { t: "よく気づいたね、と言われる", s: { observe: 3, discover: 1 } },
          { t: "分かりやすかった、と言われる", s: { communicate: 3, organize: 1 } },
          { t: "助かった、と言われる", s: { help: 3, repair: 1 } },
          { t: "こんなの初めて、と言われる", s: { create: 2, imagine: 2, challenge: 1 } }
        ]},
        { q: "気に入った物を見つけたとき、しやすい行動は？", a: [
          { t: "同じ系統の物も探す", s: { collect: 3, discover: 1 } },
          { t: "どこが魅力なのか考える", s: { analyze: 2, think: 2 } },
          { t: "大切に長く使う方法を考える", s: { protect: 2, nurture: 2 } },
          { t: "誰かに紹介する", s: { communicate: 2, connect: 2 } }
        ]},
        { q: "子どもや初心者と一緒に何かするとき、自然に取りやすい役割は？", a: [
          { t: "見守りながら、必要な時だけ手を貸す", s: { nurture: 3, protect: 2 } },
          { t: "分かりやすく順序を説明する", s: { communicate: 2, organize: 2, help: 1 } },
          { t: "一緒に試しながら楽しむ", s: { play: 2, challenge: 1, connect: 2 } },
          { t: "その人に合うやり方を考える", s: { design: 2, help: 2, observe: 1 } }
        ]},
        { q: "古い物や使われなくなった物を見ると？", a: [
          { t: "直して使えないか考える", s: { repair: 3, protect: 1 } },
          { t: "残された痕跡や背景を想像する", s: { imagine: 2, observe: 2, record: 1 } },
          { t: "部品や素材として別の使い道を考える", s: { create: 2, break: 1, design: 2 } },
          { t: "資料として取っておきたくなる", s: { collect: 2, record: 2 } }
        ]},
        { q: "複数人で企画を進めるとき、自然と担当しやすいのは？", a: [
          { t: "全体の流れや役割を設計する", s: { design: 3, organize: 2 } },
          { t: "人の意見をつなぎ合わせる", s: { connect: 3, communicate: 1 } },
          { t: "問題点を見つけて調整する", s: { repair: 2, analyze: 2 } },
          { t: "新しい案を出して空気を動かす", s: { imagine: 2, challenge: 2, create: 1 } }
        ]},
        { q: "予定通りに進まない出来事が起きたときは？", a: [
          { t: "状況を観察して、何が起きているか確認する", s: { observe: 2, analyze: 2 } },
          { t: "優先順位を組み直す", s: { organize: 3, design: 1 } },
          { t: "思い切って別の方向へ変える", s: { challenge: 2, break: 2 } },
          { t: "周囲が困らないように支える", s: { help: 2, protect: 2 } }
        ]},
        { q: "作品や映画に触れたあと、残りやすい行動は？", a: [
          { t: "しばらく余韻を味わう", s: { savor: 3, think: 1 } },
          { t: "感想や解釈を考える", s: { think: 3, analyze: 1 } },
          { t: "似た作品や背景を探す", s: { discover: 2, collect: 2 } },
          { t: "誰かに話したり文章にしたりする", s: { communicate: 2, record: 2 } }
        ]},
        { q: "新しいアイデアが浮かんだとき、最初にするのは？", a: [
          { t: "頭の中で自由に広げる", s: { imagine: 3, play: 1 } },
          { t: "実現できる構造に組み立てる", s: { design: 3, analyze: 1 } },
          { t: "試作品を作る", s: { create: 3, challenge: 1 } },
          { t: "メモや資料として残す", s: { record: 3, collect: 1 } }
        ]},
        { q: "誰かが大切にしているものに触れるときは？", a: [
          { t: "傷つけないよう丁寧に扱う", s: { protect: 3, observe: 1 } },
          { t: "なぜ大切なのか話を聞く", s: { connect: 2, observe: 1, help: 1 } },
          { t: "背景や意味を考える", s: { think: 2, imagine: 2 } },
          { t: "残し方や保管方法を考える", s: { record: 2, organize: 1, protect: 1 } }
        ]},
        { q: "ゲームや遊びで楽しいと感じる瞬間は？", a: [
          { t: "ルールの隙や新しい遊び方を見つけたとき", s: { play: 3, discover: 1, break: 1 } },
          { t: "難しい課題を突破したとき", s: { challenge: 3, analyze: 1 } },
          { t: "みんなで盛り上がったとき", s: { connect: 3, communicate: 1 } },
          { t: "世界観や物語に入り込んだとき", s: { imagine: 3, savor: 1 } }
        ]},
        { q: "日々の記録を残すなら、近い方法は？", a: [
          { t: "写真や文章で出来事を保存する", s: { record: 3, create: 1 } },
          { t: "数字や一覧で変化を追う", s: { analyze: 2, organize: 2 } },
          { t: "気になった物や言葉を集める", s: { collect: 3, discover: 1 } },
          { t: "誰かと共有しながら続ける", s: { connect: 2, communicate: 2 } }
        ]},
        { q: "身近な植物や生き物に接するときは？", a: [
          { t: "変化を毎日観察する", s: { observe: 2, nurture: 2 } },
          { t: "世話をしながら成長を支える", s: { nurture: 3, protect: 1 } },
          { t: "特徴や生態を調べる", s: { analyze: 2, discover: 2 } },
          { t: "写真や記録に残す", s: { record: 2, collect: 1, observe: 1 } }
        ]},
        { q: "長く続いている習慣があるとしたら、続く理由に近いのは？", a: [
          { t: "少しずつ変化する過程が面白い", s: { nurture: 2, observe: 2 } },
          { t: "積み重なった記録が残る", s: { record: 3, collect: 1 } },
          { t: "自分なりに改善し続けられる", s: { repair: 2, analyze: 1, challenge: 1 } },
          { t: "その時間そのものが心地よい", s: { savor: 3, play: 1 } }
        ]},
        { q: "目の前にまだ名前のない違和感があるとき、自然にすることは？", a: [
          { t: "じっと観察し、違いを探す", s: { observe: 3, discover: 1 } },
          { t: "言葉や構造にして説明しようとする", s: { communicate: 2, organize: 1, think: 2 } },
          { t: "別の可能性や物語を想像する", s: { imagine: 3, think: 1 } },
          { t: "手を動かして形にしてみる", s: { create: 2, challenge: 2, design: 1 } }
        ]}
      ];

      const $ = (selector) => ROOT.querySelector(selector);
      const $$ = (selector) => Array.from(ROOT.querySelectorAll(selector));

      const elements = {
        screens: $$(".tg-screen"),
        start: $("#tg-start"),
        quiz: $("#tg-quiz"),
        loading: $("#tg-loading"),
        result: $("#tg-result"),
        startBtn: $("#tg-start-btn"),
        backBtn: $("#tg-back-btn"),
        resetBtn: $("#tg-reset-btn"),
        retryBtn: $("#tg-retry-btn"),
        copyBtn: $("#tg-copy-btn"),
        shareBtn: $("#tg-share-btn"),
        downloadBtn: $("#tg-download-btn"),
        question: $("#tg-question"),
        answers: $("#tg-answers"),
        count: $("#tg-count"),
        progress: $(".tg-progress"),
        progressBar: $("#tg-progress-bar"),
        loadingLabel: $("#tg-loading-label"),
        resultTitle: $("#tg-result-title"),
        resultCopy: $("#tg-result-copy"),
        mainScore: $("#tg-main-score"),
        bars: $("#tg-bars"),
        radar: $("#tg-radar"),
        legend: $("#tg-legend"),
        nearTags: $("#tg-near-tags"),
        farTags: $("#tg-far-tags"),
        status: $("#tg-status")
      };

      const state = {
        index: 0,
        selectedIndexes: [],
        scores: createEmptyScores(),
        busy: false,
        lastResult: null
      };

      const maxPossible = calculateMaxPossibleScores();

      function createEmptyScores() {
        return Object.fromEntries(Object.keys(TRAITS).map((key) => [key, 0]));
      }

      function calculateMaxPossibleScores() {
        const maximums = createEmptyScores();

        QUESTIONS.forEach((question) => {
          Object.keys(TRAITS).forEach((trait) => {
            const best = Math.max(
              0,
              ...question.a.map((answer) => Number(answer.s[trait] || 0))
            );
            maximums[trait] += best;
          });
        });

        return maximums;
      }

      function showScreen(target) {
        elements.screens.forEach((screen) => screen.classList.remove("is-active"));
        target.classList.add("is-active");

        const reduceMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
        window.scrollTo({ top: 0, behavior: reduceMotion ? "auto" : "smooth" });
      }

      function focusSoon(element) {
        window.setTimeout(() => element?.focus({ preventScroll: true }), 80);
      }

      function renderQuestion() {
        const question = QUESTIONS[state.index];
        const answeredCount = state.selectedIndexes.length;
        const progressValue = Math.min(answeredCount, QUESTIONS.length);

        elements.question.textContent = question.q;
        elements.count.textContent = `${state.index + 1} / ${QUESTIONS.length}`;
        elements.progressBar.style.width = `${(progressValue / QUESTIONS.length) * 100}%`;
        elements.progress.setAttribute("aria-valuenow", String(progressValue));
        elements.answers.replaceChildren();
        elements.backBtn.hidden = state.index === 0;

        question.a.forEach((answer, answerIndex) => {
          const button = document.createElement("button");
          button.type = "button";
          button.className = "tg-answer";
          button.textContent = answer.t;
          button.dataset.answerIndex = String(answerIndex);
          button.setAttribute(
            "aria-pressed",
            String(state.selectedIndexes[state.index] === answerIndex)
          );

          button.addEventListener("click", () => chooseAnswer(answerIndex));
          elements.answers.appendChild(button);
        });

        focusSoon(elements.question);
      }

      function chooseAnswer(answerIndex) {
        if (state.busy) return;

        const question = QUESTIONS[state.index];
        const answer = question.a[answerIndex];
        if (!answer) return;

        state.busy = true;

        // Revisiting a question: remove the previous answer first.
        const previousIndex = state.selectedIndexes[state.index];
        if (Number.isInteger(previousIndex)) {
          subtractScores(question.a[previousIndex].s);
        }

        state.selectedIndexes[state.index] = answerIndex;
        addScores(answer.s);

        $$(".tg-answer").forEach((button) => {
          const selected = Number(button.dataset.answerIndex) === answerIndex;
          button.setAttribute("aria-pressed", String(selected));
          button.disabled = true;
        });

        window.setTimeout(() => {
          state.index += 1;

          if (state.index < QUESTIONS.length) {
            state.busy = false;
            renderQuestion();
          } else {
            finishDiagnosis();
          }
        }, 180);
      }

      function addScores(values) {
        Object.entries(values).forEach(([key, value]) => {
          state.scores[key] += Number(value);
        });
      }

      function subtractScores(values) {
        Object.entries(values).forEach(([key, value]) => {
          state.scores[key] = Math.max(0, state.scores[key] - Number(value));
        });
      }

      function goBack() {
        if (state.busy || state.index <= 0) return;
        state.index -= 1;
        renderQuestion();
      }

      function resetDiagnosis(confirmReset = false) {
        if (confirmReset) {
          if (state.selectedIndexes.length > 0) {
          const accepted = window.confirm("回答を消去して、最初からやり直しますか？");
            if (!accepted) return;
          }
        }

        state.index = 0;
        state.selectedIndexes = [];
        state.scores = createEmptyScores();
        state.busy = false;
        state.lastResult = null;
        elements.status.textContent = "";
        elements.loadingLabel.textContent = "あなたの行動を整理しています…";
        showScreen(elements.start);
        focusSoon(elements.startBtn);
      }

      function finishDiagnosis() {
        showScreen(elements.loading);

        const labels = [
          "あなたの行動を整理しています…",
          "世界との関わり方を確認しています…",
          "見つかりました。"
        ];

        let labelIndex = 0;
        elements.loadingLabel.textContent = labels[0];

        const intervalId = window.setInterval(() => {
          labelIndex += 1;

          if (labelIndex < labels.length) {
            elements.loadingLabel.textContent = labels[labelIndex];
            return;
          }

          window.clearInterval(intervalId);
          renderResult();
          state.busy = false;
          showScreen(elements.result);
          focusSoon(elements.resultTitle);
        }, 650);
      }

      function normalizedScores() {
        /*
          Trait appearance counts differ across the questionnaire.
          Each score is therefore divided by the maximum score the same
          trait could theoretically obtain. A small neutral prior prevents
          rarely appearing traits from jumping too easily to 100.
        */
        const priorWeight = 8;
        const priorRatio = 0.42;

        return Object.fromEntries(
          Object.entries(state.scores).map(([trait, raw]) => {
            const maximum = Math.max(1, maxPossible[trait]);
            const adjustedRatio =
              (raw + priorWeight * priorRatio) / (maximum + priorWeight);
            const score = Math.round(Math.max(0, Math.min(1, adjustedRatio)) * 100);
            return [trait, score];
          })
        );
      }

      function renderResult() {
        const normalized = normalizedScores();
        const sorted = Object.entries(normalized).sort((a, b) => {
          if (b[1] !== a[1]) return b[1] - a[1];
          return TRAITS[a[0]].localeCompare(TRAITS[b[0]], "ja");
        });

        const [main, mainValue] = sorted[0];
        const second = sorted[1];

        elements.resultTitle.textContent = DEFINITIONS[main][0];
        elements.resultCopy.textContent =
          `${DEFINITIONS[main][1]} ` +
          `あわせて「${TRAITS[second[0]]}」傾向も比較的近く現れています。`;
        elements.mainScore.textContent = String(mainValue);

        elements.bars.innerHTML = sorted.map(([trait, value]) => `
          <div class="tg-bar-row">
            <span>${escapeHtml(TRAITS[trait])}</span>
            <div class="tg-bar" aria-hidden="true">
              <i style="width:${value}%"></i>
            </div>
            <b aria-label="${escapeHtml(TRAITS[trait])} ${value}点">${value}</b>
          </div>
        `).join("");

        const top = sorted.slice(0, 8);
        drawRadar(top);

        elements.legend.innerHTML = top.map(([trait, value]) => `
          <div class="tg-legend-item">
            <span>${escapeHtml(TRAITS[trait])}</span>
            <b>${value}</b>
          </div>
        `).join("");

        elements.nearTags.innerHTML = sorted.slice(1, 5).map(([trait]) =>
          `<span class="tg-tag">${escapeHtml(TRAITS[trait])}</span>`
        ).join("");

        elements.farTags.innerHTML = sorted.slice(-4).reverse().map(([trait]) =>
          `<span class="tg-tag">${escapeHtml(TRAITS[trait])}</span>`
        ).join("");

        state.lastResult = {
          generatedAt: new Date().toISOString(),
          main,
          mainValue,
          sorted,
          answerIndexes: [...state.selectedIndexes]
        };
      }

      function drawRadar(items) {
        const svg = elements.radar;
        const ns = "http://www.w3.org/2000/svg";
        const cx = 260;
        const cy = 260;
        const radius = 180;
        const count = items.length;

        Array.from(svg.children).forEach((child) => {
          if (!["title", "desc"].includes(child.tagName.toLowerCase())) {
            child.remove();
          }
        });

        const point = (r, index) => {
          const angle = -Math.PI / 2 + index * 2 * Math.PI / count;
          return [
            cx + Math.cos(angle) * r,
            cy + Math.sin(angle) * r
          ];
        };

        for (let ring = 1; ring <= 4; ring += 1) {
          const polygon = document.createElementNS(ns, "polygon");
          polygon.setAttribute(
            "points",
            Array.from({ length: count }, (_, index) =>
              point(radius * ring / 4, index).join(",")
            ).join(" ")
          );
          polygon.setAttribute("fill", "none");
          polygon.setAttribute("stroke", "#d7d8d1");
          polygon.setAttribute("vector-effect", "non-scaling-stroke");
          svg.appendChild(polygon);
        }

        items.forEach((_, index) => {
          const line = document.createElementNS(ns, "line");
          const [x, y] = point(radius, index);
          line.setAttribute("x1", String(cx));
          line.setAttribute("y1", String(cy));
          line.setAttribute("x2", String(x));
          line.setAttribute("y2", String(y));
          line.setAttribute("stroke", "#d7d8d1");
          line.setAttribute("vector-effect", "non-scaling-stroke");
          svg.appendChild(line);
        });

        const shape = document.createElementNS(ns, "polygon");
        shape.setAttribute(
          "points",
          items.map(([, value], index) =>
            point(radius * value / 100, index).join(",")
          ).join(" ")
        );
        shape.setAttribute("fill", "rgba(109,120,105,.22)");
        shape.setAttribute("stroke", "#6d7869");
        shape.setAttribute("stroke-width", "3");
        shape.setAttribute("vector-effect", "non-scaling-stroke");
        svg.appendChild(shape);

        items.forEach(([trait], index) => {
          const [x, y] = point(radius + 34, index);
          const text = document.createElementNS(ns, "text");
          text.setAttribute("x", String(x));
          text.setAttribute("y", String(y));
          text.setAttribute("text-anchor", "middle");
          text.setAttribute("dominant-baseline", "middle");
          text.setAttribute("font-size", "13");
          text.setAttribute("fill", "#4f534d");
          text.textContent = TRAITS[trait];
          svg.appendChild(text);
        });
      }

      function resultText() {
        const result = state.lastResult;
        if (!result) return "";

        return [
          "無意識な行動診断（試作版）",
          `結果：${DEFINITIONS[result.main][0]}`,
          `説明：${DEFINITIONS[result.main][1]}`,
          "",
          "上位5項目",
          ...result.sorted.slice(0, 5).map(
            ([trait, value], index) =>
              `${index + 1}. ${TRAITS[trait]}：${value}`
          ),
          "",
          "※固定された性格を断定する結果ではありません。",
          "Tranquil Guides"
        ].join("\n");
      }

      async function copyResult() {
        const text = resultText();
        if (!text) return;

        try {
          await navigator.clipboard.writeText(text);
          setStatus("結果をクリップボードへコピーしました。");
        } catch {
          fallbackCopy(text);
        }
      }

      function fallbackCopy(text) {
        const textarea = document.createElement("textarea");
        textarea.value = text;
        textarea.setAttribute("readonly", "");
        textarea.style.position = "fixed";
        textarea.style.opacity = "0";
        document.body.appendChild(textarea);
        textarea.select();

        try {
          document.execCommand("copy");
          setStatus("結果をクリップボードへコピーしました。");
        } catch {
          window.prompt("以下をコピーしてください。", text);
        } finally {
          textarea.remove();
        }
      }

      async function shareResult() {
        const text = resultText();
        if (!text) return;

        if (!navigator.share) {
          await copyResult();
          setStatus("共有機能を利用できないため、結果をコピーしました。");
          return;
        }

        try {
          await navigator.share({
            title: "無意識な行動診断（試作版）",
            text
          });
          setStatus("共有画面を開きました。");
        } catch (error) {
          if (error?.name !== "AbortError") {
            setStatus("共有できませんでした。結果をコピーして利用してください。");
          }
        }
      }

      function downloadResult() {
        const text = resultText();
        if (!text) return;

        const date = new Date();
        const stamp = [
          date.getFullYear(),
          String(date.getMonth() + 1).padStart(2, "0"),
          String(date.getDate()).padStart(2, "0")
        ].join("-");

        const blob = new Blob([text], { type: "text/plain;charset=utf-8" });
        const url = URL.createObjectURL(blob);
        const anchor = document.createElement("a");

        anchor.href = url;
        anchor.download = `unconscious-action-diagnosis-${stamp}.txt`;
        document.body.appendChild(anchor);
        anchor.click();
        anchor.remove();
        URL.revokeObjectURL(url);

        setStatus("結果をテキストファイルとして保存しました。");
      }

      function setStatus(message) {
        elements.status.textContent = message;
        window.setTimeout(() => {
          if (elements.status.textContent === message) {
            elements.status.textContent = "";
          }
        }, 4000);
      }

      function escapeHtml(value) {
        return String(value)
          .replaceAll("&", "&amp;")
          .replaceAll("<", "&lt;")
          .replaceAll(">", "&gt;")
          .replaceAll('"', "&quot;")
          .replaceAll("'", "&#039;");
      }

      elements.startBtn.addEventListener("click", () => {
        showScreen(elements.quiz);
        renderQuestion();
      });

      elements.backBtn.addEventListener("click", goBack);
      elements.resetBtn.addEventListener("click", () => resetDiagnosis(true));
      elements.retryBtn.addEventListener("click", () => resetDiagnosis(false));
      elements.copyBtn.addEventListener("click", copyResult);
      elements.shareBtn.addEventListener("click", shareResult);
      elements.downloadBtn.addEventListener("click", downloadResult);

      ROOT.addEventListener("keydown", (event) => {
        if (!elements.quiz.classList.contains("is-active") || state.busy) return;

        const answerButtons = $$(".tg-answer");
        const numericIndex = Number(event.key) - 1;

        if (numericIndex >= 0) {
          if (numericIndex < answerButtons.length) {
          event.preventDefault();
            answerButtons[numericIndex].click();
          }
        }

        if (event.key === "Escape") {
          if (state.index > 0) {
          event.preventDefault();
            goBack();
          }
        }
      });

      // Hide share button only when unavailable; copy remains as fallback.
      if (!navigator.share) {
        elements.shareBtn.textContent = "コピーして共有";
      }
    })();
  
</script>



<p class="wp-block-paragraph"></p>
]]></content:encoded>
					
					<wfw:commentRss>https://tranquilguides.com/behavior-outline/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
		<post-id xmlns="com-wordpress:feed-additions:1">1562</post-id>	</item>
	</channel>
</rss>
