@based/schema 5.0.0-alpha.2 → 5.0.0-alpha.21

package/dist/def/DEFAULT_MAP.d.ts

@@ -0,0 +1,3 @@
+import { TypeIndex } from './types.js';
+export declare const DEFAULT_MAP: Record<TypeIndex, any>;
+//# sourceMappingURL=DEFAULT_MAP.d.ts.map

package/dist/def/DEFAULT_MAP.js

@@ -0,0 +1,29 @@
+import { TYPE_INDEX_MAP } from './types.js';
+// TODO update defaults
+export const DEFAULT_MAP = {
+    [TYPE_INDEX_MAP.alias]: '',
+    [TYPE_INDEX_MAP.binary]: undefined,
+    [TYPE_INDEX_MAP.boolean]: false,
+    [TYPE_INDEX_MAP.cardinality]: 0,
+    [TYPE_INDEX_MAP.created]: 0,
+    [TYPE_INDEX_MAP.updated]: 0,
+    [TYPE_INDEX_MAP.number]: 0,
+    [TYPE_INDEX_MAP.timestamp]: 0,
+    [TYPE_INDEX_MAP.enum]: 0,
+    [TYPE_INDEX_MAP.id]: 0,
+    [TYPE_INDEX_MAP.int16]: 0,
+    [TYPE_INDEX_MAP.int32]: 0,
+    [TYPE_INDEX_MAP.int8]: 0,
+    [TYPE_INDEX_MAP.uint8]: 0,
+    [TYPE_INDEX_MAP.uint16]: 0,
+    [TYPE_INDEX_MAP.uint32]: 0,
+    [TYPE_INDEX_MAP.json]: undefined,
+    [TYPE_INDEX_MAP.microbuffer]: undefined,
+    [TYPE_INDEX_MAP.reference]: undefined,
+    [TYPE_INDEX_MAP.references]: [],
+    [TYPE_INDEX_MAP.string]: '',
+    [TYPE_INDEX_MAP.aliases]: [],
+    [TYPE_INDEX_MAP.text]: '',
+    [TYPE_INDEX_MAP.vector]: undefined, // maybe not can set a vec with 0
+};
+//# sourceMappingURL=DEFAULT_MAP.js.map

package/dist/def/addEdges.d.ts

@@ -0,0 +1,4 @@
+import { SchemaReference } from '../index.js';
+import { PropDef } from './types.js';
+export declare const addEdges: (prop: PropDef, refProp: SchemaReference) => void;
+//# sourceMappingURL=addEdges.d.ts.map

package/dist/def/addEdges.js

@@ -0,0 +1,76 @@
+import { getPropType } from '../index.js';
+import { DEFAULT_MAP } from './defaultMap.js';
+import { TYPE_INDEX_MAP, REFERENCES, REFERENCE, ENUM, NUMBER, } from './types.js';
+import { getPropLen, isSeparate, parseMinMaxStep } from './utils.js';
+import { defaultValidation, VALIDATION_MAP } from './validation.js';
+export const addEdges = (prop, refProp) => {
+    for (const key in refProp) {
+        if (key[0] === '$') {
+            if (!prop.edges) {
+                prop.edgeMainLen = 0;
+                prop.edges = {};
+                prop.reverseSeperateEdges = {};
+                prop.reverseMainEdges = {};
+                prop.edgesSeperateCnt = 0;
+            }
+            const edgeProp = refProp[key];
+            const edgeType = getPropType(edgeProp);
+            const len = getPropLen(edgeProp);
+            const separate = isSeparate(edgeProp, len);
+            if (separate) {
+                prop.edgesSeperateCnt++;
+            }
+            const typeIndex = TYPE_INDEX_MAP[edgeType];
+            // add default
+            const edge = {
+                __isPropDef: true,
+                __isEdge: true,
+                prop: separate ? prop.edgesSeperateCnt : 0,
+                validation: edgeProp.validation ?? VALIDATION_MAP[typeIndex] ?? defaultValidation,
+                name: key,
+                typeIndex,
+                len,
+                separate,
+                path: [...prop.path, key],
+                default: edgeProp.default ?? DEFAULT_MAP[typeIndex],
+                start: prop.edgeMainLen,
+            };
+            if (edgeProp.max !== undefined) {
+                edge.max = parseMinMaxStep(edgeProp.max);
+            }
+            if (edgeProp.min !== undefined) {
+                edge.min = parseMinMaxStep(edgeProp.min);
+            }
+            if (edgeProp.step !== undefined) {
+                edge.step = parseMinMaxStep(edgeProp.step);
+            }
+            if (edge.typeIndex !== NUMBER && edge.step === undefined) {
+                edge.step = 1;
+            }
+            prop.edgeMainLen += edge.len;
+            if (edge.typeIndex === ENUM) {
+                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 === REFERENCES) {
+                edge.inverseTypeName = refProp[key].items.ref;
+            }
+            else if (edge.typeIndex === REFERENCE) {
+                edge.inverseTypeName = refProp[key].ref;
+            }
+            prop.edges[key] = edge;
+            if (separate) {
+                prop.reverseSeperateEdges[edge.prop] = edge;
+            }
+            else {
+                prop.reverseMainEdges[edge.start] = edge;
+            }
+        }
+    }
+};
+//# sourceMappingURL=addEdges.js.map

