10837608931

Committed 12 Sep 2024 07:38PM UTC coverage: 31.833% (-0.04%) from 31.871%

Build # 10837608931

Build Type

Pull #9740

github

Committed by

darkruby501

Commit Message

non-broken state of things

Pull Request Pull Request #9740: new tab with hybrid embedding recommendations

Run Details

5070 of 41383 branches covered (12.25%)

Branch coverage included in aggregate %.

35 of 157 new or added lines in 14 files covered. (22.29%)

146 existing lines in 10 files now uncovered.

29429 of 66993 relevant lines covered (43.93%)

184.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

60.98

/packages/lesswrong/server/search/elastic/ElasticConfig.ts

import type {
  MappingProperty,
  QueryDslQueryContainer,
} from "@elastic/elasticsearch/lib/api/types";
import { SearchIndexCollectionName } from "../../../lib/search/searchUtil";
import { postStatuses } from "../../../lib/collections/posts/constants";
import { isEAForum } from "../../../lib/instanceSettings";
import { isFriendlyUI } from "@/themes/forumTheme";

export type Ranking = {
  field: string,
  order: "asc" | "desc",
  weight?: number,
  scoring: {
    type: "numeric",
    pivot: number,
    min?: number,
  } | {
    type: "date",
  } | {
    type: "bool",
  },
}

export type Mappings = Record<string, MappingProperty>;

export type IndexConfig = {
  /**
   * An array of field names that compared against the search query.
   * By default, this uses a fuzzy full text search. The first field listed will also
   * be checked for an exact match, otherwise order doesn't matter.
   * Field names may be appended with a relevance boost. For instance, "title^3", which
   * will make matches on that field 3 times more relevant than matches on other fields.
   * You never need to include objectID here as that is always checked separately.
   */
  fields: string[],
  /**
   * The name of the field to create a match snippet from.
   */
  snippet: string,
  /**
   * The name of the field to create a match highlight from.
   */
  highlight?: string,
  /**
   * An array of ranking specifications to manually tune the relevancy of results.
   * Ordering does not matter.
   */
  ranking?: Ranking[],
  /**
   * The name of the field to use as a tie-breaker in the event that multiple results
   * have exactly the same ranking (normally a date and ideally guaranteed to be
   * unique). Note that relevancy is calculated as a floating point number so the
   * probability of two results actually having the same relevancy is extremely low.
   */
  tiebreaker: string,
  /**
   * Filters to completely remove entries from the result set, irregardless of their
   * relevancy to the query. This is often used to remove deleted data.
   */
  filters?: QueryDslQueryContainer[],
  /**
   * Mappings define the schema of the table. In general, elasticsearch infers the
   * type of data when it is inserted so we do not need to keep a complete schema
   * here with all the fields listed (see the serach export queries in the repos for
   * the ultimate source of truth on what data is exported).
   * We only need to add a field here if we know that elastic will infer the wrong
   * type. Most notably, all strings are infered to be of type "text", which means
   * they get stemmed and analyzed - this is normally what we want but leads to bad
   * results when used on more structured strings like ids or slugs, which should
   * instead be given the "keyword" mapping.
   * Note that making a change here requires reindexing the data with
   * `Globals.elasticConfigureIndex`.
   */
  mappings?: Mappings,
  /**
   * An array of field names that should not be sent to the client. This may be
   * because the data is private, or just because it isn't needed and we want to
   * save on network traffic.
   */
  privateFields: string[],
  /**
   * The name of the field to sort on when sorting by karma. Defaults to
   * `baseScore` if not defined.
   */
  karmaField?: string,
  /**
   * Field used for location based geo-sorting
   */
  locationField?: string,
}

/**
 * Fields that use full-text search (ie; generally all of the fields that are
 * listed in the `field` array) should use this mapping. This allows us to use
 * our normal full text analyzer with stemming and synonyms for normal searches,
 * but to fall back to the exact analyzer which has no stemming for advanced
 * searches using quotes.
 */
const fullTextMapping: MappingProperty = {
  type: "text",
  analyzer: "fm_synonym_analyzer",
  fields: {
    exact: {
      type: "text",
      analyzer: "fm_exact_analyzer",
    },
    sort: {
      type: "keyword",
      normalizer: "fm_sortable_keyword",
    },
  },
};

