entertainment media

technology software

English

_ga_ZX1TZQKKPL

You're looking at domain 'cubari.moe' on the .moe top-level domain and has no subdomain. The core label 'cubari' covers 6 characters split between 3 vowels and 3 consonants. Segmentation suggests 2 words: cuba, ri. Expect three characters per word on average. No strong language cues emerged from the frequency lists.

rs-user-address

rs-sign-in-form

html/f7/98/f79875a1-d7f9-42de-b6b9-aab074dcd134.html.gz

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

script-src 'none'; form-action 'none'; frame-src 'none'; report-uri https://csp.withgoogle.com/csp/scaffolding/ascnsrsggc:113:0

ec3d2ce48e8adf1d79838a78b969be6a0b1edb01a0a5b555e28499e757796b7e

28a8f857ac4fdd3e89aa71927d9031d635d66af712b01b6daad8e4f7f7c2c493

9a3e697988d7f7c48771b462796a0177ac6302bcfc3b0b4891b6a8a5c311a73b

509b3bdd0cd5c51edade4035550db44d18757d9b2fd5663ef2a88b89eff2635f

e03717bd4a430d78fe03a889b7eb64f4cbbc70515a2caba99986f779f88dd431

09db34170497af1bee8c9de3e57ed2a00738755875242d9443b5e21d8744e108

12ae32cb1ec02d01eda3581b127c1fee3b0dc53572ed6baf239721a03d82e126

1d3bf8bb8755d73fdeec398c7af8c5dd8ce54cda5b9a2f0e700879239137da3a

f3172a11e45e995968377dd5a35195e35834854ed44e8731e58e7988159d44bf

95bd639ec9f0f9a1f2e4c714e607c599e0565a82ab0faa376857da9d9135f12c

58e20ec8dc020bda59aa972dd2defdbadc3ab55221fe33b12a76438352ee2c5d

26a7271dd8704ddaa4645ca3ffcba4fb38fe07c7c4d13890637a3c35b3e588af

972580f07d776299d35436daee74f33c9c06e3ad10f56e45f97776888ed0afa4

UPDATE: mangasee has been migrated to weebcentral

width=device-width, initial-scale=1, shrink-to-fit=no

viewport

apple-mobile-web-app-capable

apple-mobile-web-app-status-bar-style

theme-color

format-detection

The versatile manga-oriented image reader.

twitter:description

description

twitter:card

twitter:title

twitter:image

referrer

html/f7/98/f79875a1-d7f9-42de-b6b9-aab074dcd134_nodriver.html.gz

Cubari

NameCheap, Inc.

cubari.moe

Abuse

Google LLC

