@keeex/utils 7.0.1

package/lib/json.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+import { TypePredicate } from "./types/types.js";
+/**
+ * All the primitive types supported in a JSON file.
+ *
+ * @public
+ */
+export type JSONPrimitiveType = null | string | number | boolean;
+/**
+ * All possible value type in a JSON file.
+ *
+ * @public
+ */
+export type JSONValueType = JSONPrimitiveType | JSONArray | JSONObject;
+/**
+ * All supported arrays in a JSON files.
+ *
+ * @public
+ */
+export type JSONArray = Array<JSONValueType>;
+/**
+ * All supported objects in a JSON files.
+ *
+ * @public
+ */
+export interface JSONObject {
+    [key: string]: JSONValueType;
+}
+/**
+ * JSON.parse() with typed return.
+ *
+ * @public
+ */
+export declare const jsonParse: <T>(value: unknown, predicate?: TypePredicate<T>) => T;
+/**
+ * Do a JSON stringify operation with optional canonization of properties' order.
+ *
+ * @param order - Sort all properties using their UTF-8 point value.
+ * This is roughly alphabetical order when there are no non-ASCII characters.
+ *
+ * @public
+ */
+export declare const jsonStringify: (source: unknown, order?: boolean, prettyIndent?: boolean | number) => string;

package/lib/json.js

@@ -0,0 +1,116 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+const JSON_DEFAULT_INDENT = 2;
+/**
+ * JSON.parse() with typed return.
+ *
+ * @public
+ */
+export const jsonParse = (value, predicate) => {
+    const res = typeof value === "string" ? JSON.parse(value) : value;
+    if (predicate && !predicate(res, { raise: true }))
+        throw new Error("Unexpected state");
+    return res;
+};
+/** Return the expected indentation step */
+const indentStep = (prettyIndent) => {
+    if (prettyIndent === false)
+        return 0;
+    if (prettyIndent === true)
+        return JSON_DEFAULT_INDENT;
+    return prettyIndent;
+};
+/** Indent a string */
+const indentStr = (level, value) => {
+    const lines = value.split("\n");
+    const indentedLines = lines.map((c) => `${" ".repeat(level)}${c}`);
+    return indentedLines.join("\n");
+};
+/** Helper for Array.map() */
+const indenter = (level) => (value) => indentStr(level, value);
+const processArray = (source, prettyIndent) => {
+    const outputElem = source.map((c) => {
+        if (c === undefined)
+            return "null";
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return jsonStringify(c, true, prettyIndent);
+    });
+    if (outputElem.length === 0)
+        return "[]";
+    if (prettyIndent === false)
+        return `[${outputElem.join(",")}]`;
+    return `[\n${outputElem
+        .map(indenter(indentStep(prettyIndent)))
+        .map((c, id) => (id === outputElem.length - 1 ? `${c}\n` : `${c},\n`))
+        .join("")}]`;
+};
+const utf8Sort = (a, b) => {
+    const maxLen = Math.max(a.length, b.length);
+    for (let cursor = 0; cursor < maxLen; ++cursor) {
+        const aCode = a.charCodeAt(cursor);
+        const bCode = b.charCodeAt(cursor);
+        if (isNaN(aCode) || aCode < bCode)
+            return -1;
+        if (isNaN(bCode) || aCode > bCode)
+            return 1;
+    }
+    return 0;
+};
+/**
+ * Do a JSON stringify operation with optional canonization of properties' order.
+ *
+ * @param order - Sort all properties using their UTF-8 point value.
+ * This is roughly alphabetical order when there are no non-ASCII characters.
+ *
+ * @public
+ */
+export const jsonStringify = (source, order = false, prettyIndent = false) => {
+    if (!order) {
+        if (prettyIndent) {
+            return JSON.stringify(source, null, typeof prettyIndent === "boolean" ? JSON_DEFAULT_INDENT : prettyIndent);
+        }
+        return JSON.stringify(source);
+    }
+    if (Array.isArray(source))
+        return processArray(source, prettyIndent);
+    const sourceType = typeof source;
+    if (["string", "number", "boolean"].includes(sourceType) || source === null) {
+        return JSON.stringify(source);
+    }
+    if (sourceType !== "object")
+        throw new Error("Invalid object input");
+    const casted = source;
+    const outputElem = [];
+    for (const key of Object.keys(casted).sort(utf8Sort)) {
+        const value = casted[key];
+        if (value === undefined)
+            continue;
+        if (prettyIndent === false) {
+            outputElem.push(`${JSON.stringify(key)}:${jsonStringify(value, true, prettyIndent)}`);
+        }
+        else {
+            outputElem.push(`${JSON.stringify(key)}: ${jsonStringify(value, true, prettyIndent)}`);
+        }
+    }
+    if (outputElem.length === 0)
+        return "{}";
+    if (prettyIndent === false)
+        return `{${outputElem.join(",")}}`;
+    return `{\n${outputElem
+        .map(indenter(indentStep(prettyIndent)))
+        .map((c, id) => (id === outputElem.length - 1 ? `${c}\n` : `${c},\n`))
+        .join("")}}`;
+};

package/lib/marshalling/marshaller.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+/**
+ * Concatenate values into a buffer
+ *
+ * @public
+ */
+export default class Marshaller {
+    #private;
+    private constructor();
+    static readonly start: (magicNumbers?: string) => Marshaller;
+    /** End building the buffer and returns the result */
+    readonly end: () => ArrayBuffer;
+    /** Append an utf-8 string */
+    readonly str: (value: string) => this;
+    /** Append a 32-bit unsigned int */
+    readonly u32: (value: number) => this;
+    /** Append a 8-bit unsigned int */
+    readonly u8: (value: number) => this;
+    /** Append an arraybuffer */
+    readonly buf: (value: ArrayBuffer | Uint8Array) => this;
+    /** Append a byte buffer from a hex string */
+    readonly hex: (value: string) => this;
+    /** Append a Raw IDX (101 bytes) */
+    readonly idx: (value: string) => this;
+    /** Append an array of strings */
+    readonly arrStr: (values: Array<string>) => this;
+    /** Append an array of 32bit unsigned numbers */
+    readonly arrU32: (values: Array<number>) => this;
+    /** Append an array of 8bit unsigned numbers */
+    readonly arrU8: (values: Array<number>) => this;
+    /** Append an array of buffers */
+    readonly arrBuf: (values: Array<ArrayBuffer | Uint8Array>) => this;
+    /** Append an array of hexadecimal strings saved as buffers */
+    readonly arrHex: (values: Array<string>) => this;
+    /** Append an array of IDX strings */
+    readonly arrIDX: (values: Array<string>) => this;
+}

package/lib/marshalling/marshaller.js

@@ -0,0 +1,155 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+import { writeUint32LE } from "../bytebuffer.js";
+import { getUint8Array, hex2buf8, str2buf8, utf82buf8 } from "../uint8array.js";
+import { KX_IDX_LEN, UINT32_BYTES } from "./util.js";
+/**
+ * Concatenate values into a buffer
+ *
+ * @public
+ */
+export default class Marshaller {
+    #values;
+    #buffer;
+    #magicNumbers;
+    constructor(magicNumbers) {
+        // Array of Uint8Array
+        this.#values = [];
+        // Header, in bytes
+        if (magicNumbers)
+            this.#magicNumbers = str2buf8(magicNumbers);
+    }
+    static start = (magicNumbers) => new Marshaller(magicNumbers);
+    /** End building the buffer and returns the result */
+    end = () => this.#getBuffer();
+    /** Append an utf-8 string */
+    str = (value) => {
+        this.#appendData(utf82buf8(value), true);
+        return this;
+    };
+    /** Append a 32-bit unsigned int */
+    u32 = (value) => {
+        const uintBuffer = new Uint8Array(UINT32_BYTES);
+        writeUint32LE(uintBuffer, 0, value);
+        this.#appendData(uintBuffer);
+        return this;
+    };
+    /** Append a 8-bit unsigned int */
+    u8 = (value) => {
+        const uintBuffer = new Uint8Array([value]);
+        this.#appendData(uintBuffer);
+        return this;
+    };
+    /** Append an arraybuffer */
+    buf = (value) => {
+        this.#appendData(getUint8Array(value), true);
+        return this;
+    };
+    /** Append a byte buffer from a hex string */
+    hex = (value) => {
+        this.buf(hex2buf8(value));
+        return this;
+    };
+    /** Append a Raw IDX (101 bytes) */
+    idx = (value) => {
+        const idxBuffer = str2buf8(value);
+        if (idxBuffer.length !== KX_IDX_LEN)
+            throw new Error("Invalid IDX length");
+        this.#appendData(idxBuffer);
+        return this;
+    };
+    /** Append an array of strings */
+    arrStr = (values) => {
+        this.#arrayPrefix(values);
+        for (const value of values)
+            this.str(value);
+        return this;
+    };
+    /** Append an array of 32bit unsigned numbers */
+    arrU32 = (values) => {
+        this.#arrayPrefix(values);
+        for (const value of values)
+            this.u32(value);
+        return this;
+    };
+    /** Append an array of 8bit unsigned numbers */
+    arrU8 = (values) => {
+        this.#arrayPrefix(values);
+        for (const value of values)
+            this.u8(value);
+        return this;
+    };
+    /** Append an array of buffers */
+    arrBuf = (values) => {
+        this.#arrayPrefix(values);
+        for (const value of values)
+            this.buf(value);
+        return this;
+    };
+    /** Append an array of hexadecimal strings saved as buffers */
+    arrHex = (values) => {
+        this.#arrayPrefix(values);
+        for (const value of values)
+            this.hex(value);
+        return this;
+    };
+    /** Append an array of IDX strings */
+    arrIDX = (values) => {
+        this.#arrayPrefix(values);
+        for (const value of values)
+            this.idx(value);
+        return this;
+    };
+    /** Write the beginning of an array */
+    #arrayPrefix = (values) => {
+        this.u32(values.length);
+    };
+    /** Construct the output buffer with all the previously set values */
+    #getBuffer = () => {
+        this.#buffer ??= this.#buildBuffer();
+        return this.#buffer;
+    };
+    /** Build the buffer */
+    #buildBuffer = () => {
+        const dataSize = this.#values.reduce((acc, cur) => {
+            const curSize = cur.dataBuffer.byteLength;
+            const prefixSize = cur.prefixWithSize ? UINT32_BYTES : 0;
+            return acc + curSize + prefixSize;
+        }, 0);
+        const magicSize = this.#magicNumbers?.length ?? 0;
+        const totalSize = magicSize + dataSize;
+        this.#buffer = new Uint8Array(totalSize);
+        let cursor = 0;
+        if (this.#magicNumbers) {
+            this.#buffer.set(this.#magicNumbers, cursor);
+            cursor += this.#magicNumbers.length;
+        }
+        for (const valueInfo of this.#values) {
+            if (valueInfo.prefixWithSize) {
+                writeUint32LE(this.#buffer, cursor, valueInfo.dataBuffer.length);
+                cursor += UINT32_BYTES;
+            }
+            this.#buffer.set(valueInfo.dataBuffer, cursor);
+            cursor += valueInfo.dataBuffer.length;
+        }
+        return this.#buffer;
+    };
+    /** Internally append a data to the list */
+    #appendData = (dataBuffer, prefixWithSize = false) => {
+        this.#buffer = undefined;
+        this.#values.push({ prefixWithSize, dataBuffer });
+    };
+}

package/lib/marshalling/unmarshaller.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+/**
+ * Read data from an arraybuffer
+ *
+ * Expect input in the form of the output of `Marshaller`.
+ *
+ * @public
+ */
+export default class Unmarshaller {
+    #private;
+    /**
+     * @param magicNumber - Expected magic number
+     */
+    constructor(buffer: ArrayBuffer | Uint8Array, magicNumber?: string);
+    /** Read a 32bit unsigned integer */
+    u32: () => number;
+    /** Read a 8bit unsigned integer */
+    u8: () => number;
+    /** Read an arraybuffer */
+    buf: () => Uint8Array;
+    /** Read a string */
+    str: () => string;
+    /** Read a buffer as an hex string */
+    hex: () => string;
+    /** Read an array of strings */
+    arrStr: () => Array<string>;
+    /** Read an array of numbers as unsigned 32bit values */
+    arrU32: () => Array<number>;
+    /** Read an array of numbers as unsigned 8bit values */
+    arrU8: () => Array<number>;
+    /** Read an array of buffers */
+    arrBuf: () => Array<Uint8Array>;
+    /** Read an array of hexadecimal strings stored as buffers */
+    arrHex: () => Array<string>;
+    /** Read an array of IDX */
+    arrIDX: () => Array<string>;
+    /** Read an IDX */
+    idx: () => string;
+}

package/lib/marshalling/unmarshaller.js

@@ -0,0 +1,124 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+import { readUint32LE } from "../bytebuffer.js";
+import { buf82hex, buf82str, buf82utf8, getUint8Array } from "../uint8array.js";
+import { KX_IDX_LEN, UINT32_BYTES } from "./util.js";
+/**
+ * Read data from an arraybuffer
+ *
+ * Expect input in the form of the output of `Marshaller`.
+ *
+ * @public
+ */
+export default class Unmarshaller {
+    #buffer;
+    #offset;
+    /**
+     * @param magicNumber - Expected magic number
+     */
+    constructor(buffer, magicNumber) {
+        this.#buffer = getUint8Array(buffer);
+        this.#offset = 0;
+        if (magicNumber) {
+            if (this.#buffer.length < magicNumber.length)
+                throw new Error("No magic number available");
+            const readMagicNumber = buf82str(this.#buffer.slice(0, magicNumber.length));
+            if (magicNumber !== readMagicNumber)
+                throw new Error("Incorrect magic number");
+            this.#offset += magicNumber.length;
+        }
+    }
+    /** Read a 32bit unsigned integer */
+    u32 = () => {
+        this.#checkSize(UINT32_BYTES);
+        const res = readUint32LE(this.#buffer, this.#offset);
+        this.#offset += 4;
+        return res;
+    };
+    /** Read a 8bit unsigned integer */
+    u8 = () => {
+        this.#checkSize(1);
+        const res = this.#buffer[this.#offset];
+        this.#offset += 1;
+        return res;
+    };
+    /** Read an arraybuffer */
+    buf = () => {
+        const bufferLength = this.u32();
+        this.#checkSize(bufferLength);
+        const result = this.#buffer.slice(this.#offset, this.#offset + bufferLength);
+        this.#offset += bufferLength;
+        return result;
+    };
+    /** Read a string */
+    str = () => buf82utf8(this.buf());
+    /** Read a buffer as an hex string */
+    hex = () => buf82hex(this.buf());
+    /** Read an array of strings */
+    arrStr = () => {
+        const result = new Array(this.u32());
+        for (let index = 0; index < result.length; ++index)
+            result[index] = this.str();
+        return result;
+    };
+    /** Read an array of numbers as unsigned 32bit values */
+    arrU32 = () => {
+        const result = new Array(this.u32());
+        for (let index = 0; index < result.length; ++index)
+            result[index] = this.u32();
+        return result;
+    };
+    /** Read an array of numbers as unsigned 8bit values */
+    arrU8 = () => {
+        const result = new Array(this.u32());
+        for (let index = 0; index < result.length; ++index)
+            result[index] = this.u8();
+        return result;
+    };
+    /** Read an array of buffers */
+    arrBuf = () => {
+        const result = new Array(this.u32());
+        for (let index = 0; index < result.length; ++index)
+            result[index] = this.buf();
+        return result;
+    };
+    /** Read an array of hexadecimal strings stored as buffers */
+    arrHex = () => {
+        const result = new Array(this.u32());
+        for (let index = 0; index < result.length; ++index)
+            result[index] = this.hex();
+        return result;
+    };
+    /** Read an array of IDX */
+    arrIDX = () => {
+        const result = new Array(this.u32());
+        for (let index = 0; index < result.length; ++index)
+            result[index] = this.idx();
+        return result;
+    };
+    /** Read an IDX */
+    idx = () => {
+        this.#checkSize(KX_IDX_LEN);
+        const strBuffer = this.#buffer.slice(this.#offset, this.#offset + KX_IDX_LEN);
+        const result = buf82str(strBuffer);
+        this.#offset += KX_IDX_LEN;
+        return result;
+    };
+    #checkSize = (dataSize) => {
+        if (this.#offset + dataSize > this.#buffer.length)
+            throw new Error("Buffer too short");
+    };
+}

package/lib/marshalling/util.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+/**
+ * Length of a legacy IDX
+ *
+ * Should not be used anymore, as IDX could have variable length in the future.
+ *
+ * @internal
+ */
+export declare const KX_IDX_LEN = 101;
+/** @internal */
+export declare const UINT32_BYTES = 4;

package/lib/marshalling/util.js

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+/**
+ * Length of a legacy IDX
+ *
+ * Should not be used anymore, as IDX could have variable length in the future.
+ *
+ * @internal
+ */
+export const KX_IDX_LEN = 101;
+/** @internal */
+export const UINT32_BYTES = 4;

package/lib/number.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+/** Round a number value to the given number of decimal places */
+export declare const roundDecimals: (value: number, decimalPlaces: number) => number;

package/lib/number.js

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+/** Round a number value to the given number of decimal places */
+export const roundDecimals = (value, decimalPlaces) => {
+    // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+    const multiplier = 10 ** decimalPlaces;
+    return Math.round(value * multiplier) / multiplier;
+};

package/lib/path.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * @preserve
+ *
+ * MIT License
+ * 
+ * Copyright (c) 2023 KeeeX SAS
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ */
+/**
+ * Sanitize a filename
+ *
+ * Removes some characters known to cause issues with file names.
+ *
+ * Does not work on path.
+ *
+ * @public
+ */
+export declare const sanitizeFilename: (filename: string, replacement?: string) => string;