@based/db 0.0.17 → 0.0.19

package/dist/src/client/query/validation.js

@@ -1,6 +1,5 @@
 import picocolors from 'picocolors';
-import { ALIAS, BINARY, BOOLEAN, REFERENCE, REFERENCES, REVERSE_TYPE_INDEX_MAP, STRING, TEXT, TIMESTAMP, VECTOR, } from '../../server/schema/types.js';
-import { propIsNumerical } from '../../server/schema/utils.js';
+import { ALIAS, BINARY, BOOLEAN, REFERENCE, REFERENCES, REVERSE_TYPE_INDEX_MAP, STRING, TEXT, TIMESTAMP, VECTOR, propIsNumerical, } from '@based/schema/def';
 import { EQUAL, HAS, isNumerical, LIKE, operatorReverseMap, VECTOR_FNS, } from './filter/types.js';
 import { MAX_ID, MAX_ID_VALUE, MAX_IDS_PER_QUERY, MIN_ID_VALUE, } from './thresholds.js';
 import { displayTarget, safeStringify } from './display.js';
@@ -439,8 +438,9 @@ export const EMPTY_SCHEMA_DEF = {
     lastId: 0,
     blockCapacity: 0,
     mainLen: 0,
-    buf: Buffer.from([]),
-    propNames: Buffer.from([]),
+    buf: new Uint8Array([]),
+    propNames: new Uint8Array([]),
+    packed: new Uint8Array([]),
     props: {},
     locales: {},
     reverseProps: {},
@@ -452,16 +452,17 @@ export const EMPTY_SCHEMA_DEF = {
     hasSeperateSort: false,
     seperateSort: {
         size: 0,
-        buffer: Buffer.from([]),
-        bufferTmp: Buffer.from([]),
+        buffer: new Uint8Array([]),
+        bufferTmp: new Uint8Array([]),
         props: [],
     },
     hasSeperateTextSort: false,
     seperateTextSort: {
         size: 0,
-        buffer: Buffer.from([]),
-        bufferTmp: Buffer.from([]),
+        buffer: new Uint8Array([]),
+        bufferTmp: new Uint8Array([]),
         props: [],
     },
+    localeSize: 0,
 };
 //# sourceMappingURL=validation.js.map

package/dist/src/index.d.ts

@@ -2,7 +2,6 @@ import { compress, decompress } from './client/string.js';
 import { ModifyCtx } from './client/operations.js';
 import { DbServer } from './server/index.js';
 import { DbClient } from './client/index.js';
-export * from './server/schema/typeDef.js';
 export * from './client/modify/modify.js';
 export { compress, decompress };
 export { ModifyCtx };

package/dist/src/index.js

@@ -3,7 +3,6 @@ import { ModifyCtx } from './client/operations.js';
 import { DbServer } from './server/index.js';
 import { DbClient } from './client/index.js';
 import picocolors from 'picocolors';
-export * from './server/schema/typeDef.js';
 export * from './client/modify/modify.js';
 export { compress, decompress };
 export { ModifyCtx }; // TODO move this somewhere

package/dist/src/server/index.d.ts

@@ -1,5 +1,5 @@
 import { LangName, StrictSchema } from '@based/schema';
-import { SchemaTypeDef } from './schema/types.js';
+import { SchemaTypesParsed, SchemaTypesParsedById } from '@based/schema/def';
 import { createTree } from './csmt/index.js';
 import { Worker, MessagePort } from 'node:worker_threads';
 import { TransformFns } from './migrate/index.js';
@@ -29,10 +29,8 @@ export declare class DbServer {
         lastId: number;
     };
     migrating: number;
-    schemaTypesParsed: {
-        [key: string]: SchemaTypeDef;
-    };
-    schemaTypesParsedById: Record<number, SchemaTypeDef>;
+    schemaTypesParsed: SchemaTypesParsed;
+    schemaTypesParsedById: SchemaTypesParsedById;
     fileSystemPath: string;
     maxModifySize: number;
     merkleTree: ReturnType<typeof createTree>;

package/dist/src/server/index.js

@@ -2,9 +2,9 @@ import native from '../native.js';
 import { rm, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { getPropType, langCodesMap, } from '@based/schema';
-import { genRootId } from './schema/utils.js';
-import { updateTypeDefs } from './schema/typeDef.js';
-import { schemaToSelvaBuffer } from './schema/selvaBuffer.js';
+import { 
+// genRootId,
+updateTypeDefs, schemaToSelvaBuffer, } from '@based/schema/def';
 import { start } from './start.js';
 import { foreachDirtyBlock, makeCsmtKey, makeCsmtKeyFromNodeId, } from './tree.js';
 import { save } from './save.js';
@@ -310,12 +310,18 @@ export class DbServer {
             }
             // @ts-ignore This creates an internal type to use for root props
             this.schema.types._root = {
-                id: genRootId(),
+                id: 1,
                 props,
             };
             delete this.schema.props;
         }
-        updateTypeDefs(this);
+        for (const field in this.schema.types) {
+            if (!('id' in this.schema.types[field])) {
+                this.schema.lastId++;
+                this.schema.types[field].id = this.schema.lastId;
+            }
+        }
+        updateTypeDefs(this.schema, this.schemaTypesParsed, this.schemaTypesParsedById);
         if (!fromStart) {
             writeFile(join(this.fileSystemPath, SCHEMA_FILE), JSON.stringify(this.schema)).catch((err) => console.error(SCHEMA_FILE, err));
             let types = Object.keys(this.schemaTypesParsed);

package/dist/src/server/migrate/worker.js

@@ -1,7 +1,7 @@
 import { isMainThread, receiveMessageOnPort, workerData, } from 'node:worker_threads';
 import native from '../../native.js';
 import { BasedDb } from '../../index.js';
-import { REFERENCE, REFERENCES } from '../schema/types.js';
+import { REFERENCE, REFERENCES } from '@based/schema/def';
 if (isMainThread) {
     console.warn('running worker.ts in mainthread');
 }

package/dist/src/server/start.d.ts

@@ -1,6 +1,5 @@
 import { DbServer } from './index.js';
 import './worker.js';
-export declare const DEFAULT_BLOCK_CAPACITY = 100000;
 export declare function start(db: DbServer, opts: {
     clean?: boolean;
 }): Promise<void>;

package/dist/src/server/start.js

@@ -9,9 +9,9 @@ import { availableParallelism } from 'node:os';
 import exitHook from 'exit-hook';
 import './worker.js';
 import { save } from './save.js';
+import { DEFAULT_BLOCK_CAPACITY } from '@based/schema/def';
 const SCHEMA_FILE = 'schema.json';
 const WRITELOG_FILE = 'writelog.json';
-export const DEFAULT_BLOCK_CAPACITY = 100_000;
 const makeCsmtKey = (typeId, start) => typeId * 4294967296 + start;
 export async function start(db, opts) {
     const path = db.fileSystemPath;

package/dist/src/server/tree.d.ts

@@ -1,5 +1,5 @@
 import { DbServer } from './index.js';
-import { SchemaTypeDef } from './schema/types.js';
+import { SchemaTypeDef } from '@based/schema/def';
 export type CsmtNodeRange = {
     file: string;
     typeId: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/db",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "license": "MIT",
   "type": "module",
   "main": "./dist/src/index.js",
@@ -31,7 +31,7 @@
     "basedDbNative.cjs"
   ],
   "dependencies": {
-    "@based/schema": "5.0.0-alpha.3",
+    "@based/schema": "5.0.0-alpha.4",
     "@saulx/hash": "^3.0.0",
     "@saulx/utils": "^4.3.2",
     "exit-hook": "^4.0.0",

package/dist/src/server/schema/schema.d.ts

@@ -1,3 +0,0 @@
-export * from './types.js';
-export * from './typeDef.js';
-export * from './selvaBuffer.js';

package/dist/src/server/schema/schema.js

@@ -1,4 +0,0 @@
-export * from './types.js';
-export * from './typeDef.js';
-export * from './selvaBuffer.js';
-//# sourceMappingURL=schema.js.map

package/dist/src/server/schema/selvaBuffer.d.ts

@@ -1,4 +0,0 @@
-import { SchemaTypeDef } from './types.js';
-export declare function schemaToSelvaBuffer(schema: {
-    [key: string]: SchemaTypeDef;
-}): Buffer[];

package/dist/src/server/schema/selvaBuffer.js

@@ -1,112 +0,0 @@
-import { ALIAS, ALIASES, BINARY, BOOLEAN, CREATED, EMPTY_MICRO_BUFFER, ENUM, CARDINALITY, INT16, INT32, INT64, INT8, MICRO_BUFFER, NULL, NUMBER, REFERENCE, REFERENCES, STRING, TEXT, TIMESTAMP, UINT16, UINT32, UINT8, UPDATED, VECTOR, WEAK_REFERENCE, WEAK_REFERENCES, JSON, } from './types.js';
-const selvaTypeMap = [];
-selvaTypeMap[NULL] = 0;
-selvaTypeMap[TIMESTAMP] = 1;
-selvaTypeMap[CREATED] = 1;
-selvaTypeMap[UPDATED] = 1;
-selvaTypeMap[NUMBER] = 4;
-selvaTypeMap[CARDINALITY] = 11;
-selvaTypeMap[INT8] = 20;
-selvaTypeMap[UINT8] = 6;
-selvaTypeMap[INT16] = 21;
-selvaTypeMap[UINT16] = 22;
-selvaTypeMap[INT32] = 23;
-selvaTypeMap[UINT32] = 7;
-selvaTypeMap[INT64] = 24;
-selvaTypeMap[BOOLEAN] = 9;
-selvaTypeMap[ENUM] = 10;
-selvaTypeMap[STRING] = 11;
-selvaTypeMap[TEXT] = 12;
-selvaTypeMap[REFERENCE] = 13;
-selvaTypeMap[REFERENCES] = 14;
-selvaTypeMap[WEAK_REFERENCE] = 15;
-selvaTypeMap[WEAK_REFERENCES] = 16;
-selvaTypeMap[MICRO_BUFFER] = 17;
-selvaTypeMap[ALIAS] = 18;
-selvaTypeMap[ALIASES] = 19;
-selvaTypeMap[BINARY] = 11;
-selvaTypeMap[VECTOR] = 17;
-selvaTypeMap[JSON] = 11;
-const EDGE_FIELD_CONSTRAINT_FLAG_DEPENDENT = 0x01;
-function sepPropCount(props) {
-    return props.filter((prop) => prop.separate).length;
-}
-function makeEdgeConstraintFlags(prop) {
-    return prop.dependent ? EDGE_FIELD_CONSTRAINT_FLAG_DEPENDENT : 0x00;
-}
-const propDefBuffer = (schema, prop, isEdge) => {
-    const type = prop.typeIndex;
-    const selvaType = selvaTypeMap[type];
-    if (prop.len && (type === MICRO_BUFFER || type === VECTOR)) {
-        const buf = Buffer.allocUnsafe(3);
-        buf[0] = selvaType;
-        buf.writeUint16LE(prop.len, 1);
-        return [...buf.values()];
-    }
-    else if (type === REFERENCE || type === REFERENCES) {
-        const buf = Buffer.allocUnsafe(9);
-        const dstType = schema[prop.inverseTypeName];
-        let eschema = [];
-        // @ts-ignore
-        buf[0] = selvaType + 2 * !!isEdge; // field type
-        buf[1] = makeEdgeConstraintFlags(prop); // flags
-        buf.writeUInt16LE(dstType.id, 2); // dst_node_type
-        buf.writeUint32LE(0, 5); // schema_len
-        if (!isEdge) {
-            prop.inverseTypeId = dstType.id;
-            prop.inversePropNumber = dstType.props[prop.inversePropName].prop;
-            buf[4] = prop.inversePropNumber;
-            if (prop.edges) {
-                const props = Object.values(prop.edges);
-                eschema = props
-                    .map((prop) => propDefBuffer(schema, prop, true))
-                    .flat(1);
-                eschema.unshift(0, 0, 0, 0, sepPropCount(props), 0);
-                buf.writeUint32LE(eschema.length, 5);
-            }
-        }
-        return [...buf.values(), ...eschema];
-    }
-    else if (type === STRING ||
-        type === BINARY ||
-        type === CARDINALITY ||
-        type === JSON) {
-        return [selvaType, prop.len < 50 ? prop.len : 0];
-    }
-    {
-        return [selvaType];
-    }
-};
-function makeBlockCapacityBuffer(blockCapacity) {
-    const buf = Buffer.allocUnsafe(4);
-    buf.writeInt32LE(blockCapacity);
-    return buf;
-}
-// todo rewrite
-export function schemaToSelvaBuffer(schema) {
-    return Object.values(schema).map((t, i) => {
-        const props = Object.values(t.props);
-        const rest = [];
-        let refFields = 0;
-        for (const f of props) {
-            if (f.separate) {
-                if (f.typeIndex === REFERENCE || f.typeIndex === REFERENCES) {
-                    refFields++;
-                }
-                rest.push(f);
-            }
-        }
-        rest.sort((a, b) => a.prop - b.prop);
-        return Buffer.from([
-            ...makeBlockCapacityBuffer(t.blockCapacity).values(),
-            1 + sepPropCount(props),
-            1 + refFields,
-            ...propDefBuffer(schema, {
-                ...EMPTY_MICRO_BUFFER,
-                len: t.mainLen === 0 ? 1 : t.mainLen,
-            }),
-            ...rest.map((f) => propDefBuffer(schema, f)).flat(1),
-        ]);
-    });
-}
-//# sourceMappingURL=selvaBuffer.js.map

package/dist/src/server/schema/typeDef.d.ts

@@ -1,6 +0,0 @@
-import { SchemaObject, StrictSchemaType, SchemaLocales } from '@based/schema';
-import { SchemaTypeDef } from './types.js';
-import { DbClient } from '../../client/index.js';
-import { DbServer } from '../index.js';
-export declare const updateTypeDefs: (db: DbClient | DbServer) => void;
-export declare const createSchemaTypeDef: (typeName: string, type: StrictSchemaType | SchemaObject, parsed: DbClient["schemaTypesParsed"], locales: Partial<SchemaLocales>, result?: Partial<SchemaTypeDef>, path?: string[], top?: boolean) => SchemaTypeDef;

package/dist/src/server/schema/typeDef.js

@@ -1,337 +0,0 @@
-import { isPropType, getPropType, } from '@based/schema';
-import { setByPath } from '@saulx/utils';
-import { hashObjectIgnoreKeyOrder } from '@saulx/hash';
-import { SIZE_MAP, TYPE_INDEX_MAP, STRING, ALIAS, CARDINALITY, } from './types.js';
-import { genId } from './utils.js';
-import { DEFAULT_BLOCK_CAPACITY } from '../start.js';
-const addEdges = (prop, refProp) => {
-    let edgesCnt = 0;
-    for (const key in refProp) {
-        if (key[0] === '$') {
-            if (!prop.edges) {
-                prop.edges = {};
-                prop.reverseEdges = {};
-                prop.edgesTotalLen = 0;
-            }
-            edgesCnt++;
-            const edgeType = getPropType(refProp[key]);
-            const edge = {
-                __isPropDef: true,
-                __isEdge: true,
-                prop: edgesCnt,
-                name: key,
-                typeIndex: TYPE_INDEX_MAP[edgeType],
-                len: SIZE_MAP[edgeType],
-                separate: true,
-                path: [...prop.path, key],
-            };
-            if (edge.len == 0) {
-                prop.edgesTotalLen = 0;
-            }
-            else {
-                // [field] [size] [data]
-                prop.edgesTotalLen += 1 + 2 + edge.len; // field len
-            }
-            if (edge.typeIndex === 10) {
-                edge.enum = Array.isArray(refProp[key])
-                    ? refProp[key]
-                    : refProp[key].enum;
-                edge.reverseEnum = {};
-                for (let i = 0; i < edge.enum.length; i++) {
-                    edge.reverseEnum[edge.enum[i]] = i;
-                }
-            }
-            else if (edge.typeIndex === 14) {
-                edge.inverseTypeName = refProp[key].items.ref;
-            }
-            else if (edge.typeIndex === 13) {
-                edge.inverseTypeName = refProp[key].ref;
-            }
-            prop.edges[key] = edge;
-            prop.reverseEdges[edge.prop] = edge;
-        }
-    }
-};
-export const updateTypeDefs = (db) => {
-    for (const field in db.schemaTypesParsed) {
-        if (field in db.schema.types) {
-            continue;
-        }
-        const id = db.schemaTypesParsed[field].id;
-        delete db.schemaTypesParsed[field];
-        delete db.schemaTypesParsedById[id];
-    }
-    for (const field in db.schema.types) {
-        const type = db.schema.types[field];
-        if (db.schemaTypesParsed[field] &&
-            db.schemaTypesParsed[field].checksum === hashObjectIgnoreKeyOrder(type) // bit weird..
-        ) {
-            continue;
-        }
-        else {
-            if (!type.id) {
-                type.id = genId(db);
-            }
-            const def = createSchemaTypeDef(field, type, db.schemaTypesParsed, db.schema.locales ?? {
-                en: {},
-            });
-            def.blockCapacity =
-                field === '_root' ? 2147483647 : DEFAULT_BLOCK_CAPACITY; // TODO this should come from somewhere else
-            db.schemaTypesParsed[field] = def;
-            db.schemaTypesParsedById[type.id] = def;
-        }
-    }
-};
-export const createSchemaTypeDef = (typeName, type, parsed, locales, result = {
-    cnt: 0,
-    checksum: hashObjectIgnoreKeyOrder(type),
-    type: typeName,
-    props: {},
-    reverseProps: {},
-    idUint8: new Uint8Array([0, 0]),
-    id: 0,
-    mainLen: 0,
-    separate: [],
-    tree: {},
-    total: 0,
-    lastId: 0,
-    main: {},
-    hasSeperateSort: false,
-    seperateSort: {
-        size: 0,
-        props: [],
-        buffer: Buffer.allocUnsafe(0),
-        bufferTmp: Buffer.allocUnsafe(0),
-    },
-    hasSeperateTextSort: false,
-    seperateTextSort: {
-        size: 0,
-        props: [],
-        buffer: Buffer.allocUnsafe(0),
-        bufferTmp: Buffer.allocUnsafe(0),
-    },
-}, path = [], top = true) => {
-    if (result.id == 0 && top) {
-        if ('id' in type) {
-            result.id = type.id;
-        }
-        else {
-            throw new Error(`Invalid schema type id ${result.type}`);
-        }
-    }
-    result.locales = locales;
-    result.idUint8[0] = result.id & 255;
-    result.idUint8[1] = result.id >> 8;
-    const encoder = new TextEncoder();
-    const target = type.props;
-    let separateSortProps = 0;
-    let separateSortText = 0;
-    for (const key in target) {
-        const schemaProp = target[key];
-        const propPath = [...path, key];
-        const propType = getPropType(schemaProp);
-        if (propType === 'object') {
-            createSchemaTypeDef(typeName, schemaProp, parsed, locales, result, propPath, false);
-        }
-        else {
-            let len = SIZE_MAP[propType];
-            if (isPropType('string', schemaProp) ||
-                isPropType('alias', schemaProp) ||
-                isPropType('cardinality', schemaProp)) {
-                if (typeof schemaProp === 'object') {
-                    if (schemaProp.maxBytes < 61) {
-                        len = schemaProp.maxBytes + 1;
-                    }
-                    else if ('max' in schemaProp && schemaProp.max < 31) {
-                        len = schemaProp.max * 2 + 1;
-                    }
-                    else {
-                        separateSortProps++;
-                    }
-                }
-                else {
-                    separateSortProps++;
-                }
-            }
-            else if (isPropType('vector', schemaProp)) {
-                len = 4 * schemaProp.size;
-            }
-            const isseparate = len === 0 || isPropType('vector', schemaProp);
-            if (isseparate) {
-                result.cnt++;
-            }
-            const prop = {
-                typeIndex: TYPE_INDEX_MAP[propType],
-                __isPropDef: true,
-                separate: isseparate,
-                path: propPath,
-                start: 0,
-                len,
-                prop: isseparate ? result.cnt : 0,
-            };
-            if (isPropType('enum', schemaProp)) {
-                prop.enum = Array.isArray(schemaProp) ? schemaProp : schemaProp.enum;
-                prop.reverseEnum = {};
-                for (let i = 0; i < prop.enum.length; i++) {
-                    prop.reverseEnum[prop.enum[i]] = i;
-                }
-            }
-            else if (isPropType('references', schemaProp)) {
-                prop.inversePropName = schemaProp.items.prop;
-                prop.inverseTypeName = schemaProp.items.ref;
-                prop.dependent = schemaProp.items.dependent;
-                addEdges(prop, schemaProp.items);
-            }
-            else if (isPropType('reference', schemaProp)) {
-                prop.inversePropName = schemaProp.prop;
-                prop.inverseTypeName = schemaProp.ref;
-                prop.dependent = schemaProp.dependent;
-                addEdges(prop, schemaProp);
-            }
-            else if (typeof schemaProp === 'object') {
-                if (isPropType('string', schemaProp) ||
-                    isPropType('text', schemaProp)) {
-                    prop.compression =
-                        'compression' in schemaProp && schemaProp.compression === 'none'
-                            ? 0
-                            : 1;
-                }
-                else if (isPropType('timestamp', schemaProp) && 'on' in schemaProp) {
-                    if (schemaProp.on[0] === 'c') {
-                        result.createTs ??= [];
-                        result.createTs.push(prop);
-                    }
-                    else if (schemaProp.on[0] === 'u') {
-                        result.createTs ??= [];
-                        result.createTs.push(prop);
-                        result.updateTs ??= [];
-                        result.updateTs.push(prop);
-                    }
-                }
-            }
-            result.props[propPath.join('.')] = prop;
-            if (isseparate) {
-                result.separate.push(prop);
-            }
-        }
-    }
-    if (top) {
-        const vals = Object.values(result.props);
-        vals.sort((a, b) => {
-            if (b.separate && (a.typeIndex === 14 || a.typeIndex === 13)) {
-                return -1;
-            }
-            return a.prop - b.prop;
-        });
-        let lastProp = 0;
-        for (const p of vals) {
-            if (p.separate) {
-                lastProp++;
-                p.prop = lastProp;
-            }
-        }
-        let len = 2;
-        for (const f of vals) {
-            if (f.separate) {
-                len += 2;
-                setByPath(result.tree, f.path, f);
-            }
-            else {
-                if (!result.mainLen) {
-                    len += 2;
-                }
-                len += 1;
-                f.start = result.mainLen;
-                result.mainLen += f.len;
-                setByPath(result.tree, f.path, f);
-            }
-        }
-        const mainFields = [];
-        const restFields = [];
-        for (const f of vals) {
-            if (f.separate) {
-                restFields.push(f);
-            }
-            else {
-                mainFields.push(f);
-            }
-        }
-        result.buf = Buffer.allocUnsafe(len);
-        result.buf[0] = result.idUint8[0];
-        result.buf[1] = result.idUint8[1];
-        const fieldNames = [];
-        const tNameBuf = encoder.encode(typeName);
-        fieldNames.push(tNameBuf);
-        let fieldNameLen = tNameBuf.byteLength + 1;
-        let i = 2;
-        if (result.mainLen) {
-            result.buf[i] = 0;
-            for (const f of vals) {
-                if (!f.separate) {
-                    i++;
-                    result.buf[i] = f.typeIndex;
-                    const name = encoder.encode(f.path.join('.'));
-                    fieldNames.push(name);
-                    fieldNameLen += name.byteLength + 1;
-                }
-            }
-            i++;
-            result.buf[i] = 0;
-        }
-        for (const f of vals) {
-            if (f.separate) {
-                i++;
-                result.buf[i] = f.prop;
-                i++;
-                result.buf[i] = f.typeIndex;
-                const name = encoder.encode(f.path.join('.'));
-                fieldNames.push(name);
-                fieldNameLen += name.byteLength + 1;
-            }
-        }
-        result.propNames = Buffer.allocUnsafe(fieldNameLen);
-        let lastWritten = 0;
-        for (const f of fieldNames) {
-            result.propNames[lastWritten] = f.byteLength;
-            result.propNames.set(f, lastWritten + 1);
-            lastWritten += f.byteLength + 1;
-        }
-        if (separateSortProps > 0) {
-            result.hasSeperateSort = true;
-            let max = 0;
-            for (const f of result.separate) {
-                // Does not only need to be on string can also be HLL
-                if (f.typeIndex === STRING ||
-                    f.typeIndex === ALIAS ||
-                    f.typeIndex === CARDINALITY) {
-                    if (f.prop > max) {
-                        max = f.prop;
-                    }
-                }
-            }
-            result.seperateSort.buffer = Buffer.allocUnsafe(max + 1);
-            for (const f of result.separate) {
-                if (f.typeIndex === STRING ||
-                    f.typeIndex === ALIAS ||
-                    f.typeIndex === CARDINALITY) {
-                    result.seperateSort.buffer[f.prop] = 1;
-                    result.seperateSort.props.push(f);
-                    result.seperateSort.size++;
-                }
-            }
-            result.seperateSort.bufferTmp = Buffer.allocUnsafe(max + 1);
-            result.seperateSort.buffer.copy(result.seperateSort.bufferTmp);
-        }
-        for (const p in result.props) {
-            const x = result.props[p];
-            if (!x.separate) {
-                result.main[x.start] = x;
-            }
-            else {
-                result.reverseProps[x.prop] = x;
-            }
-        }
-    }
-    return result;
-};
-//# sourceMappingURL=typeDef.js.map