alinea 1.7.0 → 2.0.0-preview.1

package/dist/core/db/EntryIndex.js

@@ -1,4 +1,7 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import {
+  pLimit
+} from "../../chunks/chunk-U5Z2VE7Z.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/db/EntryIndex.ts
 import * as paths from "alinea/core/util/Paths";
@@ -575,7 +578,7 @@ var MiniSearch = class _MiniSearch {
    * @param document  The document to be indexed
    */
   add(document) {
-    const { extractField, tokenize, processTerm, fields, idField } = this._options;
+    const { extractField, stringifyField, tokenize, processTerm, fields, idField } = this._options;
     const id = extractField(document, idField);
     if (id == null) {
       throw new Error(`MiniSearch: document does not have ID field "${idField}"`);
@@ -589,7 +592,7 @@ var MiniSearch = class _MiniSearch {
       const fieldValue = extractField(document, field);
       if (fieldValue == null)
         continue;
-      const tokens = tokenize(fieldValue.toString(), field);
+      const tokens = tokenize(stringifyField(fieldValue, field), field);
       const fieldId = this._fieldIds[field];
       const uniqueTerms = new Set(tokens).size;
       this.addFieldLength(shortDocumentId, fieldId, this._documentCount - 1, uniqueTerms);
@@ -656,7 +659,7 @@ var MiniSearch = class _MiniSearch {
    * @param document  The document to be removed
    */
   remove(document) {
-    const { tokenize, processTerm, extractField, fields, idField } = this._options;
+    const { tokenize, processTerm, extractField, stringifyField, fields, idField } = this._options;
     const id = extractField(document, idField);
     if (id == null) {
       throw new Error(`MiniSearch: document does not have ID field "${idField}"`);
@@ -669,7 +672,7 @@ var MiniSearch = class _MiniSearch {
       const fieldValue = extractField(document, field);
       if (fieldValue == null)
         continue;
-      const tokens = tokenize(fieldValue.toString(), field);
+      const tokens = tokenize(stringifyField(fieldValue, field), field);
       const fieldId = this._fieldIds[field];
       const uniqueTerms = new Set(tokens).size;
       this.removeFieldLength(shortId, fieldId, this._documentCount, uniqueTerms);
@@ -1698,7 +1701,7 @@ var MiniSearch = class _MiniSearch {
     }
   }
 };
-MiniSearch.wildcard = Symbol("*");
+MiniSearch.wildcard = /* @__PURE__ */ Symbol("*");
 var getOwnProperty = (object, property) => Object.prototype.hasOwnProperty.call(object, property) ? object[property] : void 0;
 var combinators = {
   [OR]: (a, b) => {
@@ -1752,6 +1755,7 @@ var termToQuerySpec = (options) => (term, i, terms) => {
 var defaultOptions = {
   idField: "id",
   extractField: (document, fieldName) => document[fieldName],
+  stringifyField: (fieldValue, fieldName) => fieldValue.toString(),
   tokenize: (text) => text.split(SPACE_OR_PUNCTUATION),
   processTerm: (term) => term.toLowerCase(),
   fields: void 0,
@@ -1830,6 +1834,7 @@ import { entryInfo, entryUrl } from "../util/EntryFilenames.js";
 import { entries, keys } from "../util/Objects.js";
 import { slugify } from "../util/Slugs.js";
 import { sourceChanges } from "./CommitRequest.js";
+import { EntryReferenceIndex } from "./EntryReferenceIndex.js";
 import { EntryTransaction } from "./EntryTransaction.js";
 import { IndexEvent } from "./IndexEvent.js";
 function combineConditions(a, b) {
@@ -1911,6 +1916,7 @@ var EntryCollection = class extends Map {
       this.set(locale, new EntryLanguage(entries2));
     }
   }
+  versions;
   type;
 };
 var EntryLanguageNode = class {
@@ -1934,6 +1940,8 @@ var EntryLanguageNode = class {
     assert(active, `EntryLanguageNode missing active version`);
     this.active = active;
     this.url = entryUrl(node.entryType, {
+      config: node.graph.config,
+      data: main.data,
       status: main.status,
       path: main.path,
       parentPaths: this.parentPaths,
@@ -1944,6 +1952,8 @@ var EntryLanguageNode = class {
     this.path = this.main.path;
     this.seeded = this.main.seeded;
   }
+  node;
+  language;
   inheritedStatus;
   main;
   active;
@@ -1971,6 +1981,7 @@ var EntryLanguageNode = class {
   }
   get entries() {
     if (this.#entries) return this.#entries;
+    const entryType = this.node.entryType;
     const entries2 = (this.inheritedStatus ? [this.active] : [...this.language.values()]).map((version) => {
       return {
         ...version,
@@ -1979,7 +1990,13 @@ var EntryLanguageNode = class {
         parents: this.node.parents,
         url: this.url,
         active: version === this.active,
-        main: version === this.main
+        main: version === this.main,
+        get searchableText() {
+          return version.searchableText ??= Type.searchableText(
+            entryType,
+            version.data
+          );
+        }
       };
     });
     this.#entries = entries2;
@@ -2021,6 +2038,10 @@ var EntryNode = class extends Map {
       this.set(locale, new EntryLanguageNode(this, language));
     }
   }
+  graph;
+  entryType;
+  parent;
+  children;
   id;
   index;
   parentId;
@@ -2038,12 +2059,30 @@ var EntryNode = class extends Map {
 };
 var SPACE_OR_PUNCTUATION2 = /[\n\r\p{Z}\p{P}]+/u;
 var DIACRITIC = /\p{Diacritic}/gu;
+function tokenizeSearchText(text) {
+  return text.normalize("NFD").replace(DIACRITIC, "").split(SPACE_OR_PUNCTUATION2);
+}
+function normalizedSearchTerms(text) {
+  return tokenizeSearchText(text).filter(Boolean).map((term) => term.toLowerCase());
+}
+function searchPriority(entry, match, queryTerms) {
+  const titleTerms = normalizedSearchTerms(entry.title);
+  const titlePrefix = queryTerms.every(
+    (term, index) => titleTerms[index]?.startsWith(term)
+  );
+  if (queryTerms.length > 0 && titlePrefix) return 2;
+  const titleMatch = Object.values(match).some(
+    (fields) => fields.includes("title")
+  );
+  return titleMatch ? 1 : 0;
+}
 var EntryGraph = class _EntryGraph {
   #config;
   #versionData;
   #filesById = /* @__PURE__ */ new Map();
   #byId = /* @__PURE__ */ new Map();
   #byDir = /* @__PURE__ */ new Map();
+  #childrenByParentId = /* @__PURE__ */ new Map();
   nodes;
   #singleWorkspace;
   #search;
@@ -2055,9 +2094,8 @@ var EntryGraph = class _EntryGraph {
     this.#singleWorkspace = Config.multipleWorkspaces(config) ? void 0 : keys(config.workspaces)[0];
     this.#search = new MiniSearch({
       fields: ["title", "searchableText"],
-      storeFields: ["entry"],
       tokenize(text) {
-        return text.normalize("NFD").replace(DIACRITIC, "").split(SPACE_OR_PUNCTUATION2);
+        return tokenizeSearchText(text);
       }
     });
     for (const [file, version] of versionData) {
@@ -2068,6 +2106,12 @@ var EntryGraph = class _EntryGraph {
       this.#byDir.set(dir, version.id);
     }
     this.nodes = [...this.#filesById.keys()].map((file) => this.#mkNode(file)).sort((a, b) => compareStrings(a.index, b.index));
+    for (const node of this.nodes) {
+      if (!node.parentId) continue;
+      const children = this.#childrenByParentId.get(node.parentId) ?? [];
+      children.push(node);
+      this.#childrenByParentId.set(node.parentId, children);
+    }
   }
   byId(id) {
     return this.#byId.get(id);
@@ -2080,6 +2124,17 @@ var EntryGraph = class _EntryGraph {
     if (!id) return void 0;
     return this.byId(id);
   }
+  entryByFilePath(filePath) {
+    const node = this.byDir(getNodePath(filePath));
+    if (!node) return void 0;
+    return Array.from(
+      node.filter({
+        entry(entry) {
+          return entry.filePath === filePath;
+        }
+      })
+    )[0];
+  }
   withChanges(batch) {
     const parser = getParser(this.#config);
     const versions = new Map(this.#versionData);
@@ -2098,17 +2153,34 @@ var EntryGraph = class _EntryGraph {
   }
   *filter({ search, ...filter }) {
     if (search) {
-      const found = new Set(this.filter(filter));
-      for (const entry of found) {
+      const found = new Map(
+        Array.from(this.filter(filter), (entry) => [entry.filePath, entry])
+      );
+      for (const entry of found.values()) {
         if (!this.#search.has(entry.filePath)) this.#updateSearch(entry);
       }
+      const queryTerms = normalizedSearchTerms(search);
       const results = this.#search.search(search, {
+        combineWith: "AND",
         prefix: true,
         fuzzy: 0.1,
-        boost: { title: 2 },
-        filter: (result) => found.has(result.entry)
-      }).map((result) => result.entry);
-      yield* results;
+        boost: { title: 10 },
+        filter: (result) => typeof result.id === "string" && found.has(result.id)
+      }).flatMap((result) => {
+        if (typeof result.id !== "string") return [];
+        const entry = found.get(result.id);
+        if (!entry) return [];
+        return [
+          {
+            entry,
+            priority: searchPriority(entry, result.match, queryTerms),
+            score: result.score
+          }
+        ];
+      });
+      results.sort((a, b) => b.priority - a.priority || b.score - a.score);
+      const entries2 = results.map((result) => result.entry);
+      yield* entries2;
       return;
     }
     for (const node of filter.nodes ?? this.nodes) {
@@ -2120,8 +2192,7 @@ var EntryGraph = class _EntryGraph {
     this.#search.add({
       id: entry.filePath,
       title: entry.title,
-      searchableText: entry.searchableText,
-      entry
+      searchableText: entry.searchableText
     });
   }
   #mkEntry(filePath) {
@@ -2136,7 +2207,7 @@ var EntryGraph = class _EntryGraph {
     const parentDir = segments.slice(0, -1).join("/");
     const childrenDir = `${parentDir}/${path}`;
     const seed = this.#seeds.get(childrenDir);
-    const data = { path, ...version.data, ...seed?.data };
+    const data = { path, ...seed?.data, ...version.data };
     let segmentIndex = 0;
     const workspace = this.#singleWorkspace ?? segments[segmentIndex++];
     const workspaceConfig = this.#config.workspaces[workspace];
@@ -2192,16 +2263,11 @@ var EntryGraph = class _EntryGraph {
     }
     const parent = parentId ? this.#mkNode(parentId) : null;
     const type = this.#config.schema[collection.type];
-    function* children() {
-      for (const node2 of this.nodes) {
-        if (node2.parentId === id) yield node2;
-      }
-    }
     const node = new EntryNode(
       this,
       type,
       parent,
-      children.bind(this),
+      () => this.#childrenByParentId.get(id) ?? [],
       collection
     );
     this.#byId.set(id, node);
@@ -2209,26 +2275,18 @@ var EntryGraph = class _EntryGraph {
   }
 };
 var VersionParser = class extends Map {
-  #config;
-  constructor(config) {
-    super();
-    this.#config = config;
-  }
   parse(sha, blob) {
     if (super.has(sha)) return super.get(sha);
     const decoder = new TextDecoder();
     const text = decoder.decode(blob);
     const raw = JSON.parse(text);
     const { meta, data } = parseRecord(raw);
-    const entryType = this.#config.schema[meta.type];
-    const searchableText = Type.searchableText(entryType, data);
     const version = {
       id: meta.id,
       type: meta.type,
       index: meta.index,
       data,
       title: data.title,
-      searchableText,
       seeded: meta.seeded ?? null,
       rowHash: sha,
       fileHash: sha
@@ -2239,7 +2297,7 @@ var VersionParser = class extends Map {
 };
 var ParserCache = class extends WeakMap {
   get = (config) => {
-    if (!this.has(config)) this.set(config, new VersionParser(config));
+    if (!this.has(config)) this.set(config, new VersionParser());
     return super.get(config);
   };
 };
@@ -2254,6 +2312,29 @@ function getNodePath(filePath) {
   if (base.endsWith(".draft")) base = base.slice(0, -".draft".length);
   return `${dir}/${base}`;
 }
+function entryRelation(node) {
+  return {
+    parentId: node.parentId,
+    index: node.index
+  };
+}
+function changedParentIds(previous, next) {
+  const ids = /* @__PURE__ */ new Set([...previous.keys(), ...next.keys()]);
+  const parents = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    const before = previous.get(id);
+    const after = next.get(id);
+    if (!before && after) {
+      if (after.parentId) parents.add(after.parentId);
+    } else if (before && !after) {
+      if (before.parentId) parents.add(before.parentId);
+    } else if (before && after && (before.parentId !== after.parentId || before.index !== after.index)) {
+      if (before.parentId) parents.add(before.parentId);
+      if (after.parentId) parents.add(after.parentId);
+    }
+  }
+  return parents;
+}
 var EntryIndex = class extends EventTarget {
   tree = ReadonlyTree.EMPTY;
   initialSync;
@@ -2261,6 +2342,9 @@ var EntryIndex = class extends EventTarget {
   #config;
   #seeds;
   #singleWorkspace;
+  #references;
+  #referencesBuild;
+  #syncLimit = pLimit(1);
   constructor(config) {
     super();
     this.#config = config;
@@ -2281,25 +2365,66 @@ var EntryIndex = class extends EventTarget {
   findMany(filter) {
     return this.graph.filter({ entry: filter });
   }
+  async referencesTo(query) {
+    const references = await this.references;
+    return references.referencesTo(query);
+  }
+  async referencesFrom(sourceId) {
+    const references = await this.references;
+    return references.referencesFrom(sourceId);
+  }
+  get references() {
+    if (this.#references) return Promise.resolve(this.#references);
+    this.#referencesBuild ??= EntryReferenceIndex.build(this.graph, {
+      onProgress: (scan) => {
+        this.dispatchEvent(new IndexEvent({ op: "references", ...scan }));
+      }
+    }).then((references) => {
+      this.#references = references;
+      return references;
+    });
+    return this.#referencesBuild;
+  }
+  async sync(source) {
+    return this.#syncLimit(async () => {
+      await this.syncWith(source);
+      await this.seed(source);
+      return this.sha;
+    });
+  }
   async syncWith(source) {
     const tree = await source.getTree();
     if (!this.initialSync) this.initialSync = tree;
     const batch = await bundleContents(source, this.tree.diff(tree));
     if (batch.changes.length === 0) return tree.sha;
-    return this.indexChanges(batch);
+    return this.indexChanges(batch, tree);
   }
-  async indexChanges(batch) {
+  async indexChanges(batch, targetTree) {
     const { fromSha, changes } = batch;
     if (fromSha !== this.tree.sha)
       throw new ShaMismatchError(fromSha, this.tree.sha);
     if (changes.length === 0) return this.tree.sha;
+    if (this.#referencesBuild && !this.#references) await this.#referencesBuild;
     const changed = /* @__PURE__ */ new Set();
+    const previousRelations = /* @__PURE__ */ new Map();
+    const nextRelations = /* @__PURE__ */ new Map();
+    const affectedReferenceIds = /* @__PURE__ */ new Set();
     for (const change of changes) {
       if (change.op !== "delete") continue;
       const nodePath = getNodePath(change.path);
       const node = this.graph.byDir(nodePath);
       assert(node, `Missing node for deleted path: ${change.path}`);
       changed.add(node);
+      previousRelations.set(node.id, entryRelation(node));
+    }
+    const references = this.#references;
+    if (references) {
+      for (const change of changes) {
+        if (change.op !== "delete") continue;
+        for (const id of references.removeFile(change.path)) {
+          affectedReferenceIds.add(id);
+        }
+      }
     }
     this.graph = this.graph.withChanges(batch);
     for (const change of changes) {
@@ -2308,19 +2433,37 @@ var EntryIndex = class extends EventTarget {
       const node = this.graph.byDir(nodePath);
       assert(node, `Missing node for added path: ${change.path}`);
       changed.add(node);
+      nextRelations.set(node.id, entryRelation(node));
+      if (references) {
+        const entry = this.graph.entryByFilePath(change.path);
+        if (entry) {
+          for (const id of references.replaceEntry(entry)) {
+            affectedReferenceIds.add(id);
+          }
+        }
+      }
     }
-    const updatedTree = await this.tree.withChanges(batch);
+    const updatedTree = targetTree ?? await this.tree.withChanges(batch);
     const sha = updatedTree.sha;
     this.tree = updatedTree;
+    const affectedParentIds = changedParentIds(previousRelations, nextRelations);
+    const changedEntryIds = /* @__PURE__ */ new Set();
     const pool = Array.from(changed);
     while (pool.length > 0) {
       const node = pool.shift();
-      this.dispatchEvent(new IndexEvent({ op: "entry", id: node.id }));
+      changedEntryIds.add(node.id);
       for (const child of node.children()) {
-        if (!changed.has(child)) pool.push(child);
+        if (!changed.has(child)) {
+          changed.add(child);
+          pool.push(child);
+        }
       }
     }
-    this.dispatchEvent(new IndexEvent({ op: "index", sha }));
+    for (const id of affectedParentIds) changedEntryIds.add(id);
+    for (const id of affectedReferenceIds) changedEntryIds.add(id);
+    this.dispatchEvent(
+      new IndexEvent({ op: "index", sha, ids: Array.from(changedEntryIds) })
+    );
     return sha;
   }
   async seed(source) {

package/dist/core/db/EntryReference.d.ts

@@ -0,0 +1,44 @@
+import type { EntryStatus } from 'alinea/core/Entry';
+import type { Status } from 'alinea/core/Graph';
+export type EntryReferenceLinkType = 'entry' | 'image' | 'file';
+export interface EntryReferenceTarget {
+    targetId: string;
+    fieldPath: string;
+    fieldLabel?: string;
+    linkId?: string;
+    linkType?: EntryReferenceLinkType;
+}
+export interface EntryReference {
+    targetId: string;
+    sourceId: string;
+    sourceFilePath: string;
+    sourceType: string;
+    sourceLocale: string | null;
+    sourceStatus: EntryStatus;
+    sourceActive: boolean;
+    sourceMain: boolean;
+    fieldPath: string;
+    fieldLabel?: string;
+    linkId?: string;
+    linkType?: EntryReferenceLinkType;
+}
+export interface EntryReferenceQuery {
+    targetId: string;
+    status?: Status;
+    locale?: string | null;
+}
+export interface EntryReferenceResult {
+    references: Array<EntryReference>;
+    total: number;
+    scan: EntryReferenceScan;
+}
+export interface FieldReferenceContext {
+    path: Array<string>;
+    label?: string;
+}
+export declare function referenceFieldPath(path: Array<string>): string;
+export interface EntryReferenceScan {
+    scanned: number;
+    total: number;
+    complete: boolean;
+}

package/dist/core/db/EntryReference.js

@@ -0,0 +1,9 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/core/db/EntryReference.ts
+function referenceFieldPath(path) {
+  return path.join(".");
+}
+export {
+  referenceFieldPath
+};

package/dist/core/db/EntryReferenceIndex.d.ts

@@ -0,0 +1,21 @@
+import type { Config } from 'alinea/core/Config';
+import type { EntryCondition } from 'alinea/core/db/EntryIndex';
+import { type EntryReference, type EntryReferenceQuery, type EntryReferenceResult, type EntryReferenceScan } from 'alinea/core/db/EntryReference';
+import type { Entry } from 'alinea/core/Entry';
+export interface EntryReferenceGraph {
+    config: Config;
+    filter(filter: EntryCondition): Iterable<Entry>;
+}
+export interface EntryReferenceBuildOptions {
+    onProgress?: (scan: EntryReferenceScan) => void;
+}
+export declare class EntryReferenceIndex {
+    #private;
+    static build(graph: EntryReferenceGraph, options?: EntryReferenceBuildOptions): Promise<EntryReferenceIndex>;
+    constructor(config: Config);
+    referencesTo(query: EntryReferenceQuery): EntryReferenceResult;
+    referencesFrom(sourceId: string): Array<EntryReference>;
+    replaceEntry(entry: Entry): Set<string>;
+    removeFile(filePath: string): Set<string>;
+    replaceFile(filePath: string, references: Array<EntryReference>): Set<string>;
+}

package/dist/core/db/EntryReferenceIndex.js

@@ -0,0 +1,131 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/core/db/EntryReferenceIndex.ts
+import { Type } from "alinea/core/Type";
+var EntryReferenceIndex = class _EntryReferenceIndex {
+  #config;
+  #refsByFilePath = /* @__PURE__ */ new Map();
+  #refsBySourceId = /* @__PURE__ */ new Map();
+  #refsByTargetId = /* @__PURE__ */ new Map();
+  #indexedFilePaths = /* @__PURE__ */ new Set();
+  static async build(graph, options = {}) {
+    const index = new _EntryReferenceIndex(graph.config);
+    const entries = Array.from(graph.filter({}));
+    let scanned = 0;
+    options.onProgress?.({
+      scanned,
+      total: entries.length,
+      complete: entries.length === 0
+    });
+    for (const entry of entries) {
+      index.replaceEntry(entry);
+      scanned += 1;
+      options.onProgress?.({
+        scanned,
+        total: entries.length,
+        complete: scanned === entries.length
+      });
+      if (scanned % 100 === 0) await Promise.resolve();
+    }
+    return index;
+  }
+  constructor(config) {
+    this.#config = config;
+  }
+  referencesTo(query) {
+    const all = this.#refsByTargetId.get(query.targetId) ?? [];
+    const filtered = all.filter((ref) => matchesReferenceQuery(ref, query));
+    return {
+      references: filtered,
+      total: filtered.length,
+      scan: {
+        scanned: this.#indexedFilePaths.size,
+        total: this.#indexedFilePaths.size,
+        complete: true
+      }
+    };
+  }
+  referencesFrom(sourceId) {
+    return [...this.#refsBySourceId.get(sourceId) ?? []];
+  }
+  replaceEntry(entry) {
+    this.#indexedFilePaths.add(entry.filePath);
+    return this.replaceFile(
+      entry.filePath,
+      entryReferences(this.#config, entry)
+    );
+  }
+  removeFile(filePath) {
+    this.#indexedFilePaths.delete(filePath);
+    return this.replaceFile(filePath, []);
+  }
+  replaceFile(filePath, references) {
+    const affected = /* @__PURE__ */ new Set();
+    const previous = this.#refsByFilePath.get(filePath) ?? [];
+    for (const reference of previous) {
+      affected.add(reference.targetId);
+      removeReference(this.#refsBySourceId, reference.sourceId, reference);
+      removeReference(this.#refsByTargetId, reference.targetId, reference);
+    }
+    if (references.length > 0) this.#refsByFilePath.set(filePath, references);
+    else this.#refsByFilePath.delete(filePath);
+    for (const reference of references) {
+      affected.add(reference.targetId);
+      addReference(this.#refsBySourceId, reference.sourceId, reference);
+      addReference(this.#refsByTargetId, reference.targetId, reference);
+    }
+    return affected;
+  }
+};
+function entryReferences(config, entry) {
+  const type = config.schema[entry.type];
+  if (!type) return [];
+  return Type.references(type, entry.data).map((target) => {
+    return entryReference(entry, target);
+  });
+}
+function entryReference(entry, target) {
+  return {
+    ...target,
+    sourceId: entry.id,
+    sourceFilePath: entry.filePath,
+    sourceType: entry.type,
+    sourceLocale: entry.locale,
+    sourceStatus: entry.status,
+    sourceActive: entry.active,
+    sourceMain: entry.main
+  };
+}
+function addReference(map, key, reference) {
+  const references = map.get(key);
+  if (references) references.push(reference);
+  else map.set(key, [reference]);
+}
+function removeReference(map, key, reference) {
+  const current = map.get(key);
+  if (!current) return;
+  const next = current.filter((item) => item !== reference);
+  if (next.length > 0) map.set(key, next);
+  else map.delete(key);
+}
+function matchesReferenceQuery(reference, query) {
+  if (query.locale !== void 0 && reference.sourceLocale !== query.locale)
+    return false;
+  switch (query.status ?? "published") {
+    case "published":
+      return reference.sourceStatus === "published";
+    case "draft":
+      return reference.sourceStatus === "draft";
+    case "archived":
+      return reference.sourceStatus === "archived";
+    case "preferDraft":
+      return reference.sourceActive;
+    case "preferPublished":
+      return reference.sourceMain;
+    case "all":
+      return true;
+  }
+}
+export {
+  EntryReferenceIndex
+};