/**
 * The shingle text mapping is particularly suited to short text fields that
 * often contain punctuation but not a lot of semantic meaning, such as
 * usernames.
 */
const shingleTextMapping: MappingProperty = {
  type: "text",
  analyzer: "fm_shingle_analyzer",
  fields: {
    exact: {
      type: "text",
      analyzer: "fm_exact_analyzer",
    },
    sort: {
      type: "keyword",
      normalizer: "fm_sortable_keyword",
    },
  },
};

const geopointMapping: MappingProperty = {
  type: "geo_point",
};

/**
 * Fields that should not be analyzed at all (ie; ids, slugs or enums) should
 * use a keyword mapping.
 */
const keywordMapping: MappingProperty = {
  type: "keyword",
};

const objectMapping = (
  properties: Record<string, MappingProperty>,
): MappingProperty => ({properties});

const elasticSearchConfig: Record<SearchIndexCollectionName, IndexConfig> = {
  Comments: {
    fields: [
      "body",
      "authorDisplayName^11",
    ],
    snippet: "body",
    highlight: "authorDisplayName",
    ranking: [
      {
        field: "baseScore",
        order: "desc",
        weight: 0.5,
        scoring: {type: "numeric", pivot: 20},
      },
      {
        field: "baseScore",
        order: "desc",
        weight: 1.5,
        scoring: {type: "numeric", pivot: 50, min: 50},
      },
    ],
    tiebreaker: "publicDateMs",
    filters: [
      {term: {deleted: false}},
      {term: {rejected: false}},
      {term: {authorIsUnreviewed: false}},
      {term: {retracted: false}},
      {term: {spam: false}},
    ],
    mappings: {
      body: fullTextMapping,
      postTitle: fullTextMapping,
      authorDisplayName: shingleTextMapping,
      authorUserName: shingleTextMapping,
      authorSlug: shingleTextMapping,
      postGroupId: keywordMapping,
      postSlug: keywordMapping,
      userId: keywordMapping,
      tags: keywordMapping,
      tagId: keywordMapping,
      tagSlug: keywordMapping,
      tagCommentType: keywordMapping,
    },
    privateFields: [
      "authorIsUnreviewed",
      "deleted",
      "legacy",
      "rejected",
      "retracted",
      "spam",
    ],
  },
  Posts: {
    fields: [
      "title^3",
      "authorDisplayName^4",
      "body",
    ],
    snippet: "body",
    highlight: "title",
    ranking: [
      {
        field: "baseScore",
        order: "desc",
        weight: 8,
        scoring: {type: "numeric", pivot: 20},
      },
    ],
    tiebreaker: "publicDateMs",
    filters: [
      {term: {isFuture: false}},
      {term: {draft: false}},
      {term: {rejected: false}},
      {term: {authorIsUnreviewed: false}},
      {term: {status: postStatuses.STATUS_APPROVED}},
      ...(isEAForum ? [] : [{range: {baseScore: {gte: 0}}}]),
    ],
    mappings: {
      title: fullTextMapping,
      authorDisplayName: shingleTextMapping,
      authorFullName: shingleTextMapping,
      authorSlug: shingleTextMapping,
      body: fullTextMapping,
      feedLink: keywordMapping,
      slug: keywordMapping,
      tags: keywordMapping,
      url: keywordMapping,
      userId: keywordMapping,
    },
    privateFields: [
      "authorIsUnreviewed",
      "draft",
      "isFuture",
      "legacy",
      "rejected",
      "status",
      "viewCount",
    ],
  },
  Users: {
    fields: [
      "displayName^10000",
      "bio",
      "mapLocationAddress",
      "jobTitle",
      "organization",
      "howICanHelpOthers",
      "howOthersCanHelpMe",
      ...(isFriendlyUI
        ? [
          "tags.name",
          "posts.title",
        ]
        : []),
    ],
    snippet: "bio",
    ranking: [
      {
        field: "karma",
        order: "desc",
        weight: 2,
        scoring: {type: "numeric", pivot: 5000, min: 1000},
      },
      {
        field: "karma",
        order: "desc",
        weight: 1.5,
        scoring: {type: "numeric", pivot: 1000, min: 1000},
      },
      {
        field: "karma",
        order: "desc",
        weight: 1,
        scoring: {type: "numeric", pivot: 100, min: 10},
      },
      {
        field: "createdAt",
        order: "desc",
        weight: 0.5,
        scoring: {type: "date"},
      },
    ],
    tiebreaker: "karma",
    filters: [
      {term: {deleted: false}},
      {term: {deleteContent: false}},
    ],
    mappings: {
      displayName: shingleTextMapping,
      bio: fullTextMapping,
      mapLocationAddress: fullTextMapping,
      jobTitle: fullTextMapping,
      organization: fullTextMapping,
      howICanHelpOthers: fullTextMapping,
      howOthersCanHelpMe: fullTextMapping,
      careerStage: keywordMapping,
      groups: keywordMapping,
      slug: shingleTextMapping,
      website: keywordMapping,
      profileImageId: keywordMapping,
      tags: objectMapping({
        _id: keywordMapping,
        slug: keywordMapping,
        name: keywordMapping,
      }),
      posts: objectMapping({
        _id: keywordMapping,
        slug: keywordMapping,
        title: fullTextMapping,
      }),
      _geoloc: geopointMapping,
    },
    privateFields: [
      "deleteContent",
      "deleted",
      "isAdmin",
      "hideFromPeopleDirectory",
    ],
    karmaField: "karma",
    locationField: "_geoloc",
  },
  Sequences: {
    fields: [
      "title^3",
      "plaintextDescription",
      "authorDisplayName",
    ],
    snippet: "plaintextDescription",
    tiebreaker: "publicDateMs",
    filters: [
      {term: {isDeleted: false}},
      {term: {draft: false}},
      {term: {hidden: false}},
    ],
    mappings: {
      body: fullTextMapping,
      plaintextDescription: fullTextMapping,
      authorDisplayName: shingleTextMapping,
      userId: keywordMapping,
      authorSlug: shingleTextMapping,
      bannerImageId: keywordMapping,
    },
    privateFields: [
      "draft",
      "hidden",
      "isDeleted",
    ],
  },
  Tags: {
    fields: [
      "name^3",
      "description",
    ],
    snippet: "description",
    ranking: [
      {
        field: "core",
        order: "desc",
        weight: 0.5,
        scoring: {type: "bool"},
      },
      {
        field: "postCount",
        order: "desc",
        weight: 0.25,
        scoring: {type: "numeric", pivot: 10},
      },
    ],
    tiebreaker: "postCount",
    filters: [
      {term: {deleted: false}},
      {term: {adminOnly: false}},
    ],
    mappings: {
      name: fullTextMapping,
      description: fullTextMapping,
      bannerImageId: keywordMapping,
      parentTagId: keywordMapping,
      slug: keywordMapping,
    },
    privateFields: [
      "deleted",
    ],
  },
};