GOOGLE


  // remoteStorage backend that'll be our plugged in module
  // This should be abstracted from what actually handles updates,
  // since this'll give us the ability to pull this out in the future
  const RS_PATH = "cubari";

  const remoteStorage = (() => {
    // Define the schema for our history
    const Model = {name: RS_PATH, builder: (private) => {
      const SERIES_META = "series";
      const REPLACEMENT_STR = "{SOURCE_SLUG_REPLACEMENT}";
      const SERIES_META_PATH_BASE = "series/";
      const SERIES_META_PATH = `${SERIES_META_PATH_BASE}${REPLACEMENT_STR}`;

      private.declareType(SERIES_META, {
        type: "object",
        properties: {
          slug: {
            type: "string"
          },
          coverUrl: {
            type: "string"
          },
          source: {
            type: "string"
          },
          url: {
            type: "string"
          },
          title: {
            type: "string"
          },
          timestamp: {
            type: "number"
          },
          chapters: {
            type: "array",
            default: [] // Note that these aren't validated by our schema handler
          },
          pinned: {
            type: "boolean",
            default: false // Thus it's documenting only; handle it
          }
        },
        required: ["slug", "source", "url", "title", "timestamp", "chapters", "pinned"]
      });

      let firstPartyValidator = (source) => {
        return (source === "manga" || source === "series" || source === "default");
      };

      let pathBuilder = (path, slug, source) => {
        if (!source) source = "default";
        if (firstPartyValidator(source)) source = "default";
        source = source.replace(" ", "_");
        return path.replace(REPLACEMENT_STR, `${source}-${slug}`);
      };

      let seriesBuilder = (slug, coverUrl, source, url, title, pinned, chapters) => {
        source = source.replace(" ", "_");
        if (firstPartyValidator(source)) {
          source = "default";
          pinned = true; // First party chapters always pinned
        }
        return {
          slug: slug,
          coverUrl: coverUrl || "",
          source: source,
          url: url,
          title: title,
          timestamp: Date.now(),
          chapters: chapters || [],
          pinned: (pinned === undefined) ? false : pinned
        };
      };

      return {
        exports: {
          firstPartyHandler: (source) => {
            return firstPartyValidator(source) ? "default" : source;
          },
          slugBuilder: (slug, source) => {
            return `${source}-${slug}`;
          },
          addSeries: (slug, coverUrl, source, url, title, pinned, chapters) => {
            let toStore = seriesBuilder(slug, coverUrl, source, url, title, pinned, chapters);
            return private.storeObject(
              SERIES_META,
              pathBuilder(SERIES_META_PATH, slug, source),
              toStore);
          },
          editSeries: async (slug, coverUrl, source, url, title, pinned, chapters) => {
            let obj = await private.getObject(pathBuilder(SERIES_META_PATH, slug, source));
            if (obj) {
              let toStore = seriesBuilder(
                slug || obj.slug,
                coverUrl || obj.coverUrl,
                source || obj.source,
                url || obj.url,
                title || obj.title,
                (pinned !== undefined) ? pinned : obj.pinned,
                chapters || obj.chapters // Empty array is truthy
              );
              return private.storeObject(
                SERIES_META,
                pathBuilder(SERIES_META_PATH, slug, source),
                toStore
              )
            } else {
              // Fail-fast instead of adding the series
              throw new Error("Cannot edit a non-existent series.");
            }
          },
          getSeries: (slug, source) => {
            return private.getObject(pathBuilder(SERIES_META_PATH, slug, source));
          },
          removeSeries: (slug, source) => {
            return private.remove(pathBuilder(SERIES_META_PATH, slug, source));
          },
          getAllSeries: () => {
            // Note for the future: getAll gives you the objects within, while
            // getListing gives you just a list of files; thus, this gives you the
            // metadata within
            if (private.storage.connected) {
              // maxAge cache in millis
              return private.getAll(SERIES_META_PATH_BASE, 30000);
            } else {
              // Promise resolves immediately if no storage is connected
              // https://remotestoragejs.readthedocs.io/en/v1.2.3/js-api/base-client.html#caching-logic-for-read-operations
              return private.getAll(SERIES_META_PATH_BASE);
            }
          }
        }
      }
    }};

    let remoteStorage = new RemoteStorage({cache: true, modules: [Model]});

    remoteStorage.access.claim(RS_PATH, "rw");
    remoteStorage.caching.enable(`/${RS_PATH}/`);

    return remoteStorage;
  })();

  // This will be the main handler that deals with both
  // chapter and series history. All logic should be here
  // and abstracted from the rest of the code
  const globalHistoryHandler = (() => {
    const STORAGE_KEY = "proxyHistory";
    const SORT_KEY = "timestamp";
    const MAX_VALUES = 20;

    // Helper to return an array of objects from a nested object, sorted by key
    let sortObjectByKey = (obj, key) => {
      let sortable = [];
      for (let k in obj) {
        sortable.push(obj[k]);
      }
      sortable.sort((f, s) => s[key] - f[key]);
      return sortable;
    };

    const sync = async () => {
      // Sync operation ensures the local cache doesn't have any dangling objects.
      // We'll sort for the timestamp key since that's what we use everywhere else
      let allSeries = await remoteStorage[RS_PATH].getAllSeries();
      for (const [key, value] of Object.entries(allSeries)) {
        try {
          if (!value[SORT_KEY]) {
            // We don't use split here since the slug can potentially include "-"
            let separatorIndex = key.indexOf("-");
            let slug = key.slice(separatorIndex + 1);
            let source = key.slice(0, separatorIndex);
            await remoteStorage[RS_PATH].removeSeries(slug, source);
          }
        } catch (e) {
          console.error("[Global History] Sync error, continuing.");
        }
      }
    };

    const enabled = () => {
      return localStorage.getItem(STORAGE_KEY) ? true : false;
    };

    const enable = () => {
      let settings = localStorage.getItem("settings");
      let redirected = localStorage.getItem("redirected");
      let storageOnce = localStorage.getItem("storageOnce");
      localStorage.clear();
      if (settings) localStorage.setItem("settings", settings);
      if (redirected) localStorage.setItem("redirected", redirected);
      if (storageOnce) localStorage.setItem("storageOnce", storageOnce);
      localStorage.setItem(STORAGE_KEY, true);
    };

    const disable = () => {
      let settings = localStorage.getItem("settings");
      let redirected = localStorage.getItem("redirected");
      let storageOnce = localStorage.getItem("storageOnce");
      localStorage.clear();
      if (settings) localStorage.setItem("settings", settings);
      if (redirected) localStorage.setItem("redirected", redirected);
      if (storageOnce) localStorage.setItem("storageOnce", storageOnce);
    };

    const pushSeries = async (slug, coverUrl, source, url, title) => {
      await sync();
      source = remoteStorage[RS_PATH].firstPartyHandler(source);
      let allCurrentSeries = sortObjectByKey(await remoteStorage[RS_PATH].getAllSeries() || {}, SORT_KEY);
      let existingSeries = allCurrentSeries.find((e) => e.slug === slug && e.source === source.replace(" ", "_"));

      allCurrentSeries = allCurrentSeries.filter(e => !e.pinned);

      // Be mindful of the cap regardless of the state of the tree
      while ((allCurrentSeries.length + ((existingSeries) ? 0 : 1)) > MAX_VALUES) {
        let last = allCurrentSeries.pop();
        await remoteStorage[RS_PATH].removeSeries(last.slug, last.source);
      }

      if (existingSeries) {
        // Effectively this updates the timestamp of the series, pushing it to the top
        return remoteStorage[RS_PATH].editSeries(slug, coverUrl, source, url, title, existingSeries.pinned, existingSeries.chapters);
      } else {
        return remoteStorage[RS_PATH].addSeries(slug, coverUrl, source, url, title, undefined, undefined);
      }
    };

    const removeSeries = async (slug, source) => {
      await sync();
      return remoteStorage[RS_PATH].removeSeries(slug, source);
    };

    const removeAllUnpinnedSeries = async () => {
      let series = await globalHistoryHandler.getAllUnpinnedSeries();
      if(series) {
        Array.prototype.forEach.call(series, srs => {
            removeSeries(srs.slug, srs.source)
        })
      }
    };

    const addChapters = async (slug, source, chapters) => {
      let existingSeries = await remoteStorage[RS_PATH].getSeries(slug, source);

      if (existingSeries) {
        chapters = [...new Set([...chapters, ...existingSeries.chapters])];
        return remoteStorage[RS_PATH].editSeries(slug, undefined, source, undefined, undefined, undefined, chapters);
      } else {
        console.error("[Global History] addChapters - Series didn't exist.");
      }
    };

    const addChapter = async (slug, source, chapter) => {
      return addChapters(slug, source, [chapter]);
    };

    const removeChapter = async (slug, source, chapter) => {
      let existingSeries = await remoteStorage[RS_PATH].getSeries(slug, source);

      if (existingSeries) {
        chapters = existingSeries.chapters.filter(e => e !== chapter);
        return remoteStorage[RS_PATH].editSeries(slug, undefined, source, undefined, undefined, undefined, chapters);
      } else {
        console.error("[Global History] removeChapter - Series didn't exist.");
      }
    };

    const removeAllChapters = async (slug, source) => {
      let existingSeries = await remoteStorage[RS_PATH].getSeries(slug, source);

      if (existingSeries) {
        return remoteStorage[RS_PATH].editSeries(slug, undefined, source, undefined, undefined, undefined, []);
      } else {
        console.error("[Global History] removeAllChapters - series didn't exist.");
      }
    };

    const getReadChapters = async (slug, source) => {
      let existingSeries = await remoteStorage[RS_PATH].getSeries(slug, source);

      if (existingSeries) {
        return existingSeries.chapters;
      } else {
        console.error("[Global History] getReadChapters - series didn't exist.");
      }
    };

    const pinSeries = async (slug, source) => {
      let existingSeries = await remoteStorage[RS_PATH].getSeries(slug, source);

      if (existingSeries) {
        return remoteStorage[RS_PATH].editSeries(slug, undefined, source, undefined, undefined, true, undefined);
      } else {
        console.error("[Global History] pinSeries - series didn't exist.");
      }
    };

    const unpinSeries = async (slug, source) => {
      let existingSeries = await remoteStorage[RS_PATH].getSeries(slug, source);

      if (existingSeries) {
        return remoteStorage[RS_PATH].editSeries(slug, undefined, source, undefined, undefined, false, undefined);
      } else {
        console.error("[Global History] unpinSeries - series didn't exist.");
      }
    };

    const getAllPinnedSeries = async () => {
      await sync();
      return sortObjectByKey(await remoteStorage[RS_PATH].getAllSeries() || {}, SORT_KEY).filter(e => e.pinned);
    };

    const getAllUnpinnedSeries = async () => {
      await sync();
      return sortObjectByKey(await remoteStorage[RS_PATH].getAllSeries() || {}, SORT_KEY).filter(e => !e.pinned);
    };

    return {
      max: MAX_VALUES,
      enabled,
      pushSeries,
      removeSeries,
      removeAllUnpinnedSeries,
      addChapters,
      addChapter,
      removeChapter,
      removeAllChapters,
      getReadChapters,
      pinSeries,
      unpinSeries,
      getAllPinnedSeries,
      getAllUnpinnedSeries,
      toggle: {
        enable,
        disable
      }
    };
  })();

  const tag = () => {
    try {
      let coverUrl = JSON.parse(document.getElementById("history_coverUrl").textContent);

      let source = JSON.parse(document.getElementById("history_source").textContent);

      if (!source) {
        source = window.location.pathname
        .split("/")
        .filter(e => e)[1]
        .replace("_", " ");
      } else {
        source = source.split("/")[1];
      }

      let slug = JSON.parse(document.getElementById("history_slug").textContent);

      let url = JSON.parse(document.getElementById("history_url").textContent);

      if (url) {
        url = `/${url}`.split(slug)[0] + slug;
      }

      let title = JSON.parse(document.getElementById("history_title").textContent);

      if (source && slug && url && title) {
        remoteStorage.on("ready", async () => {
          await globalHistoryHandler.pushSeries(slug, coverUrl, source, url, title);
          window.dispatchEvent(new CustomEvent("history-ready"));
        });
      }
    } catch (e) {
      // Do nothing, silently fail.
    }
  };
window.addEventListener("load", async () => {
  if((await localStorage.getItem('storageOnce')) == "1") return;
  if (!globalHistoryHandler.enabled()) {
    globalHistoryHandler.toggle.enable();
    localStorage.setItem('storageOnce', "1")
  }
})



  window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments);}
  gtag('js', new Date());

  gtag('config', 'G-ZX1TZQKKPL');


document.querySelector('.header-wrapper h2').innerHTML =
	([
		'That one cool web manga reader.',	
		`${Math.round((new Date().getTime() - new Date("07/15/2019").getTime()) / (1000 * 3600 * 24))} days of uptime.`,
		`No accounts, no problems.`,
		`Read Kaguya.`,
		`For legal reasons, we don't host anything.`,
		`The reader could be better.`,
		`Did you know that the reader has, like, options and stuff?`,
		`Advanced.`,
		`We gotchu, Mangadex.`,
		`Everyone get on the lifeboats, the main ship is down!`,
		`We're under heavy load, please come back later... Just kidding.`,
	])[Math.round(Math.random()*10)]

isiOSAux = (window.navigator.standalone == true);
		if(isiOSAux) {
			var aList = document.getElementsByTagName("a");
			for(var i=0; i<aList.length; i++) {
				if(!aList[i].onclick
				&& aList[i].href.length > 0
				&& aList[i].href.indexOf(document.location.origin) > -1) {
					aList[i].onclick = function() {
						window.location = this.getAttribute("href");
						return false;
					}
				}
			}
		}

Requests	IP Address	Location	AS Autonomous System
7	172.217.16.200	United States	AS15169Google LLC
4	142.251.36.106	United States	AS15169Google LLC
4	142.250.201.67	United States	AS15169Google LLC
4	104.21.9.36	United States	AS13335Cloudflare, Inc.
19	4	-	-

Security Scan Report: cubari.moe

Summary

AI Security Verdict

Safe Website

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Detected Technologies7

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