@lakutata/orm 3.0.0 → 3.1.1

package/dist/vendor/typeorm/driver/mongo-embedded/EmbeddedKeyEncoding.js

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddedKeyEncoding = void 0;
+const TypeORMError_1 = require("../../error/TypeORMError");
+/**
+ * lakutata: the tags of the encoded values, in the order of the types of MongoDB (its brackets of comparison).
+ */
+const Tag = {
+    MinKey: 0x01,
+    Null: 0x05,
+    Number: 0x10,
+    String: 0x20,
+    Object: 0x30,
+    Array: 0x40,
+    Binary: 0x50,
+    ObjectId: 0x60,
+    Boolean: 0x70,
+    Date: 0x80,
+    Timestamp: 0x90,
+    RegExp: 0xa0,
+    Other: 0xe0,
+    MaxKey: 0xfe,
+};
+/**
+ * lakutata: the bound of the integers of 64 bits (2^63).
+ */
+const LONG_BOUND = 2n ** 63n;
+/**
+ * lakutata: the integer of a Decimal128 (its string) when it is one; undefined for a fraction, NaN or an infinity.
+ *
+ * @param text
+ */
+function integerOf(text) {
+    const parts = /^(-?)(\d+)(?:\.(\d+))?(?:E([+-]\d+))?$/i.exec(text);
+    if (!parts)
+        return undefined;
+    const [, sign, whole, fraction = "", exponent = "0"] = parts;
+    // The digits, and the power of 10 they are multiplied by
+    const shift = Number(exponent) - fraction.length;
+    // An integer of more than 64 bits: rounded as a double (its digits not computed)
+    if (whole.length + Number(exponent) > 20)
+        return undefined;
+    let digits = BigInt(whole + fraction);
+    if (shift >= 0)
+        digits *= 10n ** BigInt(shift);
+    else {
+        const divisor = 10n ** BigInt(-shift);
+        if (digits % divisor !== 0n)
+            return undefined;
+        digits /= divisor;
+    }
+    return sign ? -digits : digits;
+}
+/**
+ * lakutata: encodes the values of the indexes as bytes whose order (compared as bytes) is the one of MongoDB for the
+ * numbers, the strings, the dates, the booleans, the ObjectIds and the binaries; the other values are encoded by
+ * their Extended JSON, equal when they are. Each value is self-delimiting (a string is terminated, its zero bytes
+ * escaped): the keys of several fields are their values concatenated, those of a descending field inverted. A
+ * number is its double, then the difference of an integer of 64 bits from it (the integers beyond 2^53 a double
+ * rounds): the integers are exact (a Long, a bigint, a Decimal128 of an integer; 2^53 + 1 one key in all of them), the
+ * Decimal128 of a fraction rounded to their double (more than 15 significant digits may share a key).
+ */
+class EmbeddedKeyEncoding {
+    constructor(values) {
+        this.values = values;
+    }
+    /**
+     * Encodes a value.
+     *
+     * @param value
+     */
+    encode(value) {
+        if (value === null || value === undefined)
+            return Buffer.of(Tag.Null);
+        switch (typeof value) {
+            case "number":
+                return this.number(Tag.Number, value);
+            case "string":
+                return this.string(Tag.String, value);
+            case "boolean":
+                return Buffer.of(Tag.Boolean, value ? 1 : 0);
+            case "bigint":
+                return this.integer(value);
+        }
+        if (value instanceof Date)
+            return this.number(Tag.Date, value.getTime());
+        const bson = this.values.bson;
+        switch (value._bsontype) {
+            case "ObjectId": {
+                const key = Buffer.allocUnsafe(13);
+                key[0] = Tag.ObjectId;
+                key.set(value.id, 1);
+                return key;
+            }
+            case "Binary": {
+                const bytes = value.buffer.subarray(0, value.position ?? value.buffer.length);
+                const key = Buffer.allocUnsafe(6 + bytes.length);
+                key[0] = Tag.Binary;
+                key.writeUInt32BE(bytes.length, 1);
+                key[5] = value.sub_type;
+                key.set(bytes, 6);
+                return key;
+            }
+            case "Long":
+                return this.integer(BigInt(value.toString()));
+            case "Int32":
+            case "Double":
+                return this.number(Tag.Number, Number(value.valueOf()));
+            case "Decimal128": {
+                const integer = integerOf(value.toString());
+                return integer === undefined
+                    ? this.number(Tag.Number, Number(value.toString()))
+                    : this.integer(integer);
+            }
+            case "Timestamp": {
+                const key = Buffer.allocUnsafe(9);
+                key[0] = Tag.Timestamp;
+                key.writeBigUInt64BE(BigInt(value.toString()), 1);
+                return key;
+            }
+            case "MinKey":
+                return Buffer.of(Tag.MinKey);
+            case "MaxKey":
+                return Buffer.of(Tag.MaxKey);
+        }
+        const text = bson.EJSON.stringify(value, { relaxed: false });
+        if (value instanceof RegExp || value._bsontype === "BSONRegExp")
+            return this.string(Tag.RegExp, text);
+        if (Array.isArray(value))
+            return this.string(Tag.Array, text);
+        if (typeof value._bsontype === "string")
+            return this.string(Tag.Other, text);
+        return this.string(Tag.Object, text);
+    }
+    /**
+     * Whether an index keeps the order of a value: a range of it may be read in the index.
+     *
+     * @param value
+     */
+    isOrdered(value) {
+        return (typeof value === "number" ||
+            typeof value === "string" ||
+            typeof value === "boolean" ||
+            value instanceof Date ||
+            (value !== null &&
+                typeof value === "object" &&
+                (value._bsontype === "ObjectId" ||
+                    value._bsontype === "Binary")));
+    }
+    /**
+     * The first byte of the encoding of the values of the type of a value, and the first byte after them: the range
+     * of the encodings of its type.
+     *
+     * @param value
+     */
+    bracketOf(value) {
+        const tag = this.encode(value)[0];
+        return [tag, tag + 1];
+    }
+    /**
+     * The keys of a document in an index of fields (1 ascending, -1 descending): one per value of the field that is an
+     * array (MongoDB indexes each of its items), none when the index is sparse and the document has none of its
+     * fields. The values missing are null.
+     *
+     * @param fields the fields of the index and their directions
+     * @param sparse
+     * @param document
+     */
+    keysOf(fields, sparse, document) {
+        const paths = Object.keys(fields);
+        const values = paths.map((path) => this.valuesAt(document, path));
+        if (sparse && values.every((items) => items === undefined))
+            return [];
+        const multiple = values.filter((items) => items !== undefined && items.length > 1);
+        if (multiple.length > 1)
+            throw new TypeORMError_1.TypeORMError(`cannot index parallel arrays [${paths.join("] [")}]`);
+        let keys = [Buffer.alloc(0)];
+        paths.forEach((path, index) => {
+            const items = values[index] ?? [null];
+            const encoded = this.unique(items.map((item) => this.direct(this.encode(item), fields[path])));
+            keys = keys.flatMap((key) => encoded.map((item) => Buffer.concat([key, item])));
+        });
+        return this.unique(keys);
+    }
+    /**
+     * The encoding of a value in a field of a direction (-1: inverted).
+     *
+     * @param encoded
+     * @param direction
+     */
+    direct(encoded, direction) {
+        if (direction !== -1 && direction !== "-1")
+            return encoded;
+        const inverted = Buffer.allocUnsafe(encoded.length);
+        for (let index = 0; index < encoded.length; index++)
+            inverted[index] = ~encoded[index] & 0xff;
+        return inverted;
+    }
+    /**
+     * The values at a path of a document, as MongoDB indexes them: the items of the arrays it meets (the arrays of
+     * objects followed by the path), an empty array as null; undefined when it has none.
+     *
+     * @param document
+     * @param path
+     */
+    valuesAt(document, path) {
+        let current = [document];
+        for (const name of path.split(".")) {
+            const next = [];
+            for (const value of current) {
+                // An index of an array ("tags.0"), and the field of its items
+                if (Array.isArray(value) && /^\d+$/.test(name) && value[Number(name)] !== undefined)
+                    next.push(value[Number(name)]);
+                const items = Array.isArray(value) ? value : [value];
+                for (const item of items)
+                    if (item !== null &&
+                        typeof item === "object" &&
+                        !Array.isArray(item) &&
+                        item[name] !== undefined)
+                        next.push(item[name]);
+            }
+            if (!next.length)
+                return undefined;
+            current = next;
+        }
+        const values = current.flatMap((value) => Array.isArray(value) ? (value.length ? value : [null]) : [value]);
+        return values;
+    }
+    /**
+     * A double ordered as bytes (a number, a date): its tag, its 8 bytes; a number then the difference of its integer
+     * from the double (2 bytes, 0 for the doubles), ordering the integers a double rounds.
+     *
+     * @param tag
+     * @param value
+     * @param difference the integer minus the double (|difference| <= 1024 for the integers of 64 bits)
+     */
+    number(tag, value, difference = 0) {
+        const key = Buffer.allocUnsafe(tag === Tag.Number ? 11 : 9);
+        key[0] = tag;
+        if (tag === Tag.Number)
+            key.writeUInt16BE(difference + 0x8000, 9);
+        // NaN before all the numbers (-Infinity included), as MongoDB sorts it
+        if (Number.isNaN(value)) {
+            key.fill(0, 1, 9);
+            return key;
+        }
+        // -0 and 0 one key, as MongoDB compares them
+        key.writeDoubleBE(value === 0 ? 0 : value, 1);
+        // The bits of a double ordered as bytes: the sign bit set for the positive ones, all of them inverted for the
+        // negative ones
+        if (key[1] & 0x80)
+            for (let index = 1; index < 9; index++)
+                key[index] = ~key[index] & 0xff;
+        else
+            key[1] |= 0x80;
+        return key;
+    }
+    /**
+     * An integer, exact up to 64 bits: its double, then its difference from it (the integers larger are rounded to
+     * their double).
+     *
+     * @param value
+     */
+    integer(value) {
+        const double = Number(value);
+        if (value < -LONG_BOUND || value > LONG_BOUND)
+            return this.number(Tag.Number, double);
+        return this.number(Tag.Number, double, Number(value - BigInt(double)));
+    }
+    /**
+     * A string terminated by two zero bytes, its zero bytes escaped (0 then 1): its order kept, self-delimiting.
+     *
+     * @param tag
+     * @param value
+     */
+    string(tag, value) {
+        const bytes = Buffer.from(value, "utf8");
+        let zeros = 0;
+        for (const byte of bytes)
+            if (byte === 0)
+                zeros++;
+        const key = Buffer.allocUnsafe(1 + bytes.length + zeros + 2);
+        key[0] = tag;
+        let position = 1;
+        for (const byte of bytes) {
+            key[position++] = byte;
+            if (byte === 0)
+                key[position++] = 1;
+        }
+        key[position++] = 0;
+        key[position] = 0;
+        return key;
+    }
+    unique(keys) {
+        const seen = new Set();
+        return keys.filter((key) => {
+            const text = key.toString("latin1");
+            if (seen.has(text))
+                return false;
+            seen.add(text);
+            return true;
+        });
+    }
+}
+exports.EmbeddedKeyEncoding = EmbeddedKeyEncoding;
+//# sourceMappingURL=EmbeddedKeyEncoding.js.map