export const indexToCollectionName = (index: string): SearchIndexCollectionName => {
  const data: Record<string, SearchIndexCollectionName> = {
    comments: "Comments",
    posts: "Posts",
    users: "Users",
    sequences: "Sequences",
    tags: "Tags",
  };
  if (!data[index]) {
    throw new Error("Invalid index name: " + index);
  }
  return data[index];
}

export const collectionNameToConfig = (
  collectionName: SearchIndexCollectionName,
): IndexConfig => {
  const config = elasticSearchConfig[collectionName];
  if (!config) {
    throw new Error("Config not found for collection: " + collectionName);
  }
  return config;
}

export const indexNameToConfig = (indexName: string): IndexConfig => {
  const collectionName = indexToCollectionName(indexName);
  return collectionNameToConfig(collectionName);
}

export const isFullTextField = <N extends SearchIndexCollectionName>(
  collectionName: N,
  fieldName: string,
) => {
  const config = elasticSearchConfig[collectionName];
  if (!config) {
    throw new Error(`Invalid elastic collection name: ${collectionName}`);
  }
  return config.mappings?.[fieldName] === fullTextMapping;
}

1	import type {	80✔
2	MappingProperty,
3	QueryDslQueryContainer,
4	} from "@elastic/elasticsearch/lib/api/types";
5	import { SearchIndexCollectionName } from "../../../lib/search/searchUtil";
6	import { postStatuses } from "../../../lib/collections/posts/constants";	22✔
7	import { isEAForum } from "../../../lib/instanceSettings";	22✔
8	import { isFriendlyUI } from "@/themes/forumTheme";	22✔
9
10	export type Ranking = {
11	field: string,
12	order: "asc" \| "desc",
13	weight?: number,
14	scoring: {
15	type: "numeric",
16	pivot: number,
17	min?: number,
18	} \| {
19	type: "date",
20	} \| {
21	type: "bool",
22	},
23	}
24
25	export type Mappings = Record<string, MappingProperty>;
26
27	export type IndexConfig = {
28	/**
29	* An array of field names that compared against the search query.
30	* By default, this uses a fuzzy full text search. The first field listed will also
31	* be checked for an exact match, otherwise order doesn't matter.
32	* Field names may be appended with a relevance boost. For instance, "title^3", which
33	* will make matches on that field 3 times more relevant than matches on other fields.
34	* You never need to include objectID here as that is always checked separately.
35	*/
36	fields: string[],
37	/**
38	* The name of the field to create a match snippet from.
39	*/
40	snippet: string,
41	/**
42	* The name of the field to create a match highlight from.
43	*/
44	highlight?: string,
45	/**
46	* An array of ranking specifications to manually tune the relevancy of results.
47	* Ordering does not matter.
48	*/
49	ranking?: Ranking[],
50	/**
51	* The name of the field to use as a tie-breaker in the event that multiple results
52	* have exactly the same ranking (normally a date and ideally guaranteed to be
53	* unique). Note that relevancy is calculated as a floating point number so the
54	* probability of two results actually having the same relevancy is extremely low.
55	*/
56	tiebreaker: string,
57	/**
58	* Filters to completely remove entries from the result set, irregardless of their
59	* relevancy to the query. This is often used to remove deleted data.
60	*/
61	filters?: QueryDslQueryContainer[],
62	/**
63	* Mappings define the schema of the table. In general, elasticsearch infers the
64	* type of data when it is inserted so we do not need to keep a complete schema
65	* here with all the fields listed (see the serach export queries in the repos for
66	* the ultimate source of truth on what data is exported).
67	* We only need to add a field here if we know that elastic will infer the wrong
68	* type. Most notably, all strings are infered to be of type "text", which means
69	* they get stemmed and analyzed - this is normally what we want but leads to bad
70	* results when used on more structured strings like ids or slugs, which should
71	* instead be given the "keyword" mapping.
72	* Note that making a change here requires reindexing the data with
73	* `Globals.elasticConfigureIndex`.
74	*/
75	mappings?: Mappings,
76	/**
77	* An array of field names that should not be sent to the client. This may be
78	* because the data is private, or just because it isn't needed and we want to
79	* save on network traffic.
80	*/
81	privateFields: string[],
82	/**
83	* The name of the field to sort on when sorting by karma. Defaults to
84	* `baseScore` if not defined.
85	*/
86	karmaField?: string,
87	/**
88	* Field used for location based geo-sorting
89	*/
90	locationField?: string,
91	}
92
93	/**
94	* Fields that use full-text search (ie; generally all of the fields that are
95	* listed in the `field` array) should use this mapping. This allows us to use
96	* our normal full text analyzer with stemming and synonyms for normal searches,
97	* but to fall back to the exact analyzer which has no stemming for advanced
98	* searches using quotes.
99	*/
100	const fullTextMapping: MappingProperty = {	22✔
101	type: "text",
102	analyzer: "fm_synonym_analyzer",
103	fields: {
104	exact: {
105	type: "text",
106	analyzer: "fm_exact_analyzer",
107	},
108	sort: {
109	type: "keyword",
110	normalizer: "fm_sortable_keyword",
111	},
112	},
113	};
114
115	/**
116	* The shingle text mapping is particularly suited to short text fields that
117	* often contain punctuation but not a lot of semantic meaning, such as
118	* usernames.
119	*/
120	const shingleTextMapping: MappingProperty = {	22✔
121	type: "text",
122	analyzer: "fm_shingle_analyzer",
123	fields: {
124	exact: {
125	type: "text",
126	analyzer: "fm_exact_analyzer",
127	},
128	sort: {
129	type: "keyword",
130	normalizer: "fm_sortable_keyword",
131	},
132	},
133	};
134
135	const geopointMapping: MappingProperty = {	22✔
136	type: "geo_point",
137	};
138
139	/**
140	* Fields that should not be analyzed at all (ie; ids, slugs or enums) should
141	* use a keyword mapping.
142	*/
143	const keywordMapping: MappingProperty = {	22✔
144	type: "keyword",
145	};
146
147	const objectMapping = (	22✔
148	properties: Record<string, MappingProperty>,
149	): MappingProperty => ({properties});	44✔
150
151	const elasticSearchConfig: Record<SearchIndexCollectionName, IndexConfig> = {	22✔
152	Comments: {
153	fields: [
154	"body",
155	"authorDisplayName^11",
156	],
157	snippet: "body",
158	highlight: "authorDisplayName",
159	ranking: [
160	{
161	field: "baseScore",
162	order: "desc",
163	weight: 0.5,
164	scoring: {type: "numeric", pivot: 20},
165	},
166	{
167	field: "baseScore",
168	order: "desc",
169	weight: 1.5,
170	scoring: {type: "numeric", pivot: 50, min: 50},
171	},
172	],
173	tiebreaker: "publicDateMs",
174	filters: [
175	{term: {deleted: false}},
176	{term: {rejected: false}},
177	{term: {authorIsUnreviewed: false}},
178	{term: {retracted: false}},
179	{term: {spam: false}},
180	],
181	mappings: {
182	body: fullTextMapping,
183	postTitle: fullTextMapping,
184	authorDisplayName: shingleTextMapping,
185	authorUserName: shingleTextMapping,
186	authorSlug: shingleTextMapping,
187	postGroupId: keywordMapping,
188	postSlug: keywordMapping,
189	userId: keywordMapping,
190	tags: keywordMapping,
191	tagId: keywordMapping,
192	tagSlug: keywordMapping,
193	tagCommentType: keywordMapping,
194	},
195	privateFields: [
196	"authorIsUnreviewed",
197	"deleted",
198	"legacy",
199	"rejected",
200	"retracted",
201	"spam",
202	],
203	},
204	Posts: {
205	fields: [
206	"title^3",
207	"authorDisplayName^4",
208	"body",
209	],
210	snippet: "body",
211	highlight: "title",
212	ranking: [
213	{
214	field: "baseScore",
215	order: "desc",
216	weight: 8,
217	scoring: {type: "numeric", pivot: 20},
218	},
219	],
220	tiebreaker: "publicDateMs",
221	filters: [
222	{term: {isFuture: false}},
223	{term: {draft: false}},
224	{term: {rejected: false}},
225	{term: {authorIsUnreviewed: false}},
226	{term: {status: postStatuses.STATUS_APPROVED}},
227	...(isEAForum ? [] : [{range: {baseScore: {gte: 0}}}]),	22!
228	],
229	mappings: {
230	title: fullTextMapping,
231	authorDisplayName: shingleTextMapping,
232	authorFullName: shingleTextMapping,
233	authorSlug: shingleTextMapping,
234	body: fullTextMapping,
235	feedLink: keywordMapping,
236	slug: keywordMapping,
237	tags: keywordMapping,
238	url: keywordMapping,
239	userId: keywordMapping,
240	},
241	privateFields: [
242	"authorIsUnreviewed",
243	"draft",
244	"isFuture",
245	"legacy",
246	"rejected",
247	"status",
248	"viewCount",
249	],
250	},
251	Users: {
252	fields: [
253	"displayName^10000",
254	"bio",
255	"mapLocationAddress",
256	"jobTitle",
257	"organization",
258	"howICanHelpOthers",
259	"howOthersCanHelpMe",
260	...(isFriendlyUI
261	? [	22!
262	"tags.name",
263	"posts.title",
264	]
265	: []),
266	],
267	snippet: "bio",
268	ranking: [
269	{
270	field: "karma",
271	order: "desc",
272	weight: 2,
273	scoring: {type: "numeric", pivot: 5000, min: 1000},
274	},
275	{
276	field: "karma",
277	order: "desc",
278	weight: 1.5,
279	scoring: {type: "numeric", pivot: 1000, min: 1000},
280	},
281	{
282	field: "karma",
283	order: "desc",
284	weight: 1,
285	scoring: {type: "numeric", pivot: 100, min: 10},
286	},
287	{
288	field: "createdAt",
289	order: "desc",
290	weight: 0.5,
291	scoring: {type: "date"},
292	},
293	],
294	tiebreaker: "karma",
295	filters: [
296	{term: {deleted: false}},
297	{term: {deleteContent: false}},
298	],
299	mappings: {
300	displayName: shingleTextMapping,
301	bio: fullTextMapping,
302	mapLocationAddress: fullTextMapping,
303	jobTitle: fullTextMapping,
304	organization: fullTextMapping,
305	howICanHelpOthers: fullTextMapping,
306	howOthersCanHelpMe: fullTextMapping,
307	careerStage: keywordMapping,
308	groups: keywordMapping,
309	slug: shingleTextMapping,
310	website: keywordMapping,
311	profileImageId: keywordMapping,
312	tags: objectMapping({
313	_id: keywordMapping,
314	slug: keywordMapping,
315	name: keywordMapping,
316	}),
317	posts: objectMapping({
318	_id: keywordMapping,
319	slug: keywordMapping,
320	title: fullTextMapping,
321	}),
322	_geoloc: geopointMapping,
323	},
324	privateFields: [
325	"deleteContent",
326	"deleted",
327	"isAdmin",
328	"hideFromPeopleDirectory",
329	],
330	karmaField: "karma",
331	locationField: "_geoloc",
332	},
333	Sequences: {
334	fields: [
335	"title^3",
336	"plaintextDescription",
337	"authorDisplayName",
338	],
339	snippet: "plaintextDescription",
340	tiebreaker: "publicDateMs",
341	filters: [
342	{term: {isDeleted: false}},
343	{term: {draft: false}},
344	{term: {hidden: false}},
345	],
346	mappings: {
347	body: fullTextMapping,
348	plaintextDescription: fullTextMapping,
349	authorDisplayName: shingleTextMapping,
350	userId: keywordMapping,
351	authorSlug: shingleTextMapping,
352	bannerImageId: keywordMapping,
353	},
354	privateFields: [
355	"draft",
356	"hidden",
357	"isDeleted",
358	],
359	},
360	Tags: {
361	fields: [
362	"name^3",
363	"description",
364	],
365	snippet: "description",
366	ranking: [
367	{
368	field: "core",
369	order: "desc",
370	weight: 0.5,
371	scoring: {type: "bool"},
372	},
373	{
374	field: "postCount",
375	order: "desc",
376	weight: 0.25,
377	scoring: {type: "numeric", pivot: 10},
378	},
379	],
380	tiebreaker: "postCount",
381	filters: [
382	{term: {deleted: false}},
383	{term: {adminOnly: false}},
384	],
385	mappings: {
386	name: fullTextMapping,
387	description: fullTextMapping,
388	bannerImageId: keywordMapping,
389	parentTagId: keywordMapping,
390	slug: keywordMapping,
391	},
392	privateFields: [
393	"deleted",
394	],
395	},
396	};
397
398	export const indexToCollectionName = (index: string): SearchIndexCollectionName => {	22✔
399	const data: Record<string, SearchIndexCollectionName> = {	7✔
400	comments: "Comments",
401	posts: "Posts",
402	users: "Users",
403	sequences: "Sequences",
404	tags: "Tags",
405	};
406	if (!data[index]) {	7!
UNCOV 407	throw new Error("Invalid index name: " + index);	×
408	}
409	return data[index];	7✔
410	}
411
412	export const collectionNameToConfig = (	22✔
413	collectionName: SearchIndexCollectionName,
414	): IndexConfig => {
415	const config = elasticSearchConfig[collectionName];	7✔
416	if (!config) {	7!
UNCOV 417	throw new Error("Config not found for collection: " + collectionName);	×
418	}
419	return config;	7✔
420	}
421
422	export const indexNameToConfig = (indexName: string): IndexConfig => {	22✔
UNCOV 423	const collectionName = indexToCollectionName(indexName);	×
UNCOV 424	return collectionNameToConfig(collectionName);	×
425	}
426
427	export const isFullTextField = <N extends SearchIndexCollectionName>(	22✔
428	collectionName: N,
429	fieldName: string,
430	) => {
UNCOV 431	const config = elasticSearchConfig[collectionName];	×
UNCOV 432	if (!config) {	×
433	throw new Error(`Invalid elastic collection name: ${collectionName}`);	×
434	}
435	return config.mappings?.[fieldName] === fullTextMapping;	×
436	}

ForumMagnum / ForumMagnum / 10837608931

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous