@everipedia/iq-utils 1.0.1 → 2.0.0

package/dist/index.js

@@ -0,0 +1,650 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/data/constants.ts
+var WIKI_SUMMARY_MAX_LENGTH = 255;
+var WIKI_CONTENT_MIN_WORDS = 100;
+var WIKI_TITLE_MAX_LENGTH = 60;
+var MEDIA_UPLOAD_PENDING_SUFFIX = "default";
+var MAX_MEDIA_COUNT = 25;
+var IPFS_HASH_LENGTH = 46;
+var EditorContentOverride = "%OVERRIDE@EDITOR@MARKDOWN%";
+var CreateNewWikiSlug = "/*CREATE+NEW+WIKI*/";
+var MIN_CONTENT_WORD_COUNT = 10;
+var GOOD_CONTENT_WORD_COUNT = 500;
+var IDEAL_CONTENT_WORD_COUNT = 1500;
+var CONTENT_SCORE_WEIGHT = 0.8;
+var INTERNAL_LINKS_SCORE_WEIGHT = 0.5;
+var CITATIONS_SCORE_WEIGHT = 0.5;
+var MEDIA_SCORE_WEIGHT = 0.3;
+var TAGS_SCORE_WEIGHT = 0.3;
+var SUMMARY_SCORE_WEIGHT = 0.5;
+var SOCIAL_SCORE_WEIGHT = 0.5;
+var IDEAL_INTERNAL_LINKS_COUNT = 10;
+var IDEAL_CITATIONS_COUNT = 10;
+var IDEAL_MEDIA_COUNT = 5;
+var IDEAL_TAGS_COUNT = 3;
+var IDEAL_SUMMARY_LENGTH = 100;
+var IDEAL_SOCIAL_MEDIA_COUNT = 4;
+var WHITELISTED_DOMAINS = [
+  "youtube.com/watch",
+  "youtu.be",
+  "vimeo.com",
+  "alpha.everipedia.org/wiki",
+  "beta.everipedia.org/wiki",
+  "iq.wiki/wiki",
+  "ipfs.everipedia.org/ipfs"
+];
+var WHITELISTED_LINK_NAMES = ["YOUTUBE@VID", "DUNE@EMBED"];
+
+// src/lib/wiki-helpers.ts
+var countWords = (text) => text.split(" ").filter((word) => word !== "").length;
+var isValidUrl = (urlString) => {
+  try {
+    return Boolean(new URL(urlString));
+  } catch (_e) {
+    return false;
+  }
+};
+var validateMediaContent = (media) => {
+  return media.every((item) => {
+    if (item.source === MediaSource.Enum.IPFS_IMG || item.source === MediaSource.Enum.IPFS_VID) {
+      return item.id.length === IPFS_HASH_LENGTH;
+    }
+    if (item.source === MediaSource.Enum.YOUTUBE) {
+      const youtubePattern = /^.*(?:youtu\.be\/|v\/|vi\/|u\/\w\/|embed\/|shorts\/|watch\?v=)([^#&?]*).*/;
+      return item.id === `https://www.youtube.com/watch?v=${item.name}` && youtubePattern.test(item.id);
+    }
+    if (item.source === MediaSource.Enum.VIMEO) {
+      return item.id === `https://vimeo.com/${item.name}`;
+    }
+    return item.type ? item.type in MediaType : true;
+  });
+};
+var validateMediaCount = (media) => {
+  const iconMediaCount = media.filter(
+    (item) => item.type === MediaType.Enum.ICON
+  ).length;
+  return media.length <= MAX_MEDIA_COUNT && iconMediaCount <= 1;
+};
+var validateEventWiki = (wiki) => {
+  if (wiki.tags.some((tag) => tag.id === "Events")) {
+    const referencesData = wiki.metadata.find((meta) => meta.id === CommonMetaIds.Enum.references)?.value || "[]";
+    const references = JSON.parse(
+      referencesData
+    );
+    const hasEventLink = references.some(
+      (item) => item.description.toLowerCase() === "event link"
+    );
+    return hasEventLink && Array.isArray(wiki.events) && wiki.events.length > 0;
+  }
+  return true;
+};
+var areContentLinksVerified = (content) => {
+  const markdownLinks = content.match(/\[(.*?)\]\((.*?)\)/g);
+  return markdownLinks?.every((link) => {
+    const [, linkText, linkUrl] = RegExp(/\[(.*?)\]\((.*?)\)/).exec(link) || [];
+    if (linkText && linkUrl && WHITELISTED_LINK_NAMES.includes(linkText) && !isValidUrl(linkUrl)) {
+      return true;
+    }
+    if (linkUrl && !linkUrl.startsWith("#")) {
+      const validDomainPattern = new RegExp(
+        `^https?://(www\\.)?(${WHITELISTED_DOMAINS.join("|")})`
+      );
+      return validDomainPattern.test(linkUrl);
+    }
+    return true;
+  }) ?? true;
+};
+
+// src/schema/index.ts
+var MediaType = zod.z.enum(["GALLERY", "ICON"]);
+var MediaSource = zod.z.enum(["IPFS_IMG", "VIMEO", "YOUTUBE", "IPFS_VID"]);
+var CommonMetaIds = zod.z.enum([
+  "references",
+  "website",
+  "contract_url",
+  "location",
+  "email_url",
+  "facebook_profile",
+  "instagram_profile",
+  "twitter_profile",
+  "linkedin_profile",
+  "youtube_profile",
+  "discord_profile",
+  "reddit_profile",
+  "telegram_profile",
+  "github_profile",
+  "coinmarketcap_url",
+  "coingecko_profile",
+  "opensea_profile",
+  "medium_profile",
+  "mirror_profile",
+  "tiktok_profile",
+  "etherscan_profile",
+  "arbiscan_profile",
+  "polygonscan_profile",
+  "bscscan_profile",
+  "optimistic_etherscan_profile",
+  "basescan_profile",
+  "ftmscan_profile",
+  "solscan_profile",
+  "avascan_profile",
+  "nearblocks_profile",
+  "troscan_profile",
+  "xrpscan_profile",
+  "kavascan_profile",
+  "tonscan_profile",
+  "celoscan_profile",
+  "cronoscan_profile",
+  "zkscan_profile",
+  "explorer_injective_profile",
+  "blastscan_profile"
+]);
+var EditSpecificMetaIds = zod.z.enum([
+  "previous_cid",
+  "commit-message",
+  "words-changed",
+  "percent-changed",
+  "blocks-changed",
+  "wiki-score"
+]);
+var ValidatorCodes = zod.z.enum([
+  "VALID_WIKI",
+  "ID_ERROR",
+  "LANGUAGE_ERROR",
+  "USER_ERROR",
+  "WORD_COUNT_ERROR",
+  "CATEGORY_ERROR",
+  "SUMMARY_ERROR",
+  "IMAGE_ERROR",
+  "TAG_ERROR",
+  "EXTERNAL_URL_ERROR",
+  "METADATA_ERROR",
+  "MEDIA_ERROR",
+  "GLOBAL_RATE_LIMIT",
+  "LINKED_WIKIS",
+  "EVENTS_ERROR"
+]);
+var LanguagesISO = zod.z.enum(["en", "es", "zh", "ko"]);
+var LinkedWikiKey = zod.z.enum(["founders", "blockchains", "speakers"]);
+var EventType = zod.z.enum(["CREATED", "DEFAULT", "MULTIDATE"]);
+var Tag = zod.z.enum([
+  "Artists",
+  "AI",
+  "BinanceSmartChain",
+  "Blockchains",
+  "CEXes",
+  "Collections",
+  "Collectors",
+  "Conference",
+  "DEXes",
+  "Developers",
+  "Entertainment",
+  "Ethereum",
+  "Events",
+  "Forum",
+  "Founders",
+  "Festival",
+  "Games",
+  "Glossary",
+  "Hackathon",
+  "Marketplaces",
+  "Memecoins",
+  "Organizations",
+  "Online",
+  "PeopleInDeFi",
+  "Polkadot",
+  "Polygon",
+  "Protocols",
+  "Solana",
+  "Speakers",
+  "Stablecoins",
+  "Venture"
+]);
+var Category = zod.z.enum([
+  "nfts",
+  "defi",
+  "exchanges",
+  "cryptocurrencies",
+  "daos",
+  "people",
+  "dapps",
+  "organizations"
+]);
+var ProfileLinks = zod.z.object({
+  twitter: zod.z.string().nullable(),
+  website: zod.z.string().nullable(),
+  instagram: zod.z.string().nullable()
+});
+var ProfileData = zod.z.object({
+  id: zod.z.string().nullable(),
+  username: zod.z.string().nullable(),
+  bio: zod.z.string().nullable(),
+  links: zod.z.array(ProfileLinks).nullable(),
+  banner: zod.z.string().nullable(),
+  avatar: zod.z.string().nullable()
+});
+var Image = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.string()
+});
+var Media = zod.z.object({
+  id: zod.z.string(),
+  size: zod.z.string().nullish(),
+  name: zod.z.string().nullish(),
+  type: MediaType.nullish(),
+  caption: zod.z.string().nullish(),
+  thumbnail: zod.z.string().nullish(),
+  source: MediaSource
+});
+var MetaData = zod.z.object({
+  id: zod.z.union([CommonMetaIds, EditSpecificMetaIds]),
+  value: zod.z.any()
+});
+var BaseCategory = zod.z.object({
+  id: Category,
+  title: zod.z.string()
+});
+var BaseEvents = zod.z.object({
+  id: zod.z.string().optional().nullable(),
+  date: zod.z.string().nullable(),
+  title: zod.z.string().optional().nullable(),
+  type: EventType.nullable(),
+  description: zod.z.string().optional().nullable(),
+  link: zod.z.string().optional().nullable(),
+  multiDateStart: zod.z.string().optional().nullable(),
+  multiDateEnd: zod.z.string().optional().nullable(),
+  continent: zod.z.string().optional().nullable(),
+  country: zod.z.string().optional().nullable(),
+  action: zod.z.enum(["DELETE", "EDIT", "CREATE"]).optional().nullable()
+});
+var WikiReference = zod.z.object({
+  id: zod.z.string(),
+  title: zod.z.string()
+});
+var Wiki = zod.z.object({
+  id: zod.z.string(),
+  title: zod.z.string().min(1, "Add a Title at the top for this Wiki to continue").max(
+    WIKI_TITLE_MAX_LENGTH,
+    `Title should be less than ${WIKI_TITLE_MAX_LENGTH} characters`
+  ),
+  ipfs: zod.z.string().optional(),
+  content: zod.z.string().min(1, "Add a Content section to continue").refine(
+    (content) => countWords(content) >= WIKI_CONTENT_MIN_WORDS,
+    `Add a minimum of ${WIKI_CONTENT_MIN_WORDS} words in the content section to continue`
+  ).refine(
+    areContentLinksVerified,
+    "Please remove all external links from the content"
+  ),
+  summary: zod.z.string().max(
+    WIKI_SUMMARY_MAX_LENGTH,
+    `Summary exceeds maximum limit of ${WIKI_SUMMARY_MAX_LENGTH}`
+  ),
+  images: zod.z.array(Image).min(1, "Add a main image on the right column to continue"),
+  categories: zod.z.array(BaseCategory).min(1, "Add one category to continue"),
+  tags: zod.z.array(
+    zod.z.object({
+      id: zod.z.string()
+    })
+  ).transform(
+    (tags) => tags.map((tag) => ({
+      id: Tag.parse(tag.id)
+    }))
+  ).refine(
+    (tags) => {
+      const invalidTags = tags.filter(
+        (tag) => !Tag.safeParse(tag.id).success
+      );
+      if (invalidTags.length > 0) {
+        throw new Error(
+          `Invalid tag(s) found: ${invalidTags.map((tag) => tag.id).join(", ")}`
+        );
+      }
+      return true;
+    },
+    {
+      message: "Invalid tag(s) found"
+    }
+  ),
+  media: zod.z.array(Media).max(MAX_MEDIA_COUNT).refine((media) => {
+    if (!media) return true;
+    return validateMediaContent(media) && validateMediaCount(media);
+  }, "Media is invalid").optional(),
+  metadata: zod.z.array(MetaData).refine((metadata) => {
+    const references = metadata.find(
+      (meta) => meta.id === CommonMetaIds.Enum.references
+    );
+    return !references?.value || references.value.length > 0;
+  }, "Please add at least one citation"),
+  events: zod.z.array(BaseEvents).optional().nullable(),
+  user: zod.z.object({
+    id: zod.z.string(),
+    profile: ProfileData.nullable()
+  }),
+  author: zod.z.object({
+    id: zod.z.string(),
+    profile: ProfileData.nullable()
+  }),
+  language: LanguagesISO.default(LanguagesISO.Enum.en),
+  version: zod.z.number().default(1),
+  hidden: zod.z.boolean().default(false),
+  promoted: zod.z.number().default(0),
+  views: zod.z.number().optional().default(0),
+  linkedWikis: zod.z.object({
+    [LinkedWikiKey.Enum.blockchains]: zod.z.array(zod.z.string()).optional().nullable(),
+    [LinkedWikiKey.Enum.founders]: zod.z.array(zod.z.string()).optional().nullable(),
+    [LinkedWikiKey.Enum.speakers]: zod.z.array(zod.z.string()).optional().nullable()
+  }).nullable().optional().default({}),
+  founderWikis: zod.z.array(WikiReference).optional().default([]),
+  blockchainWikis: zod.z.array(WikiReference).optional().default([])
+}).refine(
+  (arg) => validateEventWiki(
+    arg
+  ),
+  {
+    message: "Event wikis must have an event link citation and at least one event date",
+    path: ["events"]
+  }
+);
+var Reference = zod.z.object({
+  id: zod.z.string(),
+  description: zod.z.string(),
+  timestamp: zod.z.number(),
+  url: zod.z.string()
+});
+
+// src/lib/wiki-score.ts
+var contentQuality = (wordCount) => {
+  const scoreMin = 0;
+  const scoreMax = 1;
+  let score = 0;
+  if (wordCount < MIN_CONTENT_WORD_COUNT) {
+    return scoreMin;
+  }
+  if (wordCount >= MIN_CONTENT_WORD_COUNT && wordCount <= GOOD_CONTENT_WORD_COUNT) {
+    score = wordCount / GOOD_CONTENT_WORD_COUNT;
+    score *= 0.8;
+  }
+  if (wordCount > GOOD_CONTENT_WORD_COUNT && wordCount < IDEAL_CONTENT_WORD_COUNT) {
+    const baseScore = 0.8;
+    const wordCountAboveGood = wordCount - GOOD_CONTENT_WORD_COUNT;
+    const extraScoreFactor = wordCountAboveGood / (IDEAL_CONTENT_WORD_COUNT - GOOD_CONTENT_WORD_COUNT);
+    const extraScore = Math.sqrt(extraScoreFactor) * 0.2;
+    score = baseScore + extraScore;
+  }
+  if (wordCount >= IDEAL_CONTENT_WORD_COUNT) {
+    return scoreMax;
+  }
+  if (score < scoreMin) {
+    return scoreMin;
+  }
+  if (score > scoreMax) {
+    return scoreMax;
+  }
+  return score;
+};
+var countQuality = (idealCount, realCount) => {
+  const scoreMin = 0;
+  const scoreMax = 1;
+  const score = realCount / idealCount;
+  if (score < scoreMin) {
+    return scoreMin;
+  }
+  if (score > scoreMax) {
+    return scoreMax;
+  }
+  return score;
+};
+var getHostnameFromRegex = (url) => {
+  const matches = RegExp(/^https?:\/\/([^/?#]+)(?:[/?#]|$)/i).exec(url);
+  return matches?.[1];
+};
+var getWikiInternalLinks = (content) => {
+  const markdownLinkRegex = /\[(.*?)\]\((.*?)\)/g;
+  let internalLinksCount = 0;
+  let match = markdownLinkRegex.exec(content);
+  while (match !== null) {
+    const url = match[2];
+    if (url && !url.startsWith("#")) {
+      const hostname = getHostnameFromRegex(url);
+      if (hostname === "everipedia.org" || hostname === "iq.wiki" || hostname?.endsWith(".everipedia.org")) {
+        internalLinksCount++;
+      }
+    }
+    match = markdownLinkRegex.exec(content);
+  }
+  return internalLinksCount;
+};
+var getWikiCitationLinks = (wiki) => {
+  const rawWikiReferences = wiki.metadata.find(
+    (m) => m.id === CommonMetaIds.Enum.references
+  )?.value;
+  if (rawWikiReferences === void 0 || rawWikiReferences?.trim().length === 0) {
+    return 0;
+  }
+  const wikiReferences = JSON.parse(rawWikiReferences);
+  return wikiReferences.length;
+};
+var getSocialsCount = (wiki) => {
+  let socialsCount = 0;
+  for (const meta of wiki.metadata) {
+    if (CommonMetaIds.options.includes(meta.id)) {
+      if (meta.value) {
+        socialsCount += 1;
+      }
+    }
+  }
+  return socialsCount;
+};
+var calculateWikiScore = (wiki) => {
+  const wordCount = wiki.content.split(" ").length;
+  const internalLinksCount = getWikiInternalLinks(wiki.content);
+  const citationCount = getWikiCitationLinks(wiki);
+  const mediaCount = wiki.media?.length || 0;
+  const tagsCount = wiki.tags?.length || 0;
+  const summaryWordCount = wiki.summary?.length || 0;
+  const socialsCount = getSocialsCount(wiki);
+  const contentScore = contentQuality(wordCount);
+  const internalLinksScore = countQuality(
+    IDEAL_INTERNAL_LINKS_COUNT,
+    internalLinksCount
+  );
+  const citationScore = countQuality(IDEAL_CITATIONS_COUNT, citationCount);
+  const mediaScore = countQuality(IDEAL_MEDIA_COUNT, mediaCount);
+  const tagsScore = countQuality(IDEAL_TAGS_COUNT, tagsCount);
+  const summaryScore = countQuality(IDEAL_SUMMARY_LENGTH, summaryWordCount);
+  const socialsScore = countQuality(IDEAL_SOCIAL_MEDIA_COUNT, socialsCount);
+  const sumOfWeights = CONTENT_SCORE_WEIGHT + INTERNAL_LINKS_SCORE_WEIGHT + CITATIONS_SCORE_WEIGHT + MEDIA_SCORE_WEIGHT + TAGS_SCORE_WEIGHT + SUMMARY_SCORE_WEIGHT + SOCIAL_SCORE_WEIGHT;
+  const score = (contentScore * CONTENT_SCORE_WEIGHT + internalLinksScore * INTERNAL_LINKS_SCORE_WEIGHT + citationScore * CITATIONS_SCORE_WEIGHT + mediaScore * MEDIA_SCORE_WEIGHT + tagsScore * TAGS_SCORE_WEIGHT + summaryScore * SUMMARY_SCORE_WEIGHT + socialsScore * SOCIAL_SCORE_WEIGHT) / sumOfWeights;
+  const percentScore = Math.floor(score * 100);
+  return percentScore;
+};
+
+// src/lib/check-wiki-validity.ts
+var countWords2 = (text) => text.split(" ").filter((word) => word !== "").length;
+var isValidUrl2 = (urlString) => {
+  try {
+    return Boolean(new URL(urlString));
+  } catch (_e) {
+    return false;
+  }
+};
+var areContentLinksVerified2 = (content) => {
+  const markdownLinks = content.match(/\[(.*?)\]\((.*?)\)/g);
+  return markdownLinks?.every((link) => {
+    const [, linkText, linkUrl] = RegExp(/\[(.*?)\]\((.*?)\)/).exec(link) || [];
+    if (linkText && linkUrl && WHITELISTED_LINK_NAMES.includes(linkText) && !isValidUrl2(linkUrl)) {
+      return true;
+    }
+    if (linkUrl && !linkUrl.startsWith("#")) {
+      const validDomainPattern = new RegExp(
+        `^https?://(www\\.)?(${WHITELISTED_DOMAINS.join("|")})`
+      );
+      return validDomainPattern.test(linkUrl);
+    }
+    return true;
+  }) ?? true;
+};
+var isMediaValid = (wiki) => {
+  if (!wiki.media) return true;
+  const isMediaContentValid = wiki.media.every((media) => {
+    if (media.source === MediaSource.Enum.IPFS_IMG || media.source === MediaSource.Enum.IPFS_VID) {
+      return media.id.length === IPFS_HASH_LENGTH;
+    }
+    if (media.source === MediaSource.Enum.YOUTUBE) {
+      const youtubePattern = /^.*(?:youtu\.be\/|v\/|vi\/|u\/\w\/|embed\/|shorts\/|watch\?v=)([^#&?]*).*/;
+      return media.id === `https://www.youtube.com/watch?v=${media.name}` && youtubePattern.test(media.id);
+    }
+    if (media.source === MediaSource.Enum.VIMEO) {
+      return media.id === `https://vimeo.com/${media.name}`;
+    }
+    return media.type ? MediaType.options.includes(media.type) : true;
+  });
+  const iconMediaCount = wiki.media.filter(
+    (media) => media.type === MediaType.Enum.ICON
+  ).length;
+  return wiki.media.length <= MAX_MEDIA_COUNT && isMediaContentValid && iconMediaCount <= 1;
+};
+var isAnyMediaUploading = (wiki) => wiki.media?.some((media) => media.id.endsWith(MEDIA_UPLOAD_PENDING_SUFFIX)) ?? false;
+var isEventUrlMissing = (wiki) => {
+  if (wiki.tags.some((tag) => tag.id === "Events")) {
+    const referencesData = wiki.metadata.find((meta) => meta.id === CommonMetaIds.Enum.references)?.value || "[]";
+    const references = JSON.parse(referencesData);
+    return !references.some(
+      (item) => item.description.toLowerCase() === "event link"
+    );
+  }
+  return false;
+};
+var isEventDateMissing = (wiki) => wiki.tags.some((tag) => tag.id === "Events") && wiki.events?.length === 0;
+var isSummaryTooLong = (wiki) => !!(wiki.summary && wiki.summary.length > WIKI_SUMMARY_MAX_LENGTH);
+var hasNoCitations = (wiki) => {
+  const references = wiki.metadata.find(
+    (meta) => meta.id === CommonMetaIds.Enum.references
+  );
+  return !references?.value || references.value.length === 0;
+};
+var validateWiki = (wiki) => {
+  const wordCount = countWords2(wiki.content || "");
+  if (!wiki.title) {
+    return {
+      isValid: false,
+      error: "Add a Title at the top for this Wiki to continue"
+    };
+  }
+  if (wiki.title.length > WIKI_TITLE_MAX_LENGTH) {
+    return {
+      isValid: false,
+      error: `Title should be less than ${WIKI_TITLE_MAX_LENGTH} characters`
+    };
+  }
+  if (!wiki.content) {
+    return { isValid: false, error: "Add a Content section to continue" };
+  }
+  if (wordCount < WIKI_CONTENT_MIN_WORDS) {
+    return {
+      isValid: false,
+      error: `Add a minimum of ${WIKI_CONTENT_MIN_WORDS} words in the content section to continue. You have written ${wordCount}`
+    };
+  }
+  if (!areContentLinksVerified2(wiki.content)) {
+    return {
+      isValid: false,
+      error: "Please remove all external links from the content"
+    };
+  }
+  if (!wiki.images?.length) {
+    return {
+      isValid: false,
+      error: "Add a main image on the right column to continue"
+    };
+  }
+  if (wiki.categories.length === 0) {
+    return { isValid: false, error: "Add one category to continue" };
+  }
+  if (isSummaryTooLong(wiki)) {
+    return {
+      isValid: false,
+      error: `Summary exceeds maximum limit of ${WIKI_SUMMARY_MAX_LENGTH}`
+    };
+  }
+  if (isAnyMediaUploading(wiki)) {
+    return {
+      isValid: false,
+      error: "Some media are still uploading, please wait"
+    };
+  }
+  if (hasNoCitations(wiki)) {
+    return { isValid: false, error: "Please add at least one citation" };
+  }
+  if (isEventUrlMissing(wiki)) {
+    return {
+      isValid: false,
+      error: "Please cite the event official website with 'Event Link' description"
+    };
+  }
+  if (isEventDateMissing(wiki)) {
+    return {
+      isValid: false,
+      error: 'Please open the "Edit Wiki Details Modal" and enter a valid event date'
+    };
+  }
+  if (!isMediaValid(wiki)) {
+    return { isValid: false, error: "Media is invalid" };
+  }
+  return { isValid: true };
+};
+
+exports.BaseEvents = BaseEvents;
+exports.CITATIONS_SCORE_WEIGHT = CITATIONS_SCORE_WEIGHT;
+exports.CONTENT_SCORE_WEIGHT = CONTENT_SCORE_WEIGHT;
+exports.Category = Category;
+exports.CommonMetaIds = CommonMetaIds;
+exports.CreateNewWikiSlug = CreateNewWikiSlug;
+exports.EditSpecificMetaIds = EditSpecificMetaIds;
+exports.EditorContentOverride = EditorContentOverride;
+exports.GOOD_CONTENT_WORD_COUNT = GOOD_CONTENT_WORD_COUNT;
+exports.IDEAL_CITATIONS_COUNT = IDEAL_CITATIONS_COUNT;
+exports.IDEAL_CONTENT_WORD_COUNT = IDEAL_CONTENT_WORD_COUNT;
+exports.IDEAL_INTERNAL_LINKS_COUNT = IDEAL_INTERNAL_LINKS_COUNT;
+exports.IDEAL_MEDIA_COUNT = IDEAL_MEDIA_COUNT;
+exports.IDEAL_SOCIAL_MEDIA_COUNT = IDEAL_SOCIAL_MEDIA_COUNT;
+exports.IDEAL_SUMMARY_LENGTH = IDEAL_SUMMARY_LENGTH;
+exports.IDEAL_TAGS_COUNT = IDEAL_TAGS_COUNT;
+exports.INTERNAL_LINKS_SCORE_WEIGHT = INTERNAL_LINKS_SCORE_WEIGHT;
+exports.IPFS_HASH_LENGTH = IPFS_HASH_LENGTH;
+exports.Image = Image;
+exports.MAX_MEDIA_COUNT = MAX_MEDIA_COUNT;
+exports.MEDIA_SCORE_WEIGHT = MEDIA_SCORE_WEIGHT;
+exports.MEDIA_UPLOAD_PENDING_SUFFIX = MEDIA_UPLOAD_PENDING_SUFFIX;
+exports.MIN_CONTENT_WORD_COUNT = MIN_CONTENT_WORD_COUNT;
+exports.Media = Media;
+exports.MediaSource = MediaSource;
+exports.MediaType = MediaType;
+exports.Reference = Reference;
+exports.SOCIAL_SCORE_WEIGHT = SOCIAL_SCORE_WEIGHT;
+exports.SUMMARY_SCORE_WEIGHT = SUMMARY_SCORE_WEIGHT;
+exports.TAGS_SCORE_WEIGHT = TAGS_SCORE_WEIGHT;
+exports.Tag = Tag;
+exports.ValidatorCodes = ValidatorCodes;
+exports.WHITELISTED_DOMAINS = WHITELISTED_DOMAINS;
+exports.WHITELISTED_LINK_NAMES = WHITELISTED_LINK_NAMES;
+exports.WIKI_CONTENT_MIN_WORDS = WIKI_CONTENT_MIN_WORDS;
+exports.WIKI_SUMMARY_MAX_LENGTH = WIKI_SUMMARY_MAX_LENGTH;
+exports.WIKI_TITLE_MAX_LENGTH = WIKI_TITLE_MAX_LENGTH;
+exports.Wiki = Wiki;
+exports.areContentLinksVerified = areContentLinksVerified2;
+exports.calculateWikiScore = calculateWikiScore;
+exports.countWords = countWords2;
+exports.hasNoCitations = hasNoCitations;
+exports.isAnyMediaUploading = isAnyMediaUploading;
+exports.isEventDateMissing = isEventDateMissing;
+exports.isEventUrlMissing = isEventUrlMissing;
+exports.isMediaValid = isMediaValid;
+exports.isSummaryTooLong = isSummaryTooLong;
+exports.isValidUrl = isValidUrl2;
+exports.validateWiki = validateWiki;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map