@@ -0,0 +1,2586 @@
1+"use strict";
2+window.translations = {
3+ copy: "Copy",
4+ copied: "Copied!",
5+ normally_hidden:
6+ "This member is normally hidden due to your filter settings.",
7+ hierarchy_expand: "Expand",
8+ hierarchy_collapse: "Collapse",
9+ folder: "Folder",
10+ search_index_not_available: "The search index is not available",
11+ search_no_results_found_for_0: "No results found for {0}",
12+ kind_1: "Project",
13+ kind_2: "Module",
14+ kind_4: "Namespace",
15+ kind_8: "Enumeration",
16+ kind_16: "Enumeration Member",
17+ kind_32: "Variable",
18+ kind_64: "Function",
19+ kind_128: "Class",
20+ kind_256: "Interface",
21+ kind_512: "Constructor",
22+ kind_1024: "Property",
23+ kind_2048: "Method",
24+ kind_4096: "Call Signature",
25+ kind_8192: "Index Signature",
26+ kind_16384: "Constructor Signature",
27+ kind_32768: "Parameter",
28+ kind_65536: "Type Literal",
29+ kind_131072: "Type Parameter",
30+ kind_262144: "Accessor",
31+ kind_524288: "Get Signature",
32+ kind_1048576: "Set Signature",
33+ kind_2097152: "Type Alias",
34+ kind_4194304: "Reference",
35+ kind_8388608: "Document",
36+};
37+("use strict");
38+(() => {
39+ var Ke = Object.create;
40+ var he = Object.defineProperty;
41+ var Ge = Object.getOwnPropertyDescriptor;
42+ var Ze = Object.getOwnPropertyNames;
43+ var Xe = Object.getPrototypeOf,
44+ Ye = Object.prototype.hasOwnProperty;
45+ var et = (t, e) => () => (
46+ e || t((e = { exports: {} }).exports, e),
47+ e.exports
48+ );
49+ var tt = (t, e, n, r) => {
50+ if ((e && typeof e == "object") || typeof e == "function")
51+ for (let i of Ze(e))
52+ !Ye.call(t, i) &&
53+ i !== n &&
54+ he(t, i, {
55+ get: () => e[i],
56+ enumerable: !(r = Ge(e, i)) || r.enumerable,
57+ });
58+ return t;
59+ };
60+ var nt = (t, e, n) => (
61+ (n = t != null ? Ke(Xe(t)) : {}),
62+ tt(
63+ e || !t || !t.__esModule
64+ ? he(n, "default", { value: t, enumerable: !0 })
65+ : n,
66+ t,
67+ )
68+ );
69+ var ye = et((me, ge) => {
70+ (function () {
71+ var t = function (e) {
72+ var n = new t.Builder();
73+ return (
74+ n.pipeline.add(t.trimmer, t.stopWordFilter, t.stemmer),
75+ n.searchPipeline.add(t.stemmer),
76+ e.call(n, n),
77+ n.build()
78+ );
79+ };
80+ t.version = "2.3.9";
81+ ((t.utils = {}),
82+ (t.utils.warn = (function (e) {
83+ return function (n) {
84+ e.console && console.warn && console.warn(n);
85+ };
86+ })(this)),
87+ (t.utils.asString = function (e) {
88+ return e == null ? "" : e.toString();
89+ }),
90+ (t.utils.clone = function (e) {
91+ if (e == null) return e;
92+ for (
93+ var n = Object.create(null), r = Object.keys(e), i = 0;
94+ i < r.length;
95+ i++
96+ ) {
97+ var s = r[i],
98+ o = e[s];
99+ if (Array.isArray(o)) {
100+ n[s] = o.slice();
101+ continue;
102+ }
103+ if (
104+ typeof o == "string" ||
105+ typeof o == "number" ||
106+ typeof o == "boolean"
107+ ) {
108+ n[s] = o;
109+ continue;
110+ }
111+ throw new TypeError(
112+ "clone is not deep and does not support nested objects",
113+ );
114+ }
115+ return n;
116+ }),
117+ (t.FieldRef = function (e, n, r) {
118+ ((this.docRef = e), (this.fieldName = n), (this._stringValue = r));
119+ }),
120+ (t.FieldRef.joiner = "/"),
121+ (t.FieldRef.fromString = function (e) {
122+ var n = e.indexOf(t.FieldRef.joiner);
123+ if (n === -1) throw "malformed field ref string";
124+ var r = e.slice(0, n),
125+ i = e.slice(n + 1);
126+ return new t.FieldRef(i, r, e);
127+ }),
128+ (t.FieldRef.prototype.toString = function () {
129+ return (
130+ this._stringValue == null &&
131+ (this._stringValue =
132+ this.fieldName + t.FieldRef.joiner + this.docRef),
133+ this._stringValue
134+ );
135+ }));
136+ ((t.Set = function (e) {
137+ if (((this.elements = Object.create(null)), e)) {
138+ this.length = e.length;
139+ for (var n = 0; n < this.length; n++) this.elements[e[n]] = !0;
140+ } else this.length = 0;
141+ }),
142+ (t.Set.complete = {
143+ intersect: function (e) {
144+ return e;
145+ },
146+ union: function () {
147+ return this;
148+ },
149+ contains: function () {
150+ return !0;
151+ },
152+ }),
153+ (t.Set.empty = {
154+ intersect: function () {
155+ return this;
156+ },
157+ union: function (e) {
158+ return e;
159+ },
160+ contains: function () {
161+ return !1;
162+ },
163+ }),
164+ (t.Set.prototype.contains = function (e) {
165+ return !!this.elements[e];
166+ }),
167+ (t.Set.prototype.intersect = function (e) {
168+ var n,
169+ r,
170+ i,
171+ s = [];
172+ if (e === t.Set.complete) return this;
173+ if (e === t.Set.empty) return e;
174+ (this.length < e.length
175+ ? ((n = this), (r = e))
176+ : ((n = e), (r = this)),
177+ (i = Object.keys(n.elements)));
178+ for (var o = 0; o < i.length; o++) {
179+ var a = i[o];
180+ a in r.elements && s.push(a);
181+ }
182+ return new t.Set(s);
183+ }),
184+ (t.Set.prototype.union = function (e) {
185+ return e === t.Set.complete
186+ ? t.Set.complete
187+ : e === t.Set.empty
188+ ? this
189+ : new t.Set(
190+ Object.keys(this.elements).concat(Object.keys(e.elements)),
191+ );
192+ }),
193+ (t.idf = function (e, n) {
194+ var r = 0;
195+ for (var i in e) i != "_index" && (r += Object.keys(e[i]).length);
196+ var s = (n - r + 0.5) / (r + 0.5);
197+ return Math.log(1 + Math.abs(s));
198+ }),
199+ (t.Token = function (e, n) {
200+ ((this.str = e || ""), (this.metadata = n || {}));
201+ }),
202+ (t.Token.prototype.toString = function () {
203+ return this.str;
204+ }),
205+ (t.Token.prototype.update = function (e) {
206+ return ((this.str = e(this.str, this.metadata)), this);
207+ }),
208+ (t.Token.prototype.clone = function (e) {
209+ return (
210+ (e =
211+ e ||
212+ function (n) {
213+ return n;
214+ }),
215+ new t.Token(e(this.str, this.metadata), this.metadata)
216+ );
217+ }));
218+ ((t.tokenizer = function (e, n) {
219+ if (e == null || e == null) return [];
220+ if (Array.isArray(e))
221+ return e.map(function (f) {
222+ return new t.Token(
223+ t.utils.asString(f).toLowerCase(),
224+ t.utils.clone(n),
225+ );
226+ });
227+ for (
228+ var r = e.toString().toLowerCase(),
229+ i = r.length,
230+ s = [],
231+ o = 0,
232+ a = 0;
233+ o <= i;
234+ o++
235+ ) {
236+ var c = r.charAt(o),
237+ l = o - a;
238+ if (c.match(t.tokenizer.separator) || o == i) {
239+ if (l > 0) {
240+ var d = t.utils.clone(n) || {};
241+ ((d.position = [a, l]),
242+ (d.index = s.length),
243+ s.push(new t.Token(r.slice(a, o), d)));
244+ }
245+ a = o + 1;
246+ }
247+ }
248+ return s;
249+ }),
250+ (t.tokenizer.separator = /[\s\-]+/));
251+ ((t.Pipeline = function () {
252+ this._stack = [];
253+ }),
254+ (t.Pipeline.registeredFunctions = Object.create(null)),
255+ (t.Pipeline.registerFunction = function (e, n) {
256+ (n in this.registeredFunctions &&
257+ t.utils.warn("Overwriting existing registered function: " + n),
258+ (e.label = n),
259+ (t.Pipeline.registeredFunctions[e.label] = e));
260+ }),
261+ (t.Pipeline.warnIfFunctionNotRegistered = function (e) {
262+ var n = e.label && e.label in this.registeredFunctions;
263+ n ||
264+ t.utils.warn(
265+ `Function is not registered with pipeline. This may cause problems when serialising the index.
266+`,
267+ e,
268+ );
269+ }),
270+ (t.Pipeline.load = function (e) {
271+ var n = new t.Pipeline();
272+ return (
273+ e.forEach(function (r) {
274+ var i = t.Pipeline.registeredFunctions[r];
275+ if (i) n.add(i);
276+ else throw new Error("Cannot load unregistered function: " + r);
277+ }),
278+ n
279+ );
280+ }),
281+ (t.Pipeline.prototype.add = function () {
282+ var e = Array.prototype.slice.call(arguments);
283+ e.forEach(function (n) {
284+ (t.Pipeline.warnIfFunctionNotRegistered(n), this._stack.push(n));
285+ }, this);
286+ }),
287+ (t.Pipeline.prototype.after = function (e, n) {
288+ t.Pipeline.warnIfFunctionNotRegistered(n);
289+ var r = this._stack.indexOf(e);
290+ if (r == -1) throw new Error("Cannot find existingFn");
291+ ((r = r + 1), this._stack.splice(r, 0, n));
292+ }),
293+ (t.Pipeline.prototype.before = function (e, n) {
294+ t.Pipeline.warnIfFunctionNotRegistered(n);
295+ var r = this._stack.indexOf(e);
296+ if (r == -1) throw new Error("Cannot find existingFn");
297+ this._stack.splice(r, 0, n);
298+ }),
299+ (t.Pipeline.prototype.remove = function (e) {
300+ var n = this._stack.indexOf(e);
301+ n != -1 && this._stack.splice(n, 1);
302+ }),
303+ (t.Pipeline.prototype.run = function (e) {
304+ for (var n = this._stack.length, r = 0; r < n; r++) {
305+ for (var i = this._stack[r], s = [], o = 0; o < e.length; o++) {
306+ var a = i(e[o], o, e);
307+ if (!(a == null || a === ""))
308+ if (Array.isArray(a))
309+ for (var c = 0; c < a.length; c++) s.push(a[c]);
310+ else s.push(a);
311+ }
312+ e = s;
313+ }
314+ return e;
315+ }),
316+ (t.Pipeline.prototype.runString = function (e, n) {
317+ var r = new t.Token(e, n);
318+ return this.run([r]).map(function (i) {
319+ return i.toString();
320+ });
321+ }),
322+ (t.Pipeline.prototype.reset = function () {
323+ this._stack = [];
324+ }),
325+ (t.Pipeline.prototype.toJSON = function () {
326+ return this._stack.map(function (e) {
327+ return (t.Pipeline.warnIfFunctionNotRegistered(e), e.label);
328+ });
329+ }));
330+ ((t.Vector = function (e) {
331+ ((this._magnitude = 0), (this.elements = e || []));
332+ }),
333+ (t.Vector.prototype.positionForIndex = function (e) {
334+ if (this.elements.length == 0) return 0;
335+ for (
336+ var n = 0,
337+ r = this.elements.length / 2,
338+ i = r - n,
339+ s = Math.floor(i / 2),
340+ o = this.elements[s * 2];
341+ i > 1 && (o < e && (n = s), o > e && (r = s), o != e);
342+ )
343+ ((i = r - n),
344+ (s = n + Math.floor(i / 2)),
345+ (o = this.elements[s * 2]));
346+ if (o == e || o > e) return s * 2;
347+ if (o < e) return (s + 1) * 2;
348+ }),
349+ (t.Vector.prototype.insert = function (e, n) {
350+ this.upsert(e, n, function () {
351+ throw "duplicate index";
352+ });
353+ }),
354+ (t.Vector.prototype.upsert = function (e, n, r) {
355+ this._magnitude = 0;
356+ var i = this.positionForIndex(e);
357+ this.elements[i] == e
358+ ? (this.elements[i + 1] = r(this.elements[i + 1], n))
359+ : this.elements.splice(i, 0, e, n);
360+ }),
361+ (t.Vector.prototype.magnitude = function () {
362+ if (this._magnitude) return this._magnitude;
363+ for (var e = 0, n = this.elements.length, r = 1; r < n; r += 2) {
364+ var i = this.elements[r];
365+ e += i * i;
366+ }
367+ return (this._magnitude = Math.sqrt(e));
368+ }),
369+ (t.Vector.prototype.dot = function (e) {
370+ for (
371+ var n = 0,
372+ r = this.elements,
373+ i = e.elements,
374+ s = r.length,
375+ o = i.length,
376+ a = 0,
377+ c = 0,
378+ l = 0,
379+ d = 0;
380+ l < s && d < o;
381+ )
382+ ((a = r[l]),
383+ (c = i[d]),
384+ a < c
385+ ? (l += 2)
386+ : a > c
387+ ? (d += 2)
388+ : a == c && ((n += r[l + 1] * i[d + 1]), (l += 2), (d += 2)));
389+ return n;
390+ }),
391+ (t.Vector.prototype.similarity = function (e) {
392+ return this.dot(e) / this.magnitude() || 0;
393+ }),
394+ (t.Vector.prototype.toArray = function () {
395+ for (
396+ var e = new Array(this.elements.length / 2), n = 1, r = 0;
397+ n < this.elements.length;
398+ n += 2, r++
399+ )
400+ e[r] = this.elements[n];
401+ return e;
402+ }),
403+ (t.Vector.prototype.toJSON = function () {
404+ return this.elements;
405+ }));
406+ ((t.stemmer = (function () {
407+ var e = {
408+ ational: "ate",
409+ tional: "tion",
410+ enci: "ence",
411+ anci: "ance",
412+ izer: "ize",
413+ bli: "ble",
414+ alli: "al",
415+ entli: "ent",
416+ eli: "e",
417+ ousli: "ous",
418+ ization: "ize",
419+ ation: "ate",
420+ ator: "ate",
421+ alism: "al",
422+ iveness: "ive",
423+ fulness: "ful",
424+ ousness: "ous",
425+ aliti: "al",
426+ iviti: "ive",
427+ biliti: "ble",
428+ logi: "log",
429+ },
430+ n = {
431+ icate: "ic",
432+ ative: "",
433+ alize: "al",
434+ iciti: "ic",
435+ ical: "ic",
436+ ful: "",
437+ ness: "",
438+ },
439+ r = "[^aeiou]",
440+ i = "[aeiouy]",
441+ s = r + "[^aeiouy]*",
442+ o = i + "[aeiou]*",
443+ a = "^(" + s + ")?" + o + s,
444+ c = "^(" + s + ")?" + o + s + "(" + o + ")?$",
445+ l = "^(" + s + ")?" + o + s + o + s,
446+ d = "^(" + s + ")?" + i,
447+ f = new RegExp(a),
448+ p = new RegExp(l),
449+ v = new RegExp(c),
450+ x = new RegExp(d),
451+ w = /^(.+?)(ss|i)es$/,
452+ m = /^(.+?)([^s])s$/,
453+ g = /^(.+?)eed$/,
454+ T = /^(.+?)(ed|ing)$/,
455+ L = /.$/,
456+ C = /(at|bl|iz)$/,
457+ O = new RegExp("([^aeiouylsz])\\1$"),
458+ j = new RegExp("^" + s + i + "[^aeiouwxy]$"),
459+ N = /^(.+?[^aeiou])y$/,
460+ q =
461+ /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/,
462+ W = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/,
463+ B =
464+ /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/,
465+ z = /^(.+?)(s|t)(ion)$/,
466+ _ = /^(.+?)e$/,
467+ U = /ll$/,
468+ J = new RegExp("^" + s + i + "[^aeiouwxy]$"),
469+ V = function (u) {
470+ var y, P, k, h, E, Q, H;
471+ if (u.length < 3) return u;
472+ if (
473+ ((k = u.substr(0, 1)),
474+ k == "y" && (u = k.toUpperCase() + u.substr(1)),
475+ (h = w),
476+ (E = m),
477+ h.test(u)
478+ ? (u = u.replace(h, "$1$2"))
479+ : E.test(u) && (u = u.replace(E, "$1$2")),
480+ (h = g),
481+ (E = T),
482+ h.test(u))
483+ ) {
484+ var b = h.exec(u);
485+ ((h = f), h.test(b[1]) && ((h = L), (u = u.replace(h, ""))));
486+ } else if (E.test(u)) {
487+ var b = E.exec(u);
488+ ((y = b[1]),
489+ (E = x),
490+ E.test(y) &&
491+ ((u = y),
492+ (E = C),
493+ (Q = O),
494+ (H = j),
495+ E.test(u)
496+ ? (u = u + "e")
497+ : Q.test(u)
498+ ? ((h = L), (u = u.replace(h, "")))
499+ : H.test(u) && (u = u + "e")));
500+ }
501+ if (((h = N), h.test(u))) {
502+ var b = h.exec(u);
503+ ((y = b[1]), (u = y + "i"));
504+ }
505+ if (((h = q), h.test(u))) {
506+ var b = h.exec(u);
507+ ((y = b[1]), (P = b[2]), (h = f), h.test(y) && (u = y + e[P]));
508+ }
509+ if (((h = W), h.test(u))) {
510+ var b = h.exec(u);
511+ ((y = b[1]), (P = b[2]), (h = f), h.test(y) && (u = y + n[P]));
512+ }
513+ if (((h = B), (E = z), h.test(u))) {
514+ var b = h.exec(u);
515+ ((y = b[1]), (h = p), h.test(y) && (u = y));
516+ } else if (E.test(u)) {
517+ var b = E.exec(u);
518+ ((y = b[1] + b[2]), (E = p), E.test(y) && (u = y));
519+ }
520+ if (((h = _), h.test(u))) {
521+ var b = h.exec(u);
522+ ((y = b[1]),
523+ (h = p),
524+ (E = v),
525+ (Q = J),
526+ (h.test(y) || (E.test(y) && !Q.test(y))) && (u = y));
527+ }
528+ return (
529+ (h = U),
530+ (E = p),
531+ h.test(u) && E.test(u) && ((h = L), (u = u.replace(h, ""))),
532+ k == "y" && (u = k.toLowerCase() + u.substr(1)),
533+ u
534+ );
535+ };
536+ return function (A) {
537+ return A.update(V);
538+ };
539+ })()),
540+ t.Pipeline.registerFunction(t.stemmer, "stemmer"));
541+ ((t.generateStopWordFilter = function (e) {
542+ var n = e.reduce(function (r, i) {
543+ return ((r[i] = i), r);
544+ }, {});
545+ return function (r) {
546+ if (r && n[r.toString()] !== r.toString()) return r;
547+ };
548+ }),
549+ (t.stopWordFilter = t.generateStopWordFilter([
550+ "a",
551+ "able",
552+ "about",
553+ "across",
554+ "after",
555+ "all",
556+ "almost",
557+ "also",
558+ "am",
559+ "among",
560+ "an",
561+ "and",
562+ "any",
563+ "are",
564+ "as",
565+ "at",
566+ "be",
567+ "because",
568+ "been",
569+ "but",
570+ "by",
571+ "can",
572+ "cannot",
573+ "could",
574+ "dear",
575+ "did",
576+ "do",
577+ "does",
578+ "either",
579+ "else",
580+ "ever",
581+ "every",
582+ "for",
583+ "from",
584+ "get",
585+ "got",
586+ "had",
587+ "has",
588+ "have",
589+ "he",
590+ "her",
591+ "hers",
592+ "him",
593+ "his",
594+ "how",
595+ "however",
596+ "i",
597+ "if",
598+ "in",
599+ "into",
600+ "is",
601+ "it",
602+ "its",
603+ "just",
604+ "least",
605+ "let",
606+ "like",
607+ "likely",
608+ "may",
609+ "me",
610+ "might",
611+ "most",
612+ "must",
613+ "my",
614+ "neither",
615+ "no",
616+ "nor",
617+ "not",
618+ "of",
619+ "off",
620+ "often",
621+ "on",
622+ "only",
623+ "or",
624+ "other",
625+ "our",
626+ "own",
627+ "rather",
628+ "said",
629+ "say",
630+ "says",
631+ "she",
632+ "should",
633+ "since",
634+ "so",
635+ "some",
636+ "than",
637+ "that",
638+ "the",
639+ "their",
640+ "them",
641+ "then",
642+ "there",
643+ "these",
644+ "they",
645+ "this",
646+ "tis",
647+ "to",
648+ "too",
649+ "twas",
650+ "us",
651+ "wants",
652+ "was",
653+ "we",
654+ "were",
655+ "what",
656+ "when",
657+ "where",
658+ "which",
659+ "while",
660+ "who",
661+ "whom",
662+ "why",
663+ "will",
664+ "with",
665+ "would",
666+ "yet",
667+ "you",
668+ "your",
669+ ])),
670+ t.Pipeline.registerFunction(t.stopWordFilter, "stopWordFilter"));
671+ ((t.trimmer = function (e) {
672+ return e.update(function (n) {
673+ return n.replace(/^\W+/, "").replace(/\W+$/, "");
674+ });
675+ }),
676+ t.Pipeline.registerFunction(t.trimmer, "trimmer"));
677+ ((t.TokenSet = function () {
678+ ((this.final = !1),
679+ (this.edges = {}),
680+ (this.id = t.TokenSet._nextId),
681+ (t.TokenSet._nextId += 1));
682+ }),
683+ (t.TokenSet._nextId = 1),
684+ (t.TokenSet.fromArray = function (e) {
685+ for (
686+ var n = new t.TokenSet.Builder(), r = 0, i = e.length;
687+ r < i;
688+ r++
689+ )
690+ n.insert(e[r]);
691+ return (n.finish(), n.root);
692+ }),
693+ (t.TokenSet.fromClause = function (e) {
694+ return "editDistance" in e
695+ ? t.TokenSet.fromFuzzyString(e.term, e.editDistance)
696+ : t.TokenSet.fromString(e.term);
697+ }),
698+ (t.TokenSet.fromFuzzyString = function (e, n) {
699+ for (
700+ var r = new t.TokenSet(),
701+ i = [{ node: r, editsRemaining: n, str: e }];
702+ i.length;
703+ ) {
704+ var s = i.pop();
705+ if (s.str.length > 0) {
706+ var o = s.str.charAt(0),
707+ a;
708+ (o in s.node.edges
709+ ? (a = s.node.edges[o])
710+ : ((a = new t.TokenSet()), (s.node.edges[o] = a)),
711+ s.str.length == 1 && (a.final = !0),
712+ i.push({
713+ node: a,
714+ editsRemaining: s.editsRemaining,
715+ str: s.str.slice(1),
716+ }));
717+ }
718+ if (s.editsRemaining != 0) {
719+ if ("*" in s.node.edges) var c = s.node.edges["*"];
720+ else {
721+ var c = new t.TokenSet();
722+ s.node.edges["*"] = c;
723+ }
724+ if (
725+ (s.str.length == 0 && (c.final = !0),
726+ i.push({
727+ node: c,
728+ editsRemaining: s.editsRemaining - 1,
729+ str: s.str,
730+ }),
731+ s.str.length > 1 &&
732+ i.push({
733+ node: s.node,
734+ editsRemaining: s.editsRemaining - 1,
735+ str: s.str.slice(1),
736+ }),
737+ s.str.length == 1 && (s.node.final = !0),
738+ s.str.length >= 1)
739+ ) {
740+ if ("*" in s.node.edges) var l = s.node.edges["*"];
741+ else {
742+ var l = new t.TokenSet();
743+ s.node.edges["*"] = l;
744+ }
745+ (s.str.length == 1 && (l.final = !0),
746+ i.push({
747+ node: l,
748+ editsRemaining: s.editsRemaining - 1,
749+ str: s.str.slice(1),
750+ }));
751+ }
752+ if (s.str.length > 1) {
753+ var d = s.str.charAt(0),
754+ f = s.str.charAt(1),
755+ p;
756+ (f in s.node.edges
757+ ? (p = s.node.edges[f])
758+ : ((p = new t.TokenSet()), (s.node.edges[f] = p)),
759+ s.str.length == 1 && (p.final = !0),
760+ i.push({
761+ node: p,
762+ editsRemaining: s.editsRemaining - 1,
763+ str: d + s.str.slice(2),
764+ }));
765+ }
766+ }
767+ }
768+ return r;
769+ }),
770+ (t.TokenSet.fromString = function (e) {
771+ for (
772+ var n = new t.TokenSet(), r = n, i = 0, s = e.length;
773+ i < s;
774+ i++
775+ ) {
776+ var o = e[i],
777+ a = i == s - 1;
778+ if (o == "*") ((n.edges[o] = n), (n.final = a));
779+ else {
780+ var c = new t.TokenSet();
781+ ((c.final = a), (n.edges[o] = c), (n = c));
782+ }
783+ }
784+ return r;
785+ }),
786+ (t.TokenSet.prototype.toArray = function () {
787+ for (var e = [], n = [{ prefix: "", node: this }]; n.length; ) {
788+ var r = n.pop(),
789+ i = Object.keys(r.node.edges),
790+ s = i.length;
791+ r.node.final && (r.prefix.charAt(0), e.push(r.prefix));
792+ for (var o = 0; o < s; o++) {
793+ var a = i[o];
794+ n.push({ prefix: r.prefix.concat(a), node: r.node.edges[a] });
795+ }
796+ }
797+ return e;
798+ }),
799+ (t.TokenSet.prototype.toString = function () {
800+ if (this._str) return this._str;
801+ for (
802+ var e = this.final ? "1" : "0",
803+ n = Object.keys(this.edges).sort(),
804+ r = n.length,
805+ i = 0;
806+ i < r;
807+ i++
808+ ) {
809+ var s = n[i],
810+ o = this.edges[s];
811+ e = e + s + o.id;
812+ }
813+ return e;
814+ }),
815+ (t.TokenSet.prototype.intersect = function (e) {
816+ for (
817+ var n = new t.TokenSet(),
818+ r = void 0,
819+ i = [{ qNode: e, output: n, node: this }];
820+ i.length;
821+ ) {
822+ r = i.pop();
823+ for (
824+ var s = Object.keys(r.qNode.edges),
825+ o = s.length,
826+ a = Object.keys(r.node.edges),
827+ c = a.length,
828+ l = 0;
829+ l < o;
830+ l++
831+ )
832+ for (var d = s[l], f = 0; f < c; f++) {
833+ var p = a[f];
834+ if (p == d || d == "*") {
835+ var v = r.node.edges[p],
836+ x = r.qNode.edges[d],
837+ w = v.final && x.final,
838+ m = void 0;
839+ (p in r.output.edges
840+ ? ((m = r.output.edges[p]), (m.final = m.final || w))
841+ : ((m = new t.TokenSet()),
842+ (m.final = w),
843+ (r.output.edges[p] = m)),
844+ i.push({ qNode: x, output: m, node: v }));
845+ }
846+ }
847+ }
848+ return n;
849+ }),
850+ (t.TokenSet.Builder = function () {
851+ ((this.previousWord = ""),
852+ (this.root = new t.TokenSet()),
853+ (this.uncheckedNodes = []),
Cut short: this commit's diff is over 1000 lines.