real estate property

technology software

corporate business

government public service

adult content

Japanese

The domain 'tellus-5e4.pages.dev' uses the developer-focused generic top-level domain (.dev) and includes subdomain 'tellus-5e4'. The core label 'pages' covers 5 characters split between two vowels and 3 consonants. Word splitting yields one word: pages. No strong language cues emerged from the frequency lists.

html/06/42/064264ab-5914-4a54-81ea-434666addacf.html.gz

require-trusted-types-for 'script'; report-uri https://csp.withgoogle.com/csp/apps-themes

acc7e41455a80765b5fd9c7ee1b8078a6d160bbbca455aeae854de65c947d59e

85e6ee9ce246e3ae4424313f7e46a5ed860a28d757811de8dc9c43f306049d65

60a06a7791f2e0e874ac709b4b923f3901dee828dd2166961ba39e165562ae51

08255e1163e15d3429787354b60a2538e2948163664ca786a5880bbb7fa74d82

width=device-width, initial-scale=1, viewport-fit=cover

viewport

theme-color

Tellus — 不動産案件管理システム

不動産仲介業務のための案件・顧客・融資情報の一元管理ツール。

twitter:card

twitter:title

twitter:description

twitter:image

Abuse Team

CloudFlare, Inc.

pages.dev

Abuse

Google LLC

GOOGLE


  import { initializeApp } from 'https://www.gstatic.com/firebasejs/10.13.2/firebase-app.js';
  import {
    getAuth, signInWithEmailAndPassword, signOut, onAuthStateChanged,
    setPersistence, browserLocalPersistence
  } from 'https://www.gstatic.com/firebasejs/10.13.2/firebase-auth.js';
  import {
    getFirestore, doc, getDoc, setDoc, deleteDoc,
    collection, getDocs, addDoc, query, orderBy
  } from 'https://www.gstatic.com/firebasejs/10.13.2/firebase-firestore.js';
  import {
    getStorage, ref, uploadString, getBlob, deleteObject
  } from 'https://www.gstatic.com/firebasejs/10.13.2/firebase-storage.js';

  const firebaseConfig = {
    apiKey: "AIzaSyB_jd3fcsos0LeevC9wv6C13ZosnRHVq38",
    authDomain: "tellus-1e1f7.firebaseapp.com",
    projectId: "tellus-1e1f7",
    storageBucket: "tellus-1e1f7.firebasestorage.app",
    messagingSenderId: "80179083947",
    appId: "1:80179083947:web:828ab9343a1a09cb1995ee",
    measurementId: "G-JKYTGN5F7S"
  };

  const app = initializeApp(firebaseConfig);
  const auth = getAuth(app);
  const db = getFirestore(app);
  const storage = getStorage(app);

  // Persist login across browser restarts.
  setPersistence(auth, browserLocalPersistence).catch(e => console.warn('persistence', e));

  /* ----------------------------------------------------------
     Firestore data layout (Step 2):
       /tellus_settings/main           → settings document
       /tellus_meta/index              → list of all case IDs + last update
       /tellus_cases/<caseId>          → one case document each
     File blobs (Step 3) live in Firebase Storage:
       tellus_files/<fileId>           → original binary content
     ---------------------------------------------------------- */
  const FS_SETTINGS  = 'tellus_settings';
  const FS_META      = 'tellus_meta';
  const FS_CASES     = 'tellus_cases';
  const FS_ANALYTICS = 'tellus_analytics';
  const ST_FILES     = 'tellus_files';

  const fsAdapter = {
    async get(key) {
      const r = parseKeyToDocRef(key);
      if (!r) return null;
      const snap = await getDoc(r);
      if (!snap.exists()) return null;
      const data = snap.data();
      const value = (data && typeof data.payload === 'string') ? data.payload : null;
      if (value === null) return null;
      return { key, value, shared: true };
    },
    async set(key, value) {
      const r = parseKeyToDocRef(key);
      if (!r) throw new Error('Unknown Firestore key: ' + key);
      await setDoc(r, { payload: String(value), updatedAt: new Date().toISOString() });
      return { key, value, shared: true };
    },
    async delete(key) {
      const r = parseKeyToDocRef(key);
      if (!r) return { key, deleted: false, shared: true };
      await deleteDoc(r);
      return { key, deleted: true, shared: true };
    },
    async list(prefix = '') { return { keys: [], prefix, shared: true }; }
  };

  function parseKeyToDocRef(key) {
    if (key === 'tellus_settings_v2')  return doc(db, FS_SETTINGS, 'main');
    if (key === 'tellus_index_v3')     return doc(db, FS_META, 'index');
    if (key === 'tellus_analytics_v1') return doc(db, FS_ANALYTICS, 'main');
    if (key.startsWith('tellus_case_v3_')) {
      const id = key.slice('tellus_case_v3_'.length);
      if (!id) return null;
      return doc(db, FS_CASES, id);
    }
    return null;
  }

  /* ----------------------------------------------------------
     Firebase Storage adapter for file blobs.
     The rest of the app stores attachments as data URLs (so
     <img src> just works). We translate that to/from binary
     when talking to Firebase Storage:
       - set: parse data URL → upload base64 + content type
       - get: download blob → re-encode as data URL via FileReader
     ---------------------------------------------------------- */

  // tellus_file_<fileId>  →  storageRef('tellus_files/<fileId>')
  function storageRefForKey(key) {
    if (!key.startsWith('tellus_file_')) return null;
    const id = key.slice('tellus_file_'.length);
    if (!id) return null;
    return ref(storage, ST_FILES + '/' + id);
  }

  function parseDataUrl(dataUrl) {
    // "data:image/png;base64,iVBORw0KG..."
    const m = /^data:([^;,]+)?(;base64)?,(.*)$/s.exec(dataUrl || '');
    if (!m) return null;
    return {
      contentType: m[1] || 'application/octet-stream',
      isBase64: !!m[2],
      data: m[3] || ''
    };
  }

  function blobToDataURL(blob) {
    return new Promise((resolve, reject) => {
      const reader = new FileReader();
      reader.onload = () => resolve(reader.result);
      reader.onerror = () => reject(reader.error || new Error('blob read failed'));
      reader.readAsDataURL(blob);
    });
  }

  const storageFileAdapter = {
    async get(key) {
      const r = storageRefForKey(key);
      if (!r) return null;
      try {
        const blob = await getBlob(r);
        const dataUrl = await blobToDataURL(blob);
        return { key, value: dataUrl, shared: true };
      } catch (err) {
        // object-not-found is the expected "missing" case
        if (err && (err.code === 'storage/object-not-found')) return null;
        throw err;
      }
    },
    async set(key, value) {
      const r = storageRefForKey(key);
      if (!r) throw new Error('Unknown Storage key: ' + key);
      const parsed = parseDataUrl(String(value));
      if (!parsed) throw new Error('File value is not a data URL: ' + key);
      if (parsed.isBase64) {
        // Note: uploadString with 'base64' wants raw base64 (no data: prefix).
        await uploadString(r, parsed.data, 'base64', { contentType: parsed.contentType });
      } else {
        // Plain text payload — rare, but handle it.
        await uploadString(r, decodeURIComponent(parsed.data), 'raw', { contentType: parsed.contentType });
      }
      return { key, value, shared: true };
    },
    async delete(key) {
      const r = storageRefForKey(key);
      if (!r) return { key, deleted: false, shared: true };
      try {
        await deleteObject(r);
        return { key, deleted: true, shared: true };
      } catch (err) {
        if (err && (err.code === 'storage/object-not-found')) {
          return { key, deleted: true, shared: true };
        }
        throw err;
      }
    },
    async list(prefix = '') { return { keys: [], prefix, shared: true }; }
  };

  /* ----------------------------------------------------------
     Lead-submission inbox helpers.
     Form submissions land in /tellus_lead_submissions/<id>.
     Each doc holds the form data verbatim plus metadata:
       { submittedAt, processedAt, processedBy, processedCaseId,
         data: { 姓, 名, セイ, メイ, 電話番号, ... } }
     ---------------------------------------------------------- */
  const FS_LEAD_SUBMISSIONS = 'tellus_lead_submissions';

  async function listLeadSubmissions() {
    const colRef = collection(db, FS_LEAD_SUBMISSIONS);
    // We sort client-side so we don't require a composite index just for ordering.
    const snap = await getDocs(colRef);
    const out = [];
    snap.forEach(d => {
      const v = d.data() || {};
      out.push({ id: d.id, ...v });
    });
    out.sort((a, b) => String(b.submittedAt || '').localeCompare(String(a.submittedAt || '')));
    return out;
  }

  async function updateLeadSubmission(id, patch) {
    const ref = doc(db, FS_LEAD_SUBMISSIONS, id);
    const cur = await getDoc(ref);
    if (!cur.exists()) throw new Error('Submission not found: ' + id);
    await setDoc(ref, { ...cur.data(), ...patch }, { merge: true });
  }

  async function deleteLeadSubmission(id) {
    const ref = doc(db, FS_LEAD_SUBMISSIONS, id);
    await deleteDoc(ref);
  }

  /* ----------------------------------------------------------
     Business manuals helpers.
     Articles land in /tellus_manuals/<id> — full doc in Firestore
     so we can list/search/update them like any other collection.
     Each doc shape:
       { title, body, folderPath: ['業務マニュアル','顧客対応'],
         tags: [],
         createdAt, createdBy, updatedAt, updatedBy,
         attachments: [{id, name, type, size}],
         editingBy, editingUntil }
     ---------------------------------------------------------- */
  const FS_MANUALS = 'tellus_manuals';

  async function listManuals() {
    const colRef = collection(db, FS_MANUALS);
    const snap = await getDocs(colRef);
    const out = [];
    snap.forEach(d => out.push({ id: d.id, ...(d.data() || {}) }));
    out.sort((a, b) => String(a.title || '').localeCompare(String(b.title || ''), 'ja'));
    return out;
  }

  async function getManual(id) {
    const ref = doc(db, FS_MANUALS, id);
    const snap = await getDoc(ref);
    if (!snap.exists()) return null;
    return { id: snap.id, ...(snap.data() || {}) };
  }

  async function createManual(data) {
    // Use addDoc so Firestore generates the ID
    const colRef = collection(db, FS_MANUALS);
    const ref = await addDoc(colRef, data);
    return ref.id;
  }

  async function updateManual(id, patch) {
    const ref = doc(db, FS_MANUALS, id);
    await setDoc(ref, patch, { merge: true });
  }

  async function deleteManual(id) {
    const ref = doc(db, FS_MANUALS, id);
    await deleteDoc(ref);
  }

  /* ---------- LINE follower entries ---------- */
  const FS_LINE_FOLLOWERS = 'tellus_line_followers';

  async function listLineFollowers() {
    const colRef = collection(db, FS_LINE_FOLLOWERS);
    const snap = await getDocs(colRef);
    const out = [];
    snap.forEach(d => out.push({ id: d.id, ...(d.data() || {}) }));
    // Sort by registeredAt desc (newest first); fall back to createdAt
    out.sort((a, b) => {
      const ta = a.registeredAt || a.createdAt || '';
      const tb = b.registeredAt || b.createdAt || '';
      return String(tb).localeCompare(String(ta));
    });
    return out;
  }

  async function getLineFollower(id) {
    const ref = doc(db, FS_LINE_FOLLOWERS, id);
    const snap = await getDoc(ref);
    if (!snap.exists()) return null;
    return { id: snap.id, ...(snap.data() || {}) };
  }

  async function createLineFollower(data) {
    const colRef = collection(db, FS_LINE_FOLLOWERS);
    const ref = await addDoc(colRef, data);
    return ref.id;
  }

  async function updateLineFollower(id, patch) {
    const ref = doc(db, FS_LINE_FOLLOWERS, id);
    await setDoc(ref, patch, { merge: true });
  }

  async function deleteLineFollower(id) {
    const ref = doc(db, FS_LINE_FOLLOWERS, id);
    await deleteDoc(ref);
  }

  // Expose what the rest of the (non-module) code needs.
  window.fb = {
    auth,
    signIn: (email, password) => signInWithEmailAndPassword(auth, email, password),
    signOut: () => signOut(auth),
    onAuthStateChanged: (cb) => onAuthStateChanged(auth, cb),
    fsAdapter,
    storageFileAdapter,
    leadSubmissions: {
      list: listLeadSubmissions,
      update: updateLeadSubmission,
      delete: deleteLeadSubmission,
    },
    manuals: {
      list: listManuals,
      get: getManual,
      create: createManual,
      update: updateManual,
      delete: deleteManual,
    },
    lineFollowers: {
      list: listLineFollowers,
      get: getLineFollower,
      create: createLineFollower,
      update: updateLineFollower,
      delete: deleteLineFollower,
    },
  };

  // Tell the main script that Firebase finished loading.
  window.dispatchEvent(new Event('fb-ready'));



/* ============================================================
   TELLUS — 不動産案件管理システム v3
   ============================================================ */

const INDEX_KEY = 'tellus_index_v3';
con

Requests	IP Address	Location	AS Autonomous System
5	104.17.24.14	United States	AS13335Cloudflare, Inc.
2	142.251.14.95	United States	AS15169Google LLC
2	188.114.97.3	United States	AS13335Cloudflare, Inc.
2	142.251.13.94	United States	AS15169Google LLC
2	142.251.20.94	United States	AS15169Google LLC
13	5	-	-

Security Scan Report: tellus-5e4.pages.dev

Summary

AI Security Verdict

Moderate Risk

Risk Factors

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Detected Technologies3

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History