flatpack-json 9.6.4 → 9.8.0

package/dist/storageV2.mjs

@@ -0,0 +1,451 @@
+import { CompactStorage } from './CompactStorage.mjs';
+import { FlatpackData } from './FlatpackData.mjs';
+import { extractObjectKeyAndValueIndexes, extractObjectKeyAndValueIndexesFrom, getFlatpackedRootIdx, } from './flatpacked.mjs';
+import { optimizeFlatpacked } from './optimizeFlatpacked.mjs';
+import { RefCounter } from './RefCounter.mjs';
+import { Trie } from './Trie.mjs';
+import { dataHeaderV2_0, ElementType } from './types.mjs';
+import { extractUnpackedAnnotation } from './unpackedAnnotation.mjs';
+import { WeakCache } from './WeakCache.mjs';
+const collator = new Intl.Collator('en', {
+    usage: 'sort',
+    numeric: true,
+    sensitivity: 'variant',
+    caseFirst: 'upper',
+    ignorePunctuation: false,
+});
+const compare = collator.compare;
+export class CompactStorageV2 extends CompactStorage {
+    data;
+    stringTable;
+    dedupe = true;
+    sortKeys = true;
+    emptyObjIdx = 0;
+    /**
+     * Cache of primitives and objects that have been added to the data.
+     */
+    cache = new WeakCache([[undefined, 0]]);
+    /**
+     * Set of indexes that have been referenced by other indexes.
+     */
+    referencedFromCache = new RefCounter();
+    /**
+     * Cache of arrays that have been deduped.
+     * The key is a hash of the array elements as a function of the index of the element.
+     */
+    cachedArrays = new Map();
+    cachedElementsTrie = new Trie();
+    unpackMetaData;
+    used = new Set();
+    constructor(options) {
+        super(options);
+        this.dedupe = options?.dedupe ?? true;
+        this.sortKeys = options?.sortKeys || this.dedupe;
+        this.unpackMetaData = undefined;
+        this.data = new FlatpackData(undefined);
+        this.stringTable = this.data.stringTable;
+        if (options?.meta) {
+            this.useFlatpackMetaData(options.meta);
+        }
+    }
+    primitiveToIdx(value) {
+        if (typeof value === 'string')
+            return this.stringToIdx(value);
+        if (typeof value === 'bigint')
+            return this.bigintToIdx(value);
+        if (value === undefined)
+            return 0;
+        const found = this.#getFromCacheAndReference(value);
+        if (found !== undefined && this.data.get(found) === value) {
+            return found;
+        }
+        return this.#setElement(value);
+    }
+    addStringPrimitive(value) {
+        return -this.stringTable.add(value);
+    }
+    stringToIdx(value) {
+        const found = this.#getFromCacheAndReference(value);
+        if (found !== undefined) {
+            return found;
+        }
+        return this.addStringPrimitive(value);
+    }
+    objSetToIdx(value) {
+        const found = this.#getFromCacheAndReference(value);
+        if (found !== undefined) {
+            return found;
+        }
+        const idx = this.#reserverForValue(value);
+        const keys = [...value];
+        const k = this.createUniqueKeys(keys, false);
+        const element = [ElementType.Set, k];
+        return this.storeElement(value, idx, element);
+    }
+    createUniqueKeys(keys, cacheValue = true) {
+        let k = this.arrToIdx(keys, cacheValue);
+        const elementKeys = this.data.get(k);
+        const uniqueKeys = new Set(elementKeys.slice(1));
+        if (uniqueKeys.size !== keys.length) {
+            // one or more of the keys got deduped. We need to duplicate it.
+            uniqueKeys.clear();
+            const indexes = elementKeys.slice(1).map((idx) => {
+                if (uniqueKeys.has(idx)) {
+                    return this.data.duplicateIndex(idx);
+                }
+                uniqueKeys.add(idx);
+                return idx;
+            });
+            k = this.createArrayElementFromIndexValues(this.data.reserve(), indexes);
+        }
+        return k;
+    }
+    objMapToIdx(value) {
+        const found = this.#getFromCacheAndReference(value);
+        if (found !== undefined) {
+            return found;
+        }
+        const idx = this.#reserverForValue(value);
+        const entries = [...value.entries()];
+        const k = this.createUniqueKeys(entries.map(([key]) => key), false);
+        const v = this.arrToIdx(entries.map(([, value]) => value), false);
+        const element = [ElementType.Map, k, v];
+        return this.storeElement(value, idx, element);
+    }
+    objRegExpToIdx(value) {
+        const found = this.#getFromCacheAndReference(value);
+        if (found !== undefined) {
+            return found;
+        }
+        const idx = this.#reserverForValue(value);
+        const element = [
+            ElementType.RegExp,
+            this.stringToIdx(value.source),
+            this.stringToIdx(value.flags),
+        ];
+        return this.storeElement(value, idx, element);
+    }
+    objDateToIdx(value) {
+        const found = this.#getFromCacheAndReference(value);
+        if (found !== undefined) {
+            return found;
+        }
+        const idx = this.#reserverForValue(value);
+        const element = [ElementType.Date, value.getTime()];
+        return this.storeElement(value, idx, element);
+    }
+    bigintToIdx(value) {
+        const found = this.#getFromCacheAndReference(value);
+        if (found !== undefined) {
+            return found;
+        }
+        const idx = this.#reserverForValue(value);
+        const element = [
+            ElementType.BigInt,
+            this.primitiveToIdx(value <= Number.MAX_SAFE_INTEGER && value >= -Number.MAX_SAFE_INTEGER
+                ? Number(value)
+                : value.toString()),
+        ];
+        return this.storeElement(value, idx, element);
+    }
+    objToIdx(value) {
+        const found = this.#getFromCacheAndReference(value);
+        if (found !== undefined) {
+            return found;
+        }
+        if (isObjectWrapper(value)) {
+            const idx = this.data.add({});
+            this.#cacheValue(value, idx);
+            const element = [ElementType.Object, 0, this.valueToIdx(value.valueOf())];
+            return this.storeElement(value, idx, element);
+        }
+        const entries = Object.entries(value);
+        if (!entries.length) {
+            if (this.emptyObjIdx) {
+                return this.emptyObjIdx;
+            }
+            const idx = this.data.add({});
+            this.emptyObjIdx = idx;
+            return idx;
+        }
+        if (this.sortKeys) {
+            entries.sort(([a], [b]) => compare(a, b));
+        }
+        const idx = this.#reserverForValue(value);
+        const kvp = this.#getObjectKeyValueIndexesFromMetaData(idx);
+        const k = this.objectKeysOrValuesToIdx(entries.map(([key]) => key), kvp?.[0]);
+        const v = this.objectKeysOrValuesToIdx(entries.map(([, value]) => value), kvp?.[1]);
+        const element = [ElementType.Object, k, v];
+        return this.storeElement(value, idx, element);
+    }
+    objectKeysOrValuesToIdx(keys, idx) {
+        const element = [ElementType.Array, ...this.mapValuesToIndexes(keys)];
+        const cachedIdx = this.cacheElement(element, idx);
+        const useIdx = idx ?? cachedIdx;
+        this.data.set(useIdx, element);
+        return useIdx;
+    }
+    mapValuesToIndexes(values) {
+        return values.map((value) => this.valueToIdx(value));
+    }
+    /**
+     * Store an element in the data array, using the cache if deduplication is enabled.
+     * @param value - the value being stored, used for caching purposes.
+     * @param idx - the index at which to store the element if it is not found in the cache.
+     * @param element - the element to store if it is not found in the cache.
+     * @returns the index at which the element is stored.
+     */
+    storeElement(value, idx, element) {
+        const useIdx = this.dedupe ? this.cacheElement(element, idx) : idx;
+        if (useIdx !== idx) {
+            this.data.delete(idx);
+            return this.#cacheValue(value, useIdx);
+        }
+        this.data.set(idx, element);
+        return idx;
+    }
+    cacheElement(element, elemIdx) {
+        const foundIdx = this.cachedElementsTrie.get(element);
+        if (foundIdx === undefined) {
+            const idx = elemIdx ?? this.data.reserve();
+            this.cachedElementsTrie.set(element, idx);
+            return idx;
+        }
+        if (elemIdx && this.referencedFromCache.isReferenced(elemIdx)) {
+            if (!this.referencedFromCache.isReferenced(foundIdx)) {
+                this.cachedElementsTrie.set(element, elemIdx);
+            }
+            return elemIdx;
+        }
+        const foundElement = this.data.get(foundIdx);
+        if (!this.referencedFromCache.isReferenced(foundIdx) && !isArrayEqual(foundElement, element)) {
+            const idx = elemIdx ?? this.data.reserve();
+            this.cachedElementsTrie.set(element, idx);
+            return idx;
+        }
+        return foundIdx;
+    }
+    stashArray(idx, element) {
+        const indexHash = simpleHash(element);
+        let found = this.cachedArrays.get(indexHash);
+        if (!found) {
+            found = [];
+            this.cachedArrays.set(indexHash, found);
+        }
+        // It is possible for an array to have a circular reference to itself (possibly through a nested object).
+        // In that case, we want to treat it as a unique array and not dedupe
+        // it with other arrays that have the same content.
+        if (this.referencedFromCache.isReferenced(idx)) {
+            found.push(idx);
+            return idx;
+        }
+        const foundIdx = found.find((entryIdx) => isArrayEqual(this.data.get(entryIdx), element));
+        if (foundIdx) {
+            return foundIdx;
+        }
+        found.push(idx);
+        return idx;
+    }
+    createArrayElementFromIndexValues(idx, indexValues) {
+        const element = [ElementType.Array, ...indexValues];
+        const useIdx = this.dedupe ? this.stashArray(idx, element) : idx;
+        if (useIdx !== idx) {
+            this.data.delete(idx);
+            this.data.markUsed(useIdx);
+            return useIdx;
+        }
+        this.data.set(idx, element);
+        return idx;
+    }
+    /**
+     * Convert an array to an index.
+     * @param value - The array to convert to an index.
+     * @param cacheValue - Whether to cache the value.
+     * @returns the index of the array.
+     */
+    arrToIdx(value, cacheValue = true) {
+        const found = this.#getFromCacheAndReference(value);
+        if (found !== undefined) {
+            return found;
+        }
+        const idx = this.#reserverForValue(value, cacheValue);
+        const useIdx = this.createArrayElementFromIndexValues(idx, value.map((idx) => this.valueToIdx(idx)));
+        if (cacheValue) {
+            this.cache.set(value, useIdx);
+        }
+        return useIdx;
+    }
+    valueToIdx(value) {
+        if (value === null) {
+            return this.primitiveToIdx(value);
+        }
+        if (typeof value === 'object') {
+            if (value instanceof Set) {
+                return this.objSetToIdx(value);
+            }
+            if (value instanceof Map) {
+                return this.objMapToIdx(value);
+            }
+            if (value instanceof RegExp) {
+                return this.objRegExpToIdx(value);
+            }
+            if (Array.isArray(value)) {
+                return this.arrToIdx(value);
+            }
+            if (value instanceof Date) {
+                return this.objDateToIdx(value);
+            }
+            return this.objToIdx(value);
+        }
+        return this.primitiveToIdx(value);
+    }
+    #reserverForValue(value, cacheValue = true) {
+        const valueIdx = this.#getAvailableValueIndexFromAnnotation(value);
+        const idx = valueIdx ?? this.data.reserve();
+        this.data.markUsed(idx);
+        if (cacheValue) {
+            this.cache.set(value, idx);
+        }
+        return idx;
+    }
+    #getAvailableValueIndexFromAnnotation(value) {
+        const idx = this.#getValueIndexFromAnnotation(value);
+        return idx !== undefined && !this.data.isUsed(idx) ? idx : undefined;
+    }
+    #getValueIndexFromAnnotation(value) {
+        const annotation = extractUnpackedAnnotation(value);
+        if (!annotation || annotation.meta !== this.unpackMetaData)
+            return undefined;
+        return annotation.index;
+    }
+    #getSrcElementFromMetaData(idx) {
+        const flatpack = this.unpackMetaData?.flatpack;
+        return flatpack?.[idx];
+    }
+    #getObjectKeyValueIndexesFromMetaData(idx) {
+        const kvp = extractObjectKeyAndValueIndexesFrom(this.#getSrcElementFromMetaData(idx));
+        if (!kvp)
+            return undefined;
+        const [k, v] = kvp;
+        const key = (k && this.data.claimOwnership(k, idx) === idx && k) || undefined;
+        const value = (v && this.data.claimOwnership(v, idx) === idx && v) || undefined;
+        return [key, value];
+    }
+    #setElement(value) {
+        const idx = this.data.add(value);
+        this.#cacheValue(value, idx);
+        return idx;
+    }
+    /**
+     * Reset things in a way that allows for reuse.
+     */
+    softReset() {
+        this.cache.clear();
+        this.cache.set(undefined, 0);
+        this.cachedArrays.clear();
+        this.cachedElementsTrie.clear();
+        this.referencedFromCache.clear();
+        this.used.clear();
+        this.data = new FlatpackData([dataHeaderV2_0, this.stringTable.build()]);
+        this.stringTable = this.data.stringTable;
+        this.emptyObjIdx = 0;
+    }
+    useFlatpackMetaData(data) {
+        if (!data || data.flatpack[0] !== dataHeaderV2_0) {
+            return;
+        }
+        this.softReset();
+        this.unpackMetaData = data;
+        this.data = new FlatpackData(data.flatpack);
+        this.stringTable = this.data.stringTable;
+        this.initFromFlatpackData();
+        // Clear the referenced indexes since we don't want to treat them as referenced when we re-pack the data.
+        this.referencedFromCache.clear();
+    }
+    /**
+     * Cache the primitives from the unpacked data to improve performance when re-packing the same data.
+     */
+    initFromFlatpackData() {
+        const data = this.data.flatpack;
+        const rootIndex = getFlatpackedRootIdx(data);
+        const idxOfObjectKeysAndValues = new Set();
+        for (let i = rootIndex; i < data.length; ++i) {
+            const objKeysAndValues = extractObjectKeyAndValueIndexes(data[i]);
+            for (const idx of objKeysAndValues) {
+                idxOfObjectKeysAndValues.add(idx);
+            }
+        }
+        for (let i = rootIndex + 1; i < data.length; ++i) {
+            this.useFlattenedElement(data[i], i, idxOfObjectKeysAndValues);
+        }
+    }
+    useFlattenedElement(element, index, idxOfObjectKeysAndValues) {
+        // Primitives and null are cached directly.
+        if (!element || typeof element !== 'object') {
+            this.cache.set(element, index);
+            return;
+        }
+        if (!Array.isArray(element))
+            return;
+        // Arrays are cached based on their content, so we need to handle them separately.
+        if (!idxOfObjectKeysAndValues.has(index) && element[0] === ElementType.Array) {
+            this.stashArray(index, element);
+            return;
+        }
+        // Other objects are cached based on their identity, so we can cache them directly.
+        this.cachedElementsTrie.set(element, index);
+    }
+    #cacheValue(value, idx) {
+        this.cache.set(value, idx);
+        return idx;
+    }
+    #getFromCacheAndReference(value) {
+        const found = this.cache.get(value);
+        if (found !== undefined) {
+            this.data.markUsed(found);
+            this.#addReference(found);
+        }
+        return found;
+    }
+    #addReference(idx) {
+        this.referencedFromCache.add(idx);
+    }
+    toJSON(json) {
+        this.softReset();
+        const annotation = extractUnpackedAnnotation(json);
+        this.useFlatpackMetaData(this.unpackMetaData ?? annotation?.meta);
+        const lastIdx = this.valueToIdx(json);
+        if (lastIdx < 0) {
+            this.data.add([ElementType.String, lastIdx]);
+        }
+        const data = this.data.finalize();
+        return this.options?.optimize ? optimizeFlatpacked(data) : data;
+    }
+}
+function isArrayEqual(a, b) {
+    if (!Array.isArray(a) || !Array.isArray(b))
+        return false;
+    if (a === b)
+        return true;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+function simpleHash(values) {
+    let hash = Math.sqrt(values.length);
+    for (const value of values) {
+        hash += value * value;
+    }
+    return hash;
+}
+function isObjectWrapper(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.valueOf === 'function' &&
+        value.valueOf() !== value);
+}
+//# sourceMappingURL=storageV2.mjs.map

