jmuxer 2.1.0 → 2.1.2

package/eslint.config.mjs

@@ -0,0 +1,21 @@
+import js from "@eslint/js";
+import globals from "globals";
+import { defineConfig, globalIgnores } from "eslint/config";
+
+export default defineConfig([
+  {
+    files: ["**/*.{js,mjs,cjs}"],
+    plugins: { js },
+    extends: ["js/recommended"],
+    languageOptions: { globals: { ...globals.browser, ...globals.node } },
+    rules: {
+      indent: ["error", 4, { SwitchCase: 1 }],
+      "no-unused-vars": "off",
+      "linebreak-style": ["error", "unix"],
+      quotes: ["error", "single"],
+      semi: ["error", "always"],
+      "no-useless-assignment": "off",
+    },
+  },
+  globalIgnores(["./src/util/mp4-generator.js"]),
+]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jmuxer",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": "jMuxer - a simple javascript mp4 muxer for non-standard streaming communications protocol",
   "main": "dist/jmuxer.min.js",
   "scripts": {
@@ -9,8 +9,7 @@
     "server": "cd example && nodemon server.mjs",
     "dev": "concurrently --names \"BUILD,SERVER\" -c \"bgBlue.bold,bgMagenta.bold\" \"npm run watch\" \"npm run server\"",
     "pro": "NODE_ENV=production rollup -c",
-    "lint": "eslint  -c .eslintrc.json ./src/",
-    "test": "karma start karma.conf.js"
+    "lint": "eslint ./src/"
   },
   "keywords": [
     "h264",
@@ -28,36 +27,24 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/samirkumardas/jmuxer.git"
+    "url": "git@github.com:webstream-labs/jmuxer.git"
   },
   "author": "Samir Das",
   "devDependencies": {
     "@babel/core": "^7.10.5",
-    "@babel/eslint-parser": "^7.25.1",
-    "@babel/plugin-external-helpers": "^7.10.4",
-    "@babel/preset-env": "^7.10.4",
-    "@rollup/plugin-babel": "^5.2.1",
-    "@rollup/plugin-buble": "^0.21.3",
-    "@rollup/plugin-eslint": "^8.0.1",
-    "@rollup/plugin-node-resolve": "^13.0.6",
-    "@rollup/plugin-replace": "^3.0.0",
-    "@rollup/pluginutils": "^4.0.0",
-    "caniuse-lite": "^1.0.30001223",
-    "chai": "^4.2.0",
-    "concurrently": "^9.2.1",
-    "eslint": "^8.2.0",
+    "@babel/preset-env": "^7.29.0",
+    "@eslint/js": "^10.0.1",
+    "@rollup/plugin-babel": "^6.1.0",
+    "@rollup/plugin-replace": "^6.0.3",
+    "@rollup/plugin-terser": "^1.0.0",
+    "concurrently": "^10.0.3",
+    "eslint": "^10.0.2",
     "express": "^5.1.0",
     "express-ws": "^5.0.2",
-    "karma": "^6.3.2",
-    "karma-chai": "^0.1.0",
-    "karma-chrome-launcher": "^3.1.0",
-    "karma-mocha": "^2.0.1",
-    "karma-rollup-preprocessor": "^7.0.5",
-    "mocha": "^11.7.2",
+    "globals": "^17.4.0",
     "msgpack-lite": "^0.1.26",
     "nodemon": "^3.1.10",
-    "path": "^0.12.7",
-    "rollup": "^2.59.0",
-    "rollup-plugin-terser": "^7.0.2"
-  }
+    "rollup": "^4.59.0"
+  },
+  "type": "module"
 }

package/rollup.config.js

@@ -1,8 +1,7 @@
 // Rollup plugins
 import babel from '@rollup/plugin-babel';
-import eslint from '@rollup/plugin-eslint';
 import replace from '@rollup/plugin-replace';
-import { terser } from 'rollup-plugin-terser';
+import terser from '@rollup/plugin-terser';
 export default {
     input: 'src/jmuxer.js',
     output: [
@@ -11,6 +10,7 @@ export default {
             format: 'umd',
             name: 'JMuxer',
             sourcemap: false, // 'inline'
+            plugins: [terser()],
             globals: {
                 stream: 'stream',
                 fs: 'fs'
@@ -21,6 +21,17 @@ export default {
             format: 'umd',
             name: 'JMuxer',
             sourcemap: false,
+            plugins: [terser()],
+            globals: {
+                stream: 'stream',
+                fs: 'fs'
+            }
+        },
+        {
+            file: 'dist/jmuxer.js',
+            format: 'umd',
+            name: 'JMuxer',
+            sourcemap: false,
             globals: {
                 stream: 'stream',
                 fs: 'fs'
@@ -34,7 +45,6 @@ export default {
         console.error(message);
     },
     plugins: [
-        eslint(),
         babel({
             exclude: 'node_modules/**',
             babelHelpers: 'bundled'
@@ -44,7 +54,6 @@ export default {
             preventAssignment: true,
             ENV: JSON.stringify(process.env.NODE_ENV || 'development'),
         }),
-        (process.env.NODE_ENV === 'production' && terser()),
     ],
     external: [ 'stream', 'fs' ],
 };

package/src/controller/remux.js

@@ -37,7 +37,7 @@ export default class RemuxController extends Event {
         if (type === 'audio' || type === 'both') {
             const aacRemuxer = new AACRemuxer(this.timescale, this.mediaDuration, this.frameDuration);
             this.tracks.audio = aacRemuxer;
-            this.tracks.video.on('outOfData', () => {
+            this.tracks.audio.on('outOfData', () => {
                 this.dispatch('missingAudioFrames');
             });
         }
@@ -123,7 +123,7 @@ export default class RemuxController extends Event {
         let remux = false;
         
         if (data.video && this.tracks.video) {
-            remux |= this.tracks.video.feed(data.video, data.duration, data.compositionTimeOffset);
+            remux |= this.tracks.video.feed(data.video, data.duration, data.compositionTimeOffset, data.isLastVideoFrameComplete);
         }
         if (data.audio && this.tracks.audio) {
             remux |= this.tracks.audio.feed(data.audio, data.duration);

package/src/jmuxer.js

@@ -324,7 +324,7 @@ export default class JMuxer extends Event {
         URL.revokeObjectURL(this.url);
         // this.createBuffer();
         if (typeof this.options.onReady === 'function') {
-            this.options.onReady.call(null, this.isReset);
+            this.options.onReady.call(null, this.isReset, this.mediaSource);
         }
     }
 

package/src/parsers/h264.js

@@ -221,9 +221,11 @@ export class H264Parser {
                 let fixedFrameRate = decoder.readBoolean();
                 let frameDuration = timeScale / (2 * unitsInTick);
 
-                if (fixedFrameRate) {
-                    fps = frameDuration;
-                }
+                // if (fixedFrameRate) {
+                //     fps = frameDuration;
+                // }
+                // Return the fps value even if fixedFrameRate is not set
+                fps = frameDuration;
             }
         }
         return {

package/src/parsers/h265.js

@@ -83,7 +83,7 @@ export class H265Parser {
         decoder.readUByte();
 
         decoder.readBits(4); // sps_video_parameter_set_id
-        decoder.readBits(3); // sps_max_sub_layers_minus1
+        const sps_max_sub_layers_minus1 = decoder.readBits(3); // sps_max_sub_layers_minus1
         decoder.readBits(1); // sps_temporal_id_nesting_flag
 
         // --- profile_tier_level() ---
@@ -119,6 +119,96 @@ export class H265Parser {
             conf_win_bottom_offset = decoder.readUEG();
         }
 
+        const bit_depth_luma_minus8 = decoder.readUEG();
+        const bit_depth_chroma_minus8 = decoder.readUEG();
+
+        const log2_max_pic_order_cnt_lsb_minus4 = decoder.readUEG();
+
+        const ordering_flag = decoder.readBits(1); // sps_sub_layer_ordering_info_present_flag
+
+        for (let i = (ordering_flag ? 0 : sps_max_sub_layers_minus1); i <= sps_max_sub_layers_minus1; i++) {
+            const max_dec = decoder.readUEG();
+            const max_num = decoder.readUEG();
+            const max_latency = decoder.readUEG();
+        }
+
+        decoder.readUEG(); // log2_min_luma_coding_block_size_minus3
+        decoder.readUEG(); // log2_diff_max_min_luma_coding_block_size
+        decoder.readUEG(); // log2_min_luma_transform_block_size_minus2
+        decoder.readUEG(); // log2_diff_max_min_luma_transform_block_size
+        decoder.readUEG(); // max_transform_hierarchy_depth_inter
+        decoder.readUEG(); // max_transform_hierarchy_depth_intra
+
+        const scaling_list_enabled_flag = decoder.readBits(1);
+        if (scaling_list_enabled_flag) {
+            const sps_scaling_list_data_present_flag = decoder.readBits(1);
+            if (sps_scaling_list_data_present_flag) {
+                // inline skipScalingListH265
+                for (let sizeId = 0; sizeId < 4; sizeId++) {
+                    for (let matrixId = 0; matrixId < (sizeId === 3 ? 2 : 6); matrixId++) {
+                        const flag = decoder.readBits(1);
+                        if (!flag) {
+                            decoder.readUEG(); // scaling_list_pred_matrix_id_delta
+                        } else {
+                            const coefNum = Math.min(64, 1 << (4 + (sizeId << 1)));
+                            if (sizeId > 1) decoder.readEG(); // scaling_list_dc_coef_minus8
+                            for (let k = 0; k < coefNum; k++) decoder.readEG();
+                        }
+                    }
+                }
+            }
+        }
+
+        const amp_enabled_flag = decoder.readBits(1);
+        const sample_adaptive_offset_enabled_flag = decoder.readBits(1);
+
+        const pcm_enabled_flag = decoder.readBits(1);
+        if (pcm_enabled_flag) {
+            decoder.readBits(4); // pcm_sample_bit_depth_luma_minus1
+            decoder.readBits(4); // pcm_sample_bit_depth_chroma_minus1
+            decoder.readUEG(); // log2_min_pcm_luma_coding_block_size_minus3
+            decoder.readUEG(); // log2_diff_max_min_pcm_luma_coding_block_size
+            decoder.readBits(1); // pcm_loop_filter_disabled_flag
+        }
+
+        const num_short_term_ref_pic_sets = decoder.readUEG();
+        // inline simplified short-term RPS parsing
+        for (let stIdx = 0; stIdx < num_short_term_ref_pic_sets; stIdx++) {
+            let inter_ref_pic_set_prediction_flag = false;
+            if (stIdx !== 0) {
+                inter_ref_pic_set_prediction_flag = decoder.readBoolean();
+            }
+            if (inter_ref_pic_set_prediction_flag) {
+                decoder.readUEG(); // delta_idx_minus1 or related
+                decoder.readBits(1); // delta_rps_sign
+                decoder.readUEG(); // abs_delta_rps_minus1
+                // fine-grained details omitted for brevity
+            } else {
+                const num_negative_pics = decoder.readUEG();
+                const num_positive_pics = decoder.readUEG();
+                for (let i = 0; i < num_negative_pics; i++) {
+                    decoder.readUEG(); // delta_poc_s0_minus1[i]
+                    decoder.readBits(1); // used_by_curr_pic_s0_flag[i]
+                }
+                for (let i = 0; i < num_positive_pics; i++) {
+                    decoder.readUEG(); // delta_poc_s1_minus1[i]
+                    decoder.readBits(1); // used_by_curr_pic_s1_flag[i]
+                }
+            }
+        }
+
+        const long_term_ref_pics_present_flag = decoder.readBits(1);
+        if (long_term_ref_pics_present_flag) {
+            const num_long_term_ref_pics_sps = decoder.readUEG();
+            for (let i = 0; i < num_long_term_ref_pics_sps; i++) {
+                decoder.readUEG(); // lt_ref_pic_poc_lsb_sps[i]
+                decoder.readBits(1); // used_by_curr_pic_lt_sps_flag[i]
+            }
+        }
+
+        const sps_temporal_mvp_enabled_flag = decoder.readBits(1);
+        const strong_intra_smoothing_enabled_flag = decoder.readBits(1);
+
         let fps = null;
         let vui_parameters_present_flag = decoder.readBoolean();
         if (vui_parameters_present_flag) {
@@ -154,15 +244,111 @@ export class H265Parser {
             decoder.readBoolean(); // field_seq_flag
             decoder.readBoolean(); // frame_field_info_present_flag
 
-            // Timing info
-            let timing_info_present_flag = decoder.readBoolean();
-            if (timing_info_present_flag) {
-                let num_units_in_tick = decoder.readUInt();
-                let time_scale = decoder.readUInt();
-                decoder.readBoolean(); // poc_proportional_to_timing_flag
-                if (num_units_in_tick) {
-                    fps = time_scale / (2 * num_units_in_tick);
+            let default_display_window_flag = decoder.readBoolean();
+            if (default_display_window_flag) {
+                decoder.readUEG(); // def_disp_win_left_offset
+                decoder.readUEG(); // def_disp_win_right_offset
+                decoder.readUEG(); // def_disp_win_top_offset
+                decoder.readUEG(); // def_disp_win_bottom_offset
+            }
+
+            let vui_timing_info_present_flag = decoder.readBoolean();
+            if (vui_timing_info_present_flag) {
+                let vui_num_units_in_tick = decoder.readUInt();
+                let vui_time_scale = decoder.readUInt();
+                const vui_poc_proportional_to_timing_flag = decoder.readBoolean();
+                if (vui_poc_proportional_to_timing_flag) {
+                    decoder.readUEG(); // vui_num_ticks_poc_diff_one_minus1
+                }
+
+                const vui_hrd_parameters_present_flag = decoder.readBoolean();
+                if (vui_hrd_parameters_present_flag) {
+                    // inline simplified HRD parsing
+                    const commonInfPresentFlag = true;
+                    let nal_hrd_parameters_present_flag = false;
+                    let vcl_hrd_parameters_present_flag = false;
+                    let sub_pic_hrd_params_present_flag = false;
+
+                    if (commonInfPresentFlag) {
+                        nal_hrd_parameters_present_flag = decoder.readBoolean();
+                        vcl_hrd_parameters_present_flag = decoder.readBoolean();
+                        if (nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag) {
+                            sub_pic_hrd_params_present_flag = decoder.readBoolean();
+                            if (sub_pic_hrd_params_present_flag) {
+                                decoder.readBits(8); // tick_divisor_minus2
+                                decoder.readBits(5); // du_cpb_removal_delay_increment_length_minus1
+                                decoder.readBits(1); // sub_pic_cpb_params_in_pic_timing_sei_flag
+                                decoder.readBits(5); // dpb_output_delay_du_length_minus1
+                            }
+                            decoder.readBits(4); // bit_rate_scale
+                            decoder.readBits(4); // cpb_size_scale
+                            if (sub_pic_hrd_params_present_flag) {
+                                decoder.readBits(4); // cpb_size_du_scale
+                            }
+                            decoder.readBits(5); // initial_cpb_removal_delay_length_minus1
+                            decoder.readBits(5); // au_cpb_removal_delay_length_minus1
+                            decoder.readBits(5); // dpb_output_delay_length_minus1
+                        }
+                    }
+
+                    for (let i = 0; i <= sps_max_sub_layers_minus1; i++) {
+                        const fixed_pic_rate_general_flag = decoder.readBoolean();
+                        let fixed_pic_rate_within_cvs_flag = false;
+                        let low_delay_hrd_flag = false;
+                        let cpb_cnt_minus1 = 0;
+                        if (!fixed_pic_rate_general_flag) {
+                            fixed_pic_rate_within_cvs_flag = decoder.readBoolean();
+                        } else {
+                            fixed_pic_rate_within_cvs_flag = true;
+                        }
+                        if (fixed_pic_rate_within_cvs_flag) {
+                            decoder.readUEG(); // elemental_duration_in_tc_minus1
+                        } else {
+                            low_delay_hrd_flag = decoder.readBoolean();
+                        }
+                        if (!low_delay_hrd_flag) {
+                            cpb_cnt_minus1 = decoder.readUEG();
+                        }
+                        if (nal_hrd_parameters_present_flag) {
+                            for (let j = 0; j <= cpb_cnt_minus1; j++) {
+                                decoder.readUEG(); // bit_rate_value_minus1
+                                decoder.readUEG(); // cpb_size_value_minus1
+                                if (sub_pic_hrd_params_present_flag) {
+                                    decoder.readUEG(); // cpb_size_du_value_minus1
+                                    decoder.readUEG(); // bit_rate_du_value_minus1
+                                }
+                                decoder.readBits(1); // cbr_flag
+                            }
+                        }
+                        if (vcl_hrd_parameters_present_flag) {
+                            for (let j = 0; j <= cpb_cnt_minus1; j++) {
+                                decoder.readUEG(); // bit_rate_value_minus1
+                                decoder.readUEG(); // cpb_size_value_minus1
+                                if (sub_pic_hrd_params_present_flag) {
+                                    decoder.readUEG(); // cpb_size_du_value_minus1
+                                    decoder.readUEG(); // bit_rate_du_value_minus1
+                                }
+                                decoder.readBits(1); // cbr_flag
+                            }
+                        }
+                    }
                 }
+
+                if (vui_num_units_in_tick > 0 && vui_time_scale > 0) {
+                    fps = vui_time_scale / vui_num_units_in_tick;
+                }
+            }
+
+            const bitstream_restriction_flag = decoder.readBoolean();
+            if (bitstream_restriction_flag) {
+                decoder.readBoolean(); // tiles_fixed_structure_flag
+                decoder.readBoolean(); // motion_vectors_over_pic_boundaries_flag
+                decoder.readBoolean(); // restricted_ref_pic_lists_flag
+                decoder.readUEG(); // min_spatial_segmentation_idc
+                decoder.readUEG(); // max_bytes_per_pic_denom
+                decoder.readUEG(); // max_bits_per_min_cu_denom
+                decoder.readUEG(); // log2_max_mv_length_horizontal
+                decoder.readUEG(); // log2_max_mv_length_vertical
             }
         }
 

package/src/remuxer/h264.js

@@ -42,18 +42,27 @@ export class H264Remuxer extends BaseRemuxer {
         this.pendingUnits = {};
     }
 
-    feed(data, duration, compositionTimeOffset) {
+    feed(data, duration, compositionTimeOffset, isLastFrameComplete = false) {
         let slices = [];
         let left;
         data = appendByteArray(this.remainingData, data);
         [slices, left] = H264Parser.extractNALu(data);
-        this.remainingData = left || new Uint8Array();
+        if (left) {
+            if (isLastFrameComplete) {
+                slices.push(left);
+                this.remainingData = new Uint8Array();
+            } else {
+                this.remainingData = left;
+            }
+        } else {
+            this.remainingData = new Uint8Array();
+        }
     
         if (slices.length > 0) {
             this.remux(this.getVideoFrames(slices, duration, compositionTimeOffset));
             return true;
         } else {
-            debug.error('Failed to extract any NAL units from video data:', left);
+            debug.log('Failed to extract any NAL units from video data:', left);
             this.dispatch('outOfData');
             return false;
         }
@@ -76,6 +85,8 @@ export class H264Remuxer extends BaseRemuxer {
         for (let nalu of nalus) {
             let unit = new NALU264(nalu);
 
+            if (!this.parseNAL(unit)) continue;
+
             // frame boundary detection
             if (units.length && vcl && (unit.isFirstSlice || !unit.isVCL)) {
                 frames.push({
@@ -134,18 +145,11 @@ export class H264Remuxer extends BaseRemuxer {
 
     remux(frames) {
         for (let frame of frames) {
-            let units = [];
-            let size = 0;
-            for (let unit of frame.units) {
-                if (this.parseNAL(unit)) {
-                    units.push(unit);
-                    size += unit.getSize();
-                }
-            }
-            if (units.length > 0 && this.readyToDecode) {
+            let size = frame.units.reduce((acc, cur) => acc + cur.getSize(), 0);
+            if (frame.units.length > 0 && this.readyToDecode) {
                 this.mp4track.len += size;
                 this.samples.push({
-                    units: units,
+                    units: frame.units,
                     size: size,
                     keyFrame: frame.keyFrame,
                     duration: frame.duration,

package/src/remuxer/h265.js

@@ -1,7 +1,7 @@
 import * as debug from '../util/debug';
 import { H265Parser, NALU265 } from '../parsers/h265.js';
 import { BaseRemuxer } from './base.js';
-import { appendByteArray } from '../util/utils.js';
+import { appendByteArray, reverseBits, removeTrailingDotZero } from '../util/utils.js';
 
 export class H265Remuxer extends BaseRemuxer {
 
@@ -46,18 +46,27 @@ export class H265Remuxer extends BaseRemuxer {
         this.pendingUnits = {};
     }
 
-    feed(data, duration, compositionTimeOffset) {
+    feed(data, duration, compositionTimeOffset, isLastFrameComplete = false) {
         let slices = [];
         let left;
         data = appendByteArray(this.remainingData, data);
         [slices, left] = H265Parser.extractNALu(data);
-        this.remainingData = left || new Uint8Array();
+        if (left) {
+            if (isLastFrameComplete) {
+                slices.push(left);
+                this.remainingData = new Uint8Array();
+            } else {
+                this.remainingData = left;
+            }
+        } else {
+            this.remainingData = new Uint8Array();
+        }
     
         if (slices.length > 0) {
             this.remux(this.getVideoFrames(slices, duration, compositionTimeOffset));
             return true;
         } else {
-            debug.error('Failed to extract any NAL units from video data:', left);
+            debug.log('Failed to extract any NAL units from video data:', left);
             this.dispatch('outOfData');
             return false;
         }
@@ -80,6 +89,8 @@ export class H265Remuxer extends BaseRemuxer {
 
         for (let nalu of nalus) {
             let unit = new NALU265(nalu);
+            
+            if (!this.parseNAL(unit)) continue;
 
             // frame boundary detection
             if (units.length && vcl && (unit.isFirstSlice || !unit.isVCL)) {
@@ -139,18 +150,11 @@ export class H265Remuxer extends BaseRemuxer {
 
     remux(frames) {
         for (let frame of frames) {
-            let units = [];
-            let size = 0;
-            for (let unit of frame.units) {
-                if (this.parseNAL(unit)) {
-                    units.push(unit);
-                    size += unit.getSize();
-                }
-            }
-            if (units.length > 0 && this.readyToDecode) {
+            let size = frame.units.reduce((acc, cur) => acc + cur.getSize(), 0);
+            if (frame.units.length > 0 && this.readyToDecode) {
                 this.mp4track.len += size;
                 this.samples.push({
-                    units: units,
+                    units: frame.units,
                     size: size,
                     keyFrame: frame.keyFrame,
                     duration: frame.duration,
@@ -217,9 +221,12 @@ export class H265Remuxer extends BaseRemuxer {
         this.mp4track.width = config.width;
         this.mp4track.height = config.height;
 
-        this.mp4track.codec = `hvc1.${config.profile_idc}.${config.profile_compatibility_flags.toString(16)}`
-            + `.L${config.level_idc}${config.tier_flag ? 'H' : 'L'}`
-            + `.${config.constraint_indicator_flags.map(b => b.toString(16)).join('.').toUpperCase()}`;
+        this.mp4track.codec = 'hvc1'
+            + '.' + (config.profile_space ? String.fromCharCode(64 + config.profile_space) : '') // Map [0,1,2,3] to ['','A','B','C']
+            + config.profile_idc
+            + '.' + reverseBits(config.profile_compatibility_flags).toString(16)
+            + '.' + (config.tier_flag ? 'H' : 'L') + config.level_idc
+            + '.' + removeTrailingDotZero(config.constraint_indicator_flags.map(function (b) { return b.toString(16); }).join('.').toUpperCase());
 
         this.mp4track.hvcC = {
             profile_space: config.profile_space,

package/src/util/debug.js

@@ -2,10 +2,8 @@ let logger;
 let errorLogger;
 
 export function setLogger(log, err) {
-    /*eslint-disable */
     logger = log;
     errorLogger = err;
-    /*eslint-enable */
 }
 
 export function isEnable() {

package/src/util/utils.js

@@ -22,3 +22,23 @@ export function secToTime(sec) {
     result += (minutes < 10 ? '0' + minutes : minutes) + ':' + (seconds < 10 ? '0' + seconds : seconds);
     return result;
 }
+
+export function reverseBits(n) {
+    var result = 0;
+    for (var i = 0; i < 32; i++)
+    {
+        // Shift result left to make room
+        result <<= 1;
+        // Add the least significant bit of n
+        result |= (n & 1);
+        // Shift n right to process the next bit
+        n >>>= 1;
+    }
+    // Ensure result is treated as unsigned 32-bit
+    return result >>> 0;
+}
+
+export function removeTrailingDotZero(input) {
+    // Use regex to strip all trailing ".0" sequences
+    return input.replace(/(?:\.0)+$/, '');
+}