package/dist/vendor/typeorm/driver/mongo-embedded/EmbeddedKeyEncoding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmbeddedKeyEncoding.js","sourceRoot":"","sources":["../../../../../vendor/typeorm/driver/mongo-embedded/EmbeddedKeyEncoding.ts"],"names":[],"mappings":"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","sourcesContent":["import { TypeORMError } from \"../../error/TypeORMError\"\nimport type { EmbeddedDocument, EmbeddedValues } from \"./EmbeddedValues\"\n\n/**\n * lakutata: the tags of the encoded values, in the order of the types of MongoDB (its brackets of comparison).\n */\nconst Tag = {\n    MinKey: 0x01,\n    Null: 0x05,\n    Number: 0x10,\n    String: 0x20,\n    Object: 0x30,\n    Array: 0x40,\n    Binary: 0x50,\n    ObjectId: 0x60,\n    Boolean: 0x70,\n    Date: 0x80,\n    Timestamp: 0x90,\n    RegExp: 0xa0,\n    Other: 0xe0,\n    MaxKey: 0xfe,\n} as const\n\n/**\n * lakutata: the bound of the integers of 64 bits (2^63).\n */\nconst LONG_BOUND = 2n ** 63n\n\n/**\n * lakutata: the integer of a Decimal128 (its string) when it is one; undefined for a fraction, NaN or an infinity.\n *\n * @param text\n */\nfunction integerOf(text: string): bigint | undefined {\n    const parts = /^(-?)(\\d+)(?:\\.(\\d+))?(?:E([+-]\\d+))?$/i.exec(text)\n    if (!parts) return undefined\n    const [, sign, whole, fraction = \"\", exponent = \"0\"] = parts\n    // The digits, and the power of 10 they are multiplied by\n    const shift = Number(exponent) - fraction.length\n    // An integer of more than 64 bits: rounded as a double (its digits not computed)\n    if (whole.length + Number(exponent) > 20) return undefined\n    let digits = BigInt(whole + fraction)\n    if (shift >= 0) digits *= 10n ** BigInt(shift)\n    else {\n        const divisor = 10n ** BigInt(-shift)\n        if (digits % divisor !== 0n) return undefined\n        digits /= divisor\n    }\n    return sign ? -digits : digits\n}\n\n/**\n * lakutata: the types of the values whose encoding keeps their order (the ranges of an index may be used for them).\n */\nexport type EmbeddedOrderedValue = number | string | Date | boolean | object\n\n/**\n * lakutata: encodes the values of the indexes as bytes whose order (compared as bytes) is the one of MongoDB for the\n * numbers, the strings, the dates, the booleans, the ObjectIds and the binaries; the other values are encoded by\n * their Extended JSON, equal when they are. Each value is self-delimiting (a string is terminated, its zero bytes\n * escaped): the keys of several fields are their values concatenated, those of a descending field inverted. A\n * number is its double, then the difference of an integer of 64 bits from it (the integers beyond 2^53 a double\n * rounds): the integers are exact (a Long, a bigint, a Decimal128 of an integer; 2^53 + 1 one key in all of them), the\n * Decimal128 of a fraction rounded to their double (more than 15 significant digits may share a key).\n */\nexport class EmbeddedKeyEncoding {\n    constructor(protected readonly values: EmbeddedValues) {}\n\n    /**\n     * Encodes a value.\n     *\n     * @param value\n     */\n    encode(value: any): Buffer {\n        if (value === null || value === undefined) return Buffer.of(Tag.Null)\n        switch (typeof value) {\n            case \"number\":\n                return this.number(Tag.Number, value)\n            case \"string\":\n                return this.string(Tag.String, value)\n            case \"boolean\":\n                return Buffer.of(Tag.Boolean, value ? 1 : 0)\n            case \"bigint\":\n                return this.integer(value)\n        }\n        if (value instanceof Date)\n            return this.number(Tag.Date, value.getTime())\n        const bson = this.values.bson\n        switch (value._bsontype) {\n            case \"ObjectId\": {\n                const key = Buffer.allocUnsafe(13)\n                key[0] = Tag.ObjectId\n                key.set(value.id, 1)\n                return key\n            }\n            case \"Binary\": {\n                const bytes: Uint8Array = value.buffer.subarray(\n                    0,\n                    value.position ?? value.buffer.length,\n                )\n                const key = Buffer.allocUnsafe(6 + bytes.length)\n                key[0] = Tag.Binary\n                key.writeUInt32BE(bytes.length, 1)\n                key[5] = value.sub_type\n                key.set(bytes, 6)\n                return key\n            }\n            case \"Long\":\n                return this.integer(BigInt(value.toString()))\n            case \"Int32\":\n            case \"Double\":\n                return this.number(Tag.Number, Number(value.valueOf()))\n            case \"Decimal128\": {\n                const integer = integerOf(value.toString())\n                return integer === undefined\n                    ? this.number(Tag.Number, Number(value.toString()))\n                    : this.integer(integer)\n            }\n            case \"Timestamp\": {\n                const key = Buffer.allocUnsafe(9)\n                key[0] = Tag.Timestamp\n                key.writeBigUInt64BE(BigInt(value.toString()), 1)\n                return key\n            }\n            case \"MinKey\":\n                return Buffer.of(Tag.MinKey)\n            case \"MaxKey\":\n                return Buffer.of(Tag.MaxKey)\n        }\n        const text = bson.EJSON.stringify(value, { relaxed: false })\n        if (value instanceof RegExp || value._bsontype === \"BSONRegExp\")\n            return this.string(Tag.RegExp, text)\n        if (Array.isArray(value)) return this.string(Tag.Array, text)\n        if (typeof value._bsontype === \"string\")\n            return this.string(Tag.Other, text)\n        return this.string(Tag.Object, text)\n    }\n\n    /**\n     * Whether an index keeps the order of a value: a range of it may be read in the index.\n     *\n     * @param value\n     */\n    isOrdered(value: any): boolean {\n        return (\n            typeof value === \"number\" ||\n            typeof value === \"string\" ||\n            typeof value === \"boolean\" ||\n            value instanceof Date ||\n            (value !== null &&\n                typeof value === \"object\" &&\n                (value._bsontype === \"ObjectId\" ||\n                    value._bsontype === \"Binary\"))\n        )\n    }\n\n    /**\n     * The first byte of the encoding of the values of the type of a value, and the first byte after them: the range\n     * of the encodings of its type.\n     *\n     * @param value\n     */\n    bracketOf(value: any): [number, number] {\n        const tag = this.encode(value)[0]\n        return [tag, tag + 1]\n    }\n\n    /**\n     * The keys of a document in an index of fields (1 ascending, -1 descending): one per value of the field that is an\n     * array (MongoDB indexes each of its items), none when the index is sparse and the document has none of its\n     * fields. The values missing are null.\n     *\n     * @param fields the fields of the index and their directions\n     * @param sparse\n     * @param document\n     */\n    keysOf(\n        fields: { [path: string]: any },\n        sparse: boolean | undefined,\n        document: EmbeddedDocument,\n    ): Buffer[] {\n        const paths = Object.keys(fields)\n        const values = paths.map((path) => this.valuesAt(document, path))\n        if (sparse && values.every((items) => items === undefined)) return []\n        const multiple = values.filter(\n            (items) => items !== undefined && items.length > 1,\n        )\n        if (multiple.length > 1)\n            throw new TypeORMError(\n                `cannot index parallel arrays [${paths.join(\"] [\")}]`,\n            )\n        let keys: Buffer[] = [Buffer.alloc(0)]\n        paths.forEach((path, index) => {\n            const items = values[index] ?? [null]\n            const encoded = this.unique(\n                items.map((item) =>\n                    this.direct(this.encode(item), fields[path]),\n                ),\n            )\n            keys = keys.flatMap((key) =>\n                encoded.map((item) => Buffer.concat([key, item])),\n            )\n        })\n        return this.unique(keys)\n    }\n\n    /**\n     * The encoding of a value in a field of a direction (-1: inverted).\n     *\n     * @param encoded\n     * @param direction\n     */\n    direct(encoded: Buffer, direction: any): Buffer {\n        if (direction !== -1 && direction !== \"-1\") return encoded\n        const inverted = Buffer.allocUnsafe(encoded.length)\n        for (let index = 0; index < encoded.length; index++)\n            inverted[index] = ~encoded[index] & 0xff\n        return inverted\n    }\n\n    /**\n     * The values at a path of a document, as MongoDB indexes them: the items of the arrays it meets (the arrays of\n     * objects followed by the path), an empty array as null; undefined when it has none.\n     *\n     * @param document\n     * @param path\n     */\n    protected valuesAt(\n        document: EmbeddedDocument,\n        path: string,\n    ): any[] | undefined {\n        let current: any[] = [document]\n        for (const name of path.split(\".\")) {\n            const next: any[] = []\n            for (const value of current) {\n                // An index of an array (\"tags.0\"), and the field of its items\n                if (Array.isArray(value) && /^\\d+$/.test(name) && value[Number(name)] !== undefined)\n                    next.push(value[Number(name)])\n                const items = Array.isArray(value) ? value : [value]\n                for (const item of items)\n                    if (\n                        item !== null &&\n                        typeof item === \"object\" &&\n                        !Array.isArray(item) &&\n                        item[name] !== undefined\n                    )\n                        next.push(item[name])\n            }\n            if (!next.length) return undefined\n            current = next\n        }\n        const values = current.flatMap((value) =>\n            Array.isArray(value) ? (value.length ? value : [null]) : [value],\n        )\n        return values\n    }\n\n    /**\n     * A double ordered as bytes (a number, a date): its tag, its 8 bytes; a number then the difference of its integer\n     * from the double (2 bytes, 0 for the doubles), ordering the integers a double rounds.\n     *\n     * @param tag\n     * @param value\n     * @param difference the integer minus the double (|difference| <= 1024 for the integers of 64 bits)\n     */\n    protected number(tag: number, value: number, difference = 0): Buffer {\n        const key = Buffer.allocUnsafe(tag === Tag.Number ? 11 : 9)\n        key[0] = tag\n        if (tag === Tag.Number) key.writeUInt16BE(difference + 0x8000, 9)\n        // NaN before all the numbers (-Infinity included), as MongoDB sorts it\n        if (Number.isNaN(value)) {\n            key.fill(0, 1, 9)\n            return key\n        }\n        // -0 and 0 one key, as MongoDB compares them\n        key.writeDoubleBE(value === 0 ? 0 : value, 1)\n        // The bits of a double ordered as bytes: the sign bit set for the positive ones, all of them inverted for the\n        // negative ones\n        if (key[1] & 0x80) for (let index = 1; index < 9; index++) key[index] = ~key[index] & 0xff\n        else key[1] |= 0x80\n        return key\n    }\n\n    /**\n     * An integer, exact up to 64 bits: its double, then its difference from it (the integers larger are rounded to\n     * their double).\n     *\n     * @param value\n     */\n    protected integer(value: bigint): Buffer {\n        const double = Number(value)\n        if (value < -LONG_BOUND || value > LONG_BOUND)\n            return this.number(Tag.Number, double)\n        return this.number(Tag.Number, double, Number(value - BigInt(double)))\n    }\n\n    /**\n     * A string terminated by two zero bytes, its zero bytes escaped (0 then 1): its order kept, self-delimiting.\n     *\n     * @param tag\n     * @param value\n     */\n    protected string(tag: number, value: string): Buffer {\n        const bytes = Buffer.from(value, \"utf8\")\n        let zeros = 0\n        for (const byte of bytes) if (byte === 0) zeros++\n        const key = Buffer.allocUnsafe(1 + bytes.length + zeros + 2)\n        key[0] = tag\n        let position = 1\n        for (const byte of bytes) {\n            key[position++] = byte\n            if (byte === 0) key[position++] = 1\n        }\n        key[position++] = 0\n        key[position] = 0\n        return key\n    }\n\n    protected unique(keys: Buffer[]): Buffer[] {\n        const seen = new Set<string>()\n        return keys.filter((key) => {\n            const text = key.toString(\"latin1\")\n            if (seen.has(text)) return false\n            seen.add(text)\n            return true\n        })\n    }\n}\n"]}