package/dist/stringTable.d.mts

@@ -0,0 +1,39 @@
+import type { StringTableElement } from './types.mjs';
+export declare class StringTable {
+    #private;
+    readonly stringTableElement: StringTableElement;
+    constructor(stringTableElement: StringTableElement);
+    get(index: number): string | undefined;
+    entries(): Iterable<[number, string]>;
+    values(): Iterable<string>;
+    get size(): number;
+}
+export declare class StringTableBuilder {
+    #private;
+    splitStrings: boolean;
+    tokenRegex: RegExp;
+    constructor(stringTableElement?: StringTableElement);
+    set splitIntoTokensWhenAdding(value: boolean);
+    get splitIntoTokensWhenAdding(): boolean;
+    add(str: string): number;
+    getIndex(str: string): number | undefined;
+    get(index: number): string | undefined;
+    /**
+     * Increments the reference count for the given index.
+     * @param index - The index of the string in the string table. The absolute value is used.
+     * @returns the new reference count for the string at the given index.
+     */
+    addRef(index: number): number;
+    getRefCount(index: number): number;
+    clearUnusedEntries(): this;
+    tokenizeAllEntries(): this;
+    /**
+     * Sorts the entries in the string table by reference count, with the most referenced strings first.
+     * This can help reduce the size of the string table when serialized, as more frequently used strings
+     * will have smaller indexes.
+     * @returns a map of old indexes to new indexes after sorting. The index 0 is always mapped to itself.
+     */
+    sortEntriesByRefCount(): Map<number, number>;
+    build(): StringTableElement;
+}
+//# sourceMappingURL=stringTable.d.mts.map