package/dist/def/createEmptyDef.d.ts

@@ -0,0 +1,42 @@
+import { SchemaLocales, SchemaObject, StrictSchemaType } from '../types.js';
+export declare const createEmptyDef: (typeName: string, type: StrictSchemaType | SchemaObject, locales: Partial<SchemaLocales>) => {
+    cnt: number;
+    blockCapacity: number;
+    insertOnly: boolean;
+    partial: boolean;
+    checksum: number;
+    type: string;
+    props: {};
+    reverseProps: {};
+    idUint8: Uint8Array;
+    id: number;
+    mainEmpty: Uint8Array;
+    mainLen: number;
+    separate: any[];
+    tree: {};
+    total: number;
+    lastId: number;
+    locales: {};
+    main: {};
+    separateSortProps: number;
+    separateSortText: number;
+    localeSize: number;
+    hasSeperateSort: boolean;
+    seperateSort: {
+        size: number;
+        props: any[];
+        buffer: Uint8Array;
+        bufferTmp: Uint8Array;
+    };
+    hasSeperateTextSort: boolean;
+    seperateTextSort: {
+        size: number;
+        props: any[];
+        buffer: Uint8Array;
+        noUndefined: Uint8Array;
+        bufferTmp: Uint8Array;
+        localeStringToIndex: Map<any, any>;
+        localeToIndex: Map<any, any>;
+    };
+};
+//# sourceMappingURL=createEmptyDef.d.ts.map

package/dist/def/createEmptyDef.js

@@ -0,0 +1,45 @@
+import { hashObjectIgnoreKeyOrder } from '@saulx/hash';
+export const createEmptyDef = (typeName, type, locales) => {
+    return {
+        cnt: 0,
+        blockCapacity: 0,
+        insertOnly: false,
+        partial: false,
+        checksum: hashObjectIgnoreKeyOrder(type),
+        type: typeName,
+        props: {},
+        reverseProps: {},
+        idUint8: new Uint8Array([0, 0]),
+        // empty main buffer
+        id: 0,
+        mainEmpty: new Uint8Array(0),
+        mainLen: 0,
+        separate: [],
+        tree: {},
+        total: 0,
+        lastId: 0,
+        locales: {},
+        main: {},
+        separateSortProps: 0,
+        separateSortText: 0,
+        localeSize: 0,
+        hasSeperateSort: false,
+        seperateSort: {
+            size: 0,
+            props: [],
+            buffer: new Uint8Array([]),
+            bufferTmp: new Uint8Array([]),
+        },
+        hasSeperateTextSort: false,
+        seperateTextSort: {
+            size: 0, // prop len
+            props: [],
+            buffer: new Uint8Array([]),
+            noUndefined: new Uint8Array(new Array(Object.keys(locales).length).fill(0)),
+            bufferTmp: new Uint8Array([]),
+            localeStringToIndex: new Map(),
+            localeToIndex: new Map(),
+        },
+    };
+};
+//# sourceMappingURL=createEmptyDef.js.map

package/dist/def/defaultMap.d.ts

@@ -0,0 +1,3 @@
+import { TypeIndex } from './types.js';
+export declare const DEFAULT_MAP: Record<TypeIndex, any>;
+//# sourceMappingURL=defaultMap.d.ts.map

package/dist/def/defaultMap.js

@@ -0,0 +1,28 @@
+import { TYPE_INDEX_MAP } from './types.js';
+// TODO update defaults
+export const DEFAULT_MAP = {
+    [TYPE_INDEX_MAP.alias]: '',
+    [TYPE_INDEX_MAP.binary]: new Uint8Array([]),
+    [TYPE_INDEX_MAP.boolean]: false,
+    [TYPE_INDEX_MAP.cardinality]: 0,
+    [TYPE_INDEX_MAP.number]: 0,
+    [TYPE_INDEX_MAP.timestamp]: 0,
+    [TYPE_INDEX_MAP.enum]: 0,
+    [TYPE_INDEX_MAP.id]: 0,
+    [TYPE_INDEX_MAP.int16]: 0,
+    [TYPE_INDEX_MAP.int32]: 0,
+    [TYPE_INDEX_MAP.int8]: 0,
+    [TYPE_INDEX_MAP.uint8]: 0,
+    [TYPE_INDEX_MAP.uint16]: 0,
+    [TYPE_INDEX_MAP.uint32]: 0,
+    [TYPE_INDEX_MAP.json]: null,
+    [TYPE_INDEX_MAP.microbuffer]: undefined,
+    [TYPE_INDEX_MAP.reference]: undefined,
+    [TYPE_INDEX_MAP.references]: [],
+    [TYPE_INDEX_MAP.string]: '',
+    [TYPE_INDEX_MAP.aliases]: [],
+    [TYPE_INDEX_MAP.text]: {},
+    [TYPE_INDEX_MAP.vector]: undefined, // maybe not can set a vec with 0
+    [TYPE_INDEX_MAP.colvec]: undefined, // maybe not can set a vec with 0
+};
+//# sourceMappingURL=defaultMap.js.map

package/dist/def/fillEmptyMain.d.ts

@@ -0,0 +1,5 @@
+import { PropDef } from './types.js';
+export declare const ENCODER: TextEncoder;
+export declare const fillEmptyMain: (vals: PropDef[], mainLen: number) => Uint8Array;
+export declare const isZeroes: (buf: Uint8Array) => boolean;
+//# sourceMappingURL=fillEmptyMain.d.ts.map

package/dist/def/fillEmptyMain.js

@@ -0,0 +1,61 @@
+import { convertToTimestamp } from '@saulx/utils';
+import { BINARY, BOOLEAN, ENUM, INT16, INT32, INT8, NUMBER, STRING, TIMESTAMP, UINT16, UINT32, UINT8, } from './types.js';
+// Lets add validation of values in here - need to validate DEFAULT!
+export const ENCODER = new TextEncoder();
+export const fillEmptyMain = (vals, mainLen) => {
+    const mainEmpty = new Uint8Array(mainLen);
+    for (const f of vals) {
+        if (f.separate) {
+            continue;
+        }
+        const t = f.typeIndex;
+        const s = f.start;
+        let val = f.default;
+        if (t === ENUM) {
+            mainEmpty[s] =
+                typeof f.default === 'number' ? f.default : f.reverseEnum[val];
+        }
+        else if (t === INT8 || t === UINT8) {
+            mainEmpty[s] = val;
+        }
+        else if (t === BOOLEAN) {
+            mainEmpty[s] = val === true ? 1 : 0;
+        }
+        else if (t === UINT32 || t === INT32) {
+            mainEmpty[s] = val;
+            mainEmpty[s + 1] = val >>>= 8;
+            mainEmpty[s + 2] = val >>>= 8;
+            mainEmpty[s + 3] = val >>>= 8;
+        }
+        else if (t === UINT16 || t === INT16) {
+            mainEmpty[s] = val;
+            mainEmpty[s + 1] = val >>>= 8;
+        }
+        else if (t === NUMBER || t === TIMESTAMP) {
+            const view = new DataView(mainEmpty.buffer, s, 8);
+            view.setFloat64(0, convertToTimestamp(val), true);
+        }
+        else if (t === STRING) {
+            val = ENCODER.encode(val);
+            mainEmpty[s] = val.byteLength;
+            mainEmpty.set(val, s + 1);
+        }
+        else if (t === BINARY) {
+            if (val !== undefined) {
+                mainEmpty.set(val, s);
+            }
+        }
+    }
+    return mainEmpty;
+};
+export const isZeroes = (buf) => {
+    let i = 0;
+    while (i < buf.byteLength) {
+        if (buf[i] !== 0) {
+            return false;
+        }
+        i++;
+    }
+    return true;
+};
+//# sourceMappingURL=fillEmptyMain.js.map