package/dist/vendor/typeorm/driver/mongo-embedded/EmbeddedKeydir.d.ts

@@ -0,0 +1,124 @@
+/**
+ * lakutata: the keys of a keydir, appended to chunks of buffers: each one its length (4 bytes) then its bytes, at an
+ * address (its chunk times the size of the chunks, plus its place in it).
+ */
+declare class KeyArena {
+    chunks: Buffer[];
+    position: number;
+    /**
+     * Adds a key; its address.
+     *
+     * @param key
+     */
+    add(key: Uint8Array): number;
+    /**
+     * Whether the key at an address is a key.
+     *
+     * @param address
+     * @param key
+     */
+    equals(address: number, key: Uint8Array): boolean;
+    /**
+     * The key at an address.
+     *
+     * @param address
+     */
+    read(address: number): Buffer;
+}
+/**
+ * lakutata: the records of the documents of a collection by the keys of their _id, outside the heap of V8, whose
+ * maps hold up to 2^23 entries: an open addressing hash table (linear probing) of typed arrays, its keys in an arena.
+ * A slot holds the hash of its key (0 empty, 1 deleted), the address of its key, and the file (a number), offset and
+ * length of the record of the document. It holds up to 0.7 × 2^28 keys.
+ */
+export declare class EmbeddedKeydir {
+    protected hashes: Uint32Array;
+    protected keys: Float64Array;
+    protected offsets: Float64Array;
+    protected lengths: Uint32Array;
+    protected files: Uint8Array;
+    protected arena: KeyArena;
+    protected mask: number;
+    protected live: number;
+    protected deleted: number;
+    constructor(capacity?: number);
+    /**
+     * The number of keys.
+     */
+    get size(): number;
+    /**
+     * The slot of a key, or -1.
+     *
+     * @param key
+     */
+    find(key: Uint8Array): number;
+    /**
+     * Whether a key is held.
+     *
+     * @param key
+     */
+    has(key: Uint8Array): boolean;
+    /**
+     * The offset of the record of a slot.
+     *
+     * @param slot
+     */
+    offsetAt(slot: number): number;
+    /**
+     * The length of the record of a slot.
+     *
+     * @param slot
+     */
+    lengthAt(slot: number): number;
+    /**
+     * The file of the record of a slot.
+     *
+     * @param slot
+     */
+    fileAt(slot: number): number;
+    /**
+     * Sets the record of a key; the length of the record it replaces, or 0.
+     *
+     * @param key
+     * @param offset
+     * @param length
+     * @param file
+     */
+    set(key: Uint8Array, offset: number, length: number, file?: number): number;
+    /**
+     * Removes a key; the length of the record of its document, or 0 when it was not held.
+     *
+     * @param key
+     */
+    delete(key: Uint8Array): number;
+    /**
+     * Removes all the keys.
+     */
+    clear(): void;
+    /**
+     * The keys held, with the offsets and lengths of their records.
+     */
+    entries(): Generator<[Buffer, number, number]>;
+    /**
+     * The state of the keydir as buffers (its arrays and the chunks of its arena, shared, not copied), and the numbers
+     * telling them apart.
+     */
+    export(): {
+        state: number[];
+        buffers: Uint8Array[];
+    };
+    /**
+     * A keydir from its state exported (its buffers used as they are, aligned on 8 bytes).
+     *
+     * @param state
+     * @param buffers
+     */
+    static import(state: number[], buffers: Uint8Array[]): EmbeddedKeydir;
+    /**
+     * Grows the table (or rebuilds it without its deleted slots), with a new arena of its live keys: read from the
+     * arrays of the old table, their hashes kept.
+     */
+    protected grow(): void;
+    protected allocate(capacity: number): void;
+}
+export {};