package/dist/stringTable.mjs

@@ -0,0 +1,213 @@
+import assert from 'node:assert';
+import { ElementType } from './types.mjs';
+export class StringTable {
+    stringTableElement;
+    constructor(stringTableElement) {
+        this.stringTableElement = stringTableElement;
+    }
+    get(index) {
+        if (!index)
+            return '';
+        index = index < 0 ? -index : index;
+        if (index >= this.stringTableElement.length)
+            return undefined;
+        return this.#getCompoundString(index);
+    }
+    *entries() {
+        for (let i = 1; i < this.stringTableElement.length; i++) {
+            yield [i, this.#getCompoundString(i)];
+        }
+    }
+    *values() {
+        for (const entry of this.entries()) {
+            yield entry[1];
+        }
+    }
+    get size() {
+        return this.stringTableElement.length;
+    }
+    #getCompoundString(index, visited = new Set()) {
+        if (visited.has(index)) {
+            throw new Error(`Circular reference in string table at index ${index}`);
+        }
+        const entry = this.stringTableElement[index];
+        if (typeof entry === 'string') {
+            return entry;
+        }
+        if (Array.isArray(entry)) {
+            visited.add(index);
+            const value = entry.map((i) => this.#getCompoundString(i, visited)).join('');
+            visited.delete(index);
+            return value;
+        }
+        throw new Error(`Invalid string table entry at index ${index}`);
+    }
+}
+const tokenRegex = /\w+/g;
+export class StringTableBuilder {
+    splitStrings = false;
+    #stringToIndex = new Map();
+    #entries = [{ value: '', entry: '', refCount: 0 }];
+    #availableIndexes = [];
+    tokenRegex = tokenRegex;
+    #splitIntoTokens = false;
+    constructor(stringTableElement) {
+        if (!stringTableElement)
+            return;
+        const st = new StringTable(stringTableElement);
+        for (const [idx, value] of st.entries()) {
+            if (!idx)
+                continue;
+            const entry = stringTableElement[idx];
+            this.#entries[idx] = { value, entry, refCount: 0 };
+            if (Array.isArray(entry) && !entry.length) {
+                this.#availableIndexes.push(idx);
+                continue;
+            }
+            if (!this.#stringToIndex.has(value)) {
+                this.#stringToIndex.set(value, idx);
+            }
+        }
+    }
+    set splitIntoTokensWhenAdding(value) {
+        this.#splitIntoTokens = value;
+    }
+    get splitIntoTokensWhenAdding() {
+        return this.#splitIntoTokens;
+    }
+    add(str) {
+        const found = this.#stringToIndex.get(str);
+        if (found !== undefined) {
+            const entry = this.#entries[found];
+            entry.refCount++;
+            return found;
+        }
+        str ||= '';
+        return this.#append(str);
+    }
+    getIndex(str) {
+        return this.#stringToIndex.get(str);
+    }
+    get(index) {
+        const entry = this.#getEntry(index);
+        return entry?.value;
+    }
+    /**
+     * Increments the reference count for the given index.
+     * @param index - The index of the string in the string table. The absolute value is used.
+     * @returns the new reference count for the string at the given index.
+     */
+    addRef(index) {
+        const entry = this.#getEntryCheckBounds(index);
+        const count = ++entry.refCount;
+        if (count === 1 && Array.isArray(entry.entry)) {
+            entry.entry.forEach((i) => this.addRef(i));
+        }
+        return count;
+    }
+    getRefCount(index) {
+        const entry = this.#getEntryCheckBounds(index);
+        return entry.refCount;
+    }
+    #getEntry(index) {
+        index = index < 0 ? -index : index;
+        return this.#entries[index];
+    }
+    #getEntryCheckBounds(index) {
+        const entry = this.#getEntry(index);
+        if (!entry) {
+            throw new Error(`Invalid string table index: ${index}`);
+        }
+        return entry;
+    }
+    #append(str) {
+        const found = this.#stringToIndex.get(str);
+        if (found !== undefined) {
+            return found;
+        }
+        const entry = { value: str, entry: str, refCount: 1 };
+        const idx = this.#availableIndexes.shift() ?? this.#entries.length;
+        this.#entries[idx] = entry;
+        this.#stringToIndex.set(str, idx);
+        if (this.#splitIntoTokens) {
+            this.#splitEntryIntoTokens(entry);
+        }
+        return idx;
+    }
+    #splitEntryIntoTokens(entry) {
+        if (Array.isArray(entry.entry))
+            return;
+        if (!entry.value)
+            return;
+        const regex = new RegExp(this.tokenRegex);
+        const indexes = [...entry.value.matchAll(regex)].flatMap((match) => [
+            match.index,
+            match.index + match[0].length,
+        ]);
+        if (!indexes.length)
+            return;
+        if (indexes.length === 2 && indexes[0] === 0 && indexes[1] === entry.value.length) {
+            return;
+        }
+        const subEntries = [];
+        entry.entry = subEntries;
+        indexes.push(entry.value.length);
+        let lastIndex = 0;
+        for (const index of indexes) {
+            if (index === lastIndex)
+                continue;
+            const value = entry.value.slice(lastIndex, index);
+            subEntries.push(this.add(value));
+            lastIndex = index;
+        }
+    }
+    clearUnusedEntries() {
+        for (let i = 1; i < this.#entries.length; i++) {
+            const entry = this.#entries[i];
+            if (entry.refCount > 0)
+                continue;
+            if (this.#stringToIndex.get(entry.value) === i) {
+                this.#stringToIndex.delete(entry.value);
+            }
+            this.#entries[i] = { value: '', entry: [], refCount: 0 };
+            this.#availableIndexes.push(i);
+        }
+        return this;
+    }
+    tokenizeAllEntries() {
+        for (const entry of this.#entries) {
+            this.#splitEntryIntoTokens(entry);
+        }
+        return this;
+    }
+    /**
+     * Sorts the entries in the string table by reference count, with the most referenced strings first.
+     * This can help reduce the size of the string table when serialized, as more frequently used strings
+     * will have smaller indexes.
+     * @returns a map of old indexes to new indexes after sorting. The index 0 is always mapped to itself.
+     */
+    sortEntriesByRefCount() {
+        const mapEntryToOldIndex = new Map(this.#entries.map((entry, index) => [entry, index]));
+        const entry0 = this.#entries[0];
+        const sorted = this.#entries.sort((a, b) => a === entry0 ? -1 : b === entry0 ? 1 : b.refCount - a.refCount || getOldIndex(a) - getOldIndex(b));
+        const oldIndexToNew = new Map(sorted.map((entry, index) => [getOldIndex(entry), index]));
+        for (const entry of this.#entries) {
+            if (!Array.isArray(entry.entry))
+                continue;
+            entry.entry = entry.entry.map((i) => oldIndexToNew.get(i) ?? i);
+        }
+        for (const [str, oldIdx] of this.#stringToIndex.entries()) {
+            this.#stringToIndex.set(str, oldIndexToNew.get(oldIdx) ?? oldIdx);
+        }
+        return oldIndexToNew;
+        function getOldIndex(entry) {
+            const oldIndex = mapEntryToOldIndex.get(entry);
+            assert(oldIndex !== undefined, 'Entry not found in map');
+            return oldIndex;
+        }
+    }
+    build() {
+        return [ElementType.StringTable, ...this.#entries.slice(1).map((e) => e.entry)];
+    }
+}
+//# sourceMappingURL=stringTable.mjs.map