package/dist/def/getPropLen.d.ts

@@ -0,0 +1,3 @@
+import { SchemaProp } from '../types.js';
+export declare function getPropLen(schemaProp: SchemaProp): any;
+//# sourceMappingURL=getPropLen.d.ts.map

package/dist/def/getPropLen.js

@@ -0,0 +1,23 @@
+import { getPropType } from '../parse/utils.js';
+import { isPropType } from '../types.js';
+import { SIZE_MAP } from './types.js';
+export function getPropLen(schemaProp) {
+    let len = SIZE_MAP[getPropType(schemaProp)];
+    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 if (isPropType('vector', schemaProp)) {
+        len = 4 * schemaProp.size;
+    }
+    return len;
+}
+//# sourceMappingURL=getPropLen.js.map

package/dist/def/index.d.ts

@@ -0,0 +1,8 @@
+export * from './types.js';
+export * from './typeDef.js';
+export * from './utils.js';
+export * from './selvaBuffer.js';
+export * from './createEmptyDef.js';
+export * from './defaultMap.js';
+export * from './validation.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/def/index.js

@@ -0,0 +1,9 @@
+// flap
+export * from './types.js';
+export * from './typeDef.js';
+export * from './utils.js';
+export * from './selvaBuffer.js';
+export * from './createEmptyDef.js';
+export * from './defaultMap.js';
+export * from './validation.js';
+//# sourceMappingURL=index.js.map

package/dist/def/makePacked.d.ts

@@ -0,0 +1,3 @@
+import { SchemaTypeDef, PropDef } from './types.js';
+export declare function makePacked(result: Partial<SchemaTypeDef>, typeName: string, vals: PropDef[], len: number): void;
+//# sourceMappingURL=makePacked.d.ts.map

package/dist/def/makePacked.js

@@ -0,0 +1,50 @@
+export function makePacked(result, typeName, vals, len) {
+    const encoder = new TextEncoder();
+    result.buf = new Uint8Array(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 = new Uint8Array(fieldNameLen);
+    let lastWritten = 0;
+    for (const f of fieldNames) {
+        result.propNames[lastWritten] = f.byteLength;
+        result.propNames.set(f, lastWritten + 1);
+        lastWritten += f.byteLength + 1;
+    }
+    let bufLen = result.buf.length;
+    result.packed = new Uint8Array(2 + bufLen + result.propNames.length);
+    result.packed[0] = bufLen;
+    result.packed[1] = bufLen >>>= 8;
+    result.packed.set(result.buf, 2);
+    result.packed.set(result.propNames, result.buf.length + 2);
+}
+//# sourceMappingURL=makePacked.js.map

package/dist/def/makeSeparateSort.d.ts

@@ -0,0 +1,3 @@
+import { SchemaTypeDef } from './types.js';
+export declare function makeSeparateSort(result: Partial<SchemaTypeDef>): void;
+//# sourceMappingURL=makeSeparateSort.d.ts.map

package/dist/def/makeSeparateSort.js

@@ -0,0 +1,27 @@
+import { STRING, ALIAS, CARDINALITY } from './types.js';
+export function makeSeparateSort(result) {
+    result.hasSeperateSort = true;
+    let max = 0;
+    for (const f of result.separate) {
+        if (f.typeIndex === STRING ||
+            f.typeIndex === ALIAS ||
+            f.typeIndex === CARDINALITY) {
+            if (f.prop > max) {
+                max = f.prop;
+            }
+        }
+    }
+    result.seperateSort.buffer = new Uint8Array(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 = new Uint8Array(max + 1);
+    result.seperateSort.buffer.set(result.seperateSort.bufferTmp);
+}
+//# sourceMappingURL=makeSeparateSort.js.map

package/dist/def/makeSeparateTextSort.d.ts

@@ -0,0 +1,3 @@
+import { SchemaTypeDef } from './types.js';
+export declare function makeSeparateTextSort(result: Partial<SchemaTypeDef>): void;
+//# sourceMappingURL=makeSeparateTextSort.d.ts.map

package/dist/def/makeSeparateTextSort.js

@@ -0,0 +1,38 @@
+import { langCodesMap } from '../lang.js';
+import { TEXT } from './types.js';
+export function makeSeparateTextSort(result) {
+    result.hasSeperateTextSort = true;
+    let max = 0;
+    for (const f of result.separate) {
+        if (f.typeIndex === TEXT) {
+            if (f.prop > max) {
+                max = f.prop;
+            }
+        }
+    }
+    const bufLen = (max + 1) * (result.localeSize + 1);
+    result.seperateTextSort.buffer = new Uint8Array(bufLen);
+    let index = 0;
+    for (const code in result.locales) {
+        const codeLang = langCodesMap.get(code);
+        result.seperateTextSort.localeStringToIndex.set(code, new Uint8Array([index + 1, codeLang]));
+        result.seperateTextSort.localeToIndex.set(codeLang, index + 1);
+        index++;
+    }
+    for (const f of result.separate) {
+        if (f.typeIndex === TEXT) {
+            const index = f.prop * (result.localeSize + 1);
+            result.seperateTextSort.buffer[index] = result.localeSize;
+            for (const [, locales] of result.seperateTextSort.localeStringToIndex) {
+                result.seperateTextSort.buffer[locales[0] + index] = locales[1];
+            }
+            result.seperateTextSort.props.push(f);
+            result.seperateTextSort.size += result.localeSize;
+        }
+    }
+    result.seperateTextSort.props.sort((a, b) => (a.prop > b.prop ? 1 : -1));
+    result.seperateTextSort.bufferTmp = new Uint8Array(bufLen);
+    result.seperateTextSort.bufferTmp.fill(0);
+    result.seperateTextSort.bufferTmp.set(result.seperateTextSort.buffer);
+}
+//# sourceMappingURL=makeSeparateTextSort.js.map

package/dist/def/readFromPacked.d.ts

@@ -0,0 +1,3 @@
+import { SchemaTypeDef } from './types.js';
+export declare const readFromPacked: (packed: Uint8Array) => SchemaTypeDef;
+//# sourceMappingURL=readFromPacked.d.ts.map

package/dist/def/readFromPacked.js

@@ -0,0 +1,140 @@
+import { REVERSE_SIZE_MAP } from './types.js';
+import { DEFAULT_MAP } from './defaultMap.js';
+import { VALIDATION_MAP } from './validation.js';
+export const readFromPacked = (packed) => {
+    const size = (packed[0] | (packed[1] << 8)) >>> 0;
+    const props = [];
+    const b = packed.subarray(2, 2 + size);
+    let collectMain = false;
+    const mainProps = [];
+    const typeId = b.subarray(0, 2);
+    const typeIdNr = (typeId[0] | (typeId[1] << 8)) >>> 0;
+    for (let i = 2; i < b.length; i++) {
+        const prop = b[i];
+        if (collectMain) {
+            if (prop === 0) {
+                collectMain = false;
+            }
+            else {
+                mainProps.push({
+                    prop: 0,
+                    typeIndex: b[i],
+                });
+            }
+        }
+        else {
+            if (prop == 0) {
+                collectMain = true;
+            }
+            else {
+                props.push({ prop, typeIndex: b[i + 1] });
+                i++;
+            }
+        }
+    }
+    const decoder = new TextDecoder();
+    const fields = [];
+    const f = packed.subarray(2 + size, packed.length);
+    for (let i = 0; i < f.length; i++) {
+        const size = f[i];
+        fields.push(decoder.decode(f.subarray(i + 1, i + 1 + size)));
+        i += size;
+    }
+    for (let i = 0; i < mainProps.length; i++) {
+        mainProps[i].path = fields[i + 1];
+    }
+    for (let i = 0; i < props.length; i++) {
+        props[i].path = fields[i + 1 + mainProps.length];
+    }
+    // Fixed len strings not supported
+    // Refs also not supported
+    // Text not supported yet
+    // Ref not supported yet
+    //   compression: 1 (0)
+    const result = {
+        cnt: 0,
+        checksum: 0,
+        total: 0,
+        type: fields[0],
+        lastId: 0,
+        blockCapacity: 0,
+        mainLen: mainProps.length,
+        buf: b,
+        propNames: f,
+        packed,
+        props: {},
+        reverseProps: {}, // in a bit
+        id: typeIdNr,
+        idUint8: typeId,
+        separate: [],
+        main: {},
+        tree: {},
+        // not nessecary...
+        hasSeperateSort: false,
+        seperateSort: {
+            size: 0,
+            buffer: new Uint8Array([]),
+            bufferTmp: new Uint8Array([]),
+            props: [],
+        },
+        hasSeperateTextSort: false,
+        seperateTextSort: {
+            localeToIndex: new Map(),
+            localeStringToIndex: new Map(),
+            noUndefined: new Uint8Array([]),
+            size: 0,
+            buffer: new Uint8Array([]),
+            bufferTmp: new Uint8Array([]),
+            props: [],
+        },
+        mainEmpty: new Uint8Array([]),
+        mainEmptyAllZeroes: true,
+        // need this...
+        locales: {},
+        localeSize: 0,
+    };
+    let s = 0;
+    for (const p of mainProps) {
+        const len = REVERSE_SIZE_MAP[p.typeIndex];
+        const prop = {
+            prop: p.prop,
+            separate: false,
+            __isPropDef: true,
+            validation: VALIDATION_MAP[p.typeIndex],
+            start: s,
+            default: DEFAULT_MAP[p.typeIndex], // tmp
+            typeIndex: p.typeIndex,
+            path: p.path.split('.'),
+            len,
+        };
+        result.props[p.path] = prop;
+        result.main[prop.start] = prop;
+        s += len;
+    }
+    for (const p of props) {
+        const prop = {
+            prop: p.prop,
+            separate: true,
+            __isPropDef: true,
+            validation: VALIDATION_MAP[p.typeIndex],
+            start: 0,
+            typeIndex: p.typeIndex,
+            default: DEFAULT_MAP[p.typeIndex], // tmp
+            path: p.path.split('.'),
+            len: 0,
+            compression: 1,
+        };
+        result.props[p.path] = prop;
+        result.reverseProps[prop.prop] = prop;
+    }
+    // make this into a typeDef
+    //   return {
+    //     type: fields[0],
+    //     fields,
+    //     typeId,
+    //     props,
+    //     mainProps,
+    //   }
+    return result;
+};
+//# sourceMappingURL=readFromPacked.js.map

package/dist/def/selvaBuffer.d.ts

@@ -0,0 +1,5 @@
+import { SchemaTypeDef } from './types.js';
+export declare function schemaToSelvaBuffer(schema: {
+    [key: string]: SchemaTypeDef;
+}): ArrayBuffer[];
+//# sourceMappingURL=selvaBuffer.d.ts.map