snowflake-id-monotonic 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Princetoniño Piscos
+
+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.

package/README.md

@@ -0,0 +1,181 @@
+# ❄️ Snowflake ID Generator (Monotonic)
+
+[![npm version](https://img.shields.io/npm/v/snowflake-id-monotonic.svg?style=flat-square)](https://www.npmjs.com/package/snowflake-id-monotonic)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue?style=flat-square&logo=typescript)](https://www.typescriptlang.org/)
+[![Node.js](https://img.shields.io/badge/Node.js-≥16-green?style=flat-square&logo=node.js)](https://nodejs.org/)
+
+A performancent, monotonic Snowflake ID generator for Node.js and TypeScript applications. Inspired by Twitter's original Snowflake algorithm, time-ordered, unique IDs across distributed systems with zero dependencies,
+
+## Features
+
+- **Monotonic**: IDs are always increasing, even when system clock moves backward
+- **Async Support**: Non-blocking async version for concurrent environments
+- **Timezone Aware**: Optional for timezone-specific decoding
+- **ID Decoding**: Extracts creation timestamp from Snowflake ID base to its offset
+- **Resilient**: Returns "0" on errors instead of throwing
+- **TypeScript Native**: Full type definitions included
+- **Flexible Configuration**: Custom epochs, machine IDs
+
+## 📦 Installation
+
+```bash
+npm install snowflake-id-monotonic
+# or
+yarn add snowflake-id-monotonic
+# or
+pnpm add snowflake-id-monotonic
+```
+
+## Basic Usage
+
+```js
+import { Snowflake } from 'snowflake-id-monotonic';
+
+// Create generator with default settings
+const snowflake = new Snowflake();
+
+// Generate ID (synchronous - fastest)
+const id = snowflake.GenerateID();
+console.log(id); // "130303618715750401"
+
+// Generate ID (asynchronous - non-blocking)
+const asyncId = await snowflake.GenerateIDAsync();
+console.log(asyncId); // "130303618715750402"
+
+// Decode ID back to creation timestamp
+const timestamp = snowflake.decodetoTimestamp(id);
+console.log(timestamp); // "1745109200000" (epoch milliseconds)
+
+// Format timestamp as Date
+console.log(new Date(Number(timestamp)));
+// Output: 2025-04-19T10:33:20.000Z
+```
+
+## Custom Config
+
+```js
+import { Snowflake } from 'snowflake-id-monotonic';
+
+// Create generator with custom settings
+const snowflake = new Snowflake({
+  mid: 42,                    // Machine ID (0-1023)
+  offset: "2025-01-01T00:00:00Z", // Custom epoch (ISO string)
+  // offset: new Date("2025-01-01"), // Or Date object
+  // offset: 1735689600000,    // Or milliseconds
+  // now: () => Date.now(),    // Custom time source
+});
+
+const id = snowflake.GenerateID();
+console.log(id);
+```
+## 🎯 API Reference
+
+__new Snowflake(options?)__ Creates a new Snowflake ID generator instance.
+
+__GenerateID(): string__ Generates a unique Snowflake ID synchronously. Returns "0" on error.
+
+__GenerateIDAsync(): Promise(string)__ Generates a unique Snowflake ID asynchronously. Returns "0" on error.
+
+__decodetoTimestamp(id: string, offset?): string__ Decodes a Snowflake ID back to its creation timestamp (epoch milliseconds).
+
+## Distributed System Setup
+
+```js
+// Server 1
+const server1 = new Snowflake({ mid: 1 });
+
+// Server 2
+const server2 = new Snowflake({ mid: 2 });
+
+// Server 3
+const server3 = new Snowflake({ mid: 3 });
+
+// Each generates unique, non-overlapping IDs
+```
+
+## Database Integration
+```js
+import { Snowflake } from 'snowflake-id-monotonic';
+
+const snowflake = new Snowflake({ mid: process.env.MACHINE_ID || 1 });
+
+// Create user with Snowflake ID
+async function createUser(userData) {
+  const userId = await snowflake.GenerateIDAsync();
+  const createdAt = Number(snowflake.decodetoTimestamp(userId));
+  
+  await db.users.insert({
+    id: userId,
+    ...userData,
+    created_at: new Date(createdAt)
+  });
+  
+  return userId;
+}
+```
+
+## 📈 Performance
+
+### Benchmarks (Node.js v24, Acer Aspire 5 WIN11 Core i5-11th Gen 16gb ram 1tb ssd)
+
+| Method | Rate (IDs/sec) | Time per ID | Relative Speed |
+|--------|----------------|-------------|----------------|
+| `GenerateID()` | ~1.2 million | ~0.0008ms | 1.52x faster |
+| `GenerateIDAsync()` | ~800,000 | ~0.0012ms | Baseline |
+| **Concurrent (100 instances)** | ~340,000 | ~0.0029ms | System-wide |
+
+### Performance Characteristics
+
+1. **Synchronous (`GenerateID()`)**
+   - **Best for**: Bulk generation, single-threaded workloads
+   - **Overhead**: Minimal, but may block event loop briefly
+   - **Use when**: Generating IDs in loops or batches
+
+2. **Asynchronous (`GenerateIDAsync()`)**
+   - **Best for**: High-concurrency, I/O-bound applications
+   - **Overhead**: ~52% slower due to Promise scheduling
+   - **Use when**: In async/await contexts, web servers, real-time systems
+
+3. **Memory Efficiency**
+   - Minimal memory footprint (< 1MB for 1M IDs)
+   - No significant GC pressure
+   - Suitable for serverless and memory-constrained environments
+
+## 🤝 Contributing
+Every snowflake matters - and so does every contribution... Whether you're fixing a typo or adding a new feature...
+
+How You Can Help:
+- 🐛 Found a bug? File an issue with the snowflake ID that caused it!
+- 💡 Have an idea? Suggest features that would make your snowfall heavier
+- 📚 Better docs? Help others navigate the blizzard
+- 🔧 Code contribution? Check our Contributing Guide to get started
+
+### Fun fact: Why 'snowflake'?
+Because a snowflake's shape evolves as it journeys through the air, no two will ever be the same. 
+Even two flakes floating side by side will each be blown through different levels
+of humidity and vapour to create a shape that is truly unique. -BBC UK
+
+### First Time? No Problem!
+- Look for issues tagged good-first-issue ❄️ - perfect for your first contribution to an open source snowstorm!
+
+```bash
+# Quick start for contributors
+git clone https://github.com/piscode/snowflake-id-monotonic.git
+cd snowflake-id-monotonic
+npm install
+npm test
+
+benchmark:
+ - path\test> node benchmark.js
+ - path\test> node benchmark-batch.js
+```
+
+### The Originals
+Twitter Engineering (2010) - For inventing the Snowflake concept that powers thousands of applications today.
+Their brilliant 64-bit timestamp-based design revolutionized distributed ID generation.
+_Dustin Rouillard_ - For the initial JavaScript implementation that made Snowflakes accessible
+
+## Special Thanks To:
+  - The Open Source Community - For being the atmosphere where ideas can collide and form beautiful patterns
+  - Early Adopters - For braving the first snowfall and reporting the icy patches

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+export type SnowflakeOffset = number | Date | string;
+
+export interface SnowflakeOptions
+{
+    /** Machine ID (0–1023). Defaults to 1. */
+    mid?: number;
+    /** Custom epoch (ms since unix epoch), Date, or ISO string. Defaults to 2025-01-01T00:00:00Z. */
+    offset?: SnowflakeOffset;
+    /** Override time source: either a function returning epoch ms, or a fixed epoch ms number. */
+    now?: (() => number) | number;
+}
+
+export declare class Snowflake
+{
+    static DEFAULT_OFFSET: string;
+    static MIN_EPOCH_AGE_MS: number;
+
+    /** Sequence number (0–4095). */
+    seq: number;
+    /** Machine ID (0–1023). */
+    mid: number;
+    /** Custom epoch in ms. */
+    offset: number;
+    /** Time source. */
+    now: (() => number) | number;
+    /** Last timestamp used (epoch ms). */
+    lastTime: number;
+
+    constructor(options?: SnowflakeOptions);
+
+    /**
+     * Generates a unique, time-ordered Snowflake ID.
+     *
+     * Note: the current implementation returns `0` on error.
+     */
+    GenerateID(): string;
+
+    /**
+     * Generates a unique, time-ordered Snowflake ID (non-blocking version).
+     *
+     * Note: the current implementation returns `0` on error.
+     */
+    GenerateIDAsync(): Promise<string>;
+
+    /**
+     * Decodes a Snowflake ID back to its creation timestamp (epoch ms).
+     *
+     * Note: the current implementation returns `0` on error.
+     */
+    decodetoTimestamp(id: string, offset?: SnowflakeOffset): string;
+}

package/dist/index.js

@@ -0,0 +1,165 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/index.js
+var _Snowflake_static, resolveOffsetMs_fn, _Snowflake_instances, getCurrentTime_fn, waitNextMs_fn;
+var _Snowflake = class _Snowflake {
+  /**
+   * @constructor
+   * @param {Object} options Configuration options
+   * @param {number} options.mid Machine ID (0–1023)
+   * @param {number|Date|string} options.offset Custom epoch (ms, Date, or ISO string)
+   * @description creates a new Snowflake ID generator instance 
+   */
+  constructor(options) {
+    __privateAdd(this, _Snowflake_instances);
+    __publicField(this, "seq", 0);
+    __publicField(this, "mid");
+    __publicField(this, "offset");
+    __publicField(this, "now", Date.now);
+    __publicField(this, "lastTime", 0);
+    var _a;
+    this.mid = (options?.mid ?? 1) & 1023;
+    this.offset = __privateMethod(_a = _Snowflake, _Snowflake_static, resolveOffsetMs_fn).call(_a, options?.offset);
+    if (!Number.isFinite(this.offset))
+      throw new Error("Invalid offset: must be a valid epoch in milliseconds, or a parsable DEFAULT_OFFSET ISO string.");
+    this.now = options?.now ?? Date.now;
+    const nowValue = __privateMethod(this, _Snowflake_instances, getCurrentTime_fn).call(this);
+    if (!Number.isFinite(nowValue))
+      throw new Error("Invalid now: must be a function returning epoch ms, or a finite number of epoch ms.");
+    if (this.offset > nowValue - _Snowflake.MIN_EPOCH_AGE_MS)
+      throw new Error("Invalid offset: custom epoch must not be in the future.");
+  }
+  /**
+   * @function GenerateID
+   * @description Generates a unique, time-ordered Snowflake ID
+   * Blocking version (synchronous); Fastest for single-threaded usage, may block the event loop briefly.
+   * @returns {string} The generated Snowflake ID as a string
+   */
+  GenerateID() {
+    let time = __privateMethod(this, _Snowflake_instances, getCurrentTime_fn).call(this);
+    try {
+      if (time < this.lastTime)
+        time = this.lastTime;
+      if (time === this.lastTime) {
+        this.seq = this.seq + 1 & 4095;
+        if (this.seq === 0) {
+          while (__privateMethod(this, _Snowflake_instances, getCurrentTime_fn).call(this) <= time)
+            time = __privateMethod(this, _Snowflake_instances, getCurrentTime_fn).call(this);
+        }
+      } else {
+        this.seq = 0;
+      }
+      this.lastTime = time;
+      const timePart = BigInt(time - this.offset) << 22n;
+      const midPart = BigInt(this.mid) << 12n;
+      const seqPart = BigInt(this.seq);
+      return (timePart | midPart | seqPart).toString(10);
+    } catch (error) {
+      return "0";
+    }
+  }
+  /**
+   * @function GenerateIDAsync
+   * @description Non-blocking version (asynchronous); Uses async/await to yield control instead of blocking event loop.
+   * Slightly slower due to async overhead, but better for high-concurrency scenarios.
+   * @returns {Promise<string>} Promise that resolves to the generated Snowflake ID as a string
+   */
+  async GenerateIDAsync() {
+    let time = __privateMethod(this, _Snowflake_instances, getCurrentTime_fn).call(this);
+    try {
+      if (time < this.lastTime)
+        time = this.lastTime;
+      if (time === this.lastTime) {
+        this.seq = this.seq + 1 & 4095;
+        if (this.seq === 0) {
+          await __privateMethod(this, _Snowflake_instances, waitNextMs_fn).call(this, time);
+          time = __privateMethod(this, _Snowflake_instances, getCurrentTime_fn).call(this);
+        }
+      } else {
+        this.seq = 0;
+      }
+      this.lastTime = time;
+      const timePart = BigInt(time - this.offset) << 22n;
+      const midPart = BigInt(this.mid) << 12n;
+      const seqPart = BigInt(this.seq);
+      const id = timePart | midPart | seqPart;
+      return id.toString(10);
+    } catch (error) {
+      return "0";
+    }
+  }
+  /**
+   * @function decodetoTimestamp
+   * @param {string} id The Snowflake ID to decode
+   * @returns {string} The timestamp (epoch ms) when the ID was generated, or "0" on error
+   * @description decodes a Snowflake ID back to its creation timestamp (epoch ms)
+   */
+  decodetoTimestamp(id, offset = this.offset) {
+    var _a;
+    try {
+      const offsetMs = __privateMethod(_a = _Snowflake, _Snowflake_static, resolveOffsetMs_fn).call(_a, offset);
+      if (!Number.isFinite(offsetMs))
+        throw new Error("Invalid offset");
+      const timePart = BigInt(id) >> 22n;
+      const timestamp = timePart + BigInt(offsetMs);
+      const maxSafe = BigInt(Number.MAX_SAFE_INTEGER);
+      if (timestamp > maxSafe)
+        throw new Error("Timestamp exceeds MAX_SAFE_INTEGER");
+      return String(Number(timestamp));
+    } catch (error) {
+      return "0";
+    }
+  }
+};
+_Snowflake_static = new WeakSet();
+resolveOffsetMs_fn = function(offset) {
+  if (typeof offset === "number")
+    return offset;
+  if (offset instanceof Date)
+    return offset.getTime();
+  const parsed = Date.parse(offset ?? _Snowflake.DEFAULT_OFFSET);
+  return Number.isFinite(parsed) ? parsed : NaN;
+};
+_Snowflake_instances = new WeakSet();
+/**
+ * Retrieves the current timestamp in milliseconds adjusted by offset
+ * @returns {number} Current timestamp in milliseconds adjusted by offset
+ */
+getCurrentTime_fn = function() {
+  if (typeof this.now === "function")
+    return this.now();
+  if (typeof this.now === "number")
+    return this.now;
+  return Date.now();
+};
+/**
+ * @function #waitNextMs
+ * @param {number} time The current timestamp in milliseconds
+ * @returns {Promise<void>} Promise that resolves when the next millisecond is reached
+ * @description Non-blocking wait until the next millisecond
+ */
+waitNextMs_fn = function(time) {
+  return new Promise((resolve) => {
+    const check = () => {
+      if (__privateMethod(this, _Snowflake_instances, getCurrentTime_fn).call(this) > time)
+        resolve();
+      else
+        setTimeout(check, 0);
+    };
+    check();
+  });
+};
+__privateAdd(_Snowflake, _Snowflake_static);
+__publicField(_Snowflake, "DEFAULT_OFFSET", "2000-01-01T00:00:00Z");
+__publicField(_Snowflake, "MIN_EPOCH_AGE_MS", 0);
+var Snowflake = _Snowflake;
+module.exports = { Snowflake };

package/dist/index.mjs

@@ -0,0 +1,173 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/index.js
+var require_index = __commonJS({
+  "src/index.js"(exports, module) {
+    var _Snowflake_static, resolveOffsetMs_fn, _Snowflake_instances, getCurrentTime_fn, waitNextMs_fn;
+    var _Snowflake = class _Snowflake {
+      /**
+       * @constructor
+       * @param {Object} options Configuration options
+       * @param {number} options.mid Machine ID (0–1023)
+       * @param {number|Date|string} options.offset Custom epoch (ms, Date, or ISO string)
+       * @description creates a new Snowflake ID generator instance 
+       */
+      constructor(options) {
+        __privateAdd(this, _Snowflake_instances);
+        __publicField(this, "seq", 0);
+        __publicField(this, "mid");
+        __publicField(this, "offset");
+        __publicField(this, "now", Date.now);
+        __publicField(this, "lastTime", 0);
+        var _a;
+        this.mid = (options?.mid ?? 1) & 1023;
+        this.offset = __privateMethod(_a = _Snowflake, _Snowflake_static, resolveOffsetMs_fn).call(_a, options?.offset);
+        if (!Number.isFinite(this.offset))
+          throw new Error("Invalid offset: must be a valid epoch in milliseconds, or a parsable DEFAULT_OFFSET ISO string.");
+        this.now = options?.now ?? Date.now;
+        const nowValue = __privateMethod(this, _Snowflake_instances, getCurrentTime_fn).call(this);
+        if (!Number.isFinite(nowValue))
+          throw new Error("Invalid now: must be a function returning epoch ms, or a finite number of epoch ms.");
+        if (this.offset > nowValue - _Snowflake.MIN_EPOCH_AGE_MS)
+          throw new Error("Invalid offset: custom epoch must not be in the future.");
+      }
+      /**
+       * @function GenerateID
+       * @description Generates a unique, time-ordered Snowflake ID
+       * Blocking version (synchronous); Fastest for single-threaded usage, may block the event loop briefly.
+       * @returns {string} The generated Snowflake ID as a string
+       */
+      GenerateID() {
+        let time = __privateMethod(this, _Snowflake_instances, getCurrentTime_fn).call(this);
+        try {
+          if (time < this.lastTime)
+            time = this.lastTime;
+          if (time === this.lastTime) {
+            this.seq = this.seq + 1 & 4095;
+            if (this.seq === 0) {
+              while (__privateMethod(this, _Snowflake_instances, getCurrentTime_fn).call(this) <= time)
+                time = __privateMethod(this, _Snowflake_instances, getCurrentTime_fn).call(this);
+            }
+          } else {
+            this.seq = 0;
+          }
+          this.lastTime = time;
+          const timePart = BigInt(time - this.offset) << 22n;
+          const midPart = BigInt(this.mid) << 12n;
+          const seqPart = BigInt(this.seq);
+          return (timePart | midPart | seqPart).toString(10);
+        } catch (error) {
+          return "0";
+        }
+      }
+      /**
+       * @function GenerateIDAsync
+       * @description Non-blocking version (asynchronous); Uses async/await to yield control instead of blocking event loop.
+       * Slightly slower due to async overhead, but better for high-concurrency scenarios.
+       * @returns {Promise<string>} Promise that resolves to the generated Snowflake ID as a string
+       */
+      async GenerateIDAsync() {
+        let time = __privateMethod(this, _Snowflake_instances, getCurrentTime_fn).call(this);
+        try {
+          if (time < this.lastTime)
+            time = this.lastTime;
+          if (time === this.lastTime) {
+            this.seq = this.seq + 1 & 4095;
+            if (this.seq === 0) {
+              await __privateMethod(this, _Snowflake_instances, waitNextMs_fn).call(this, time);
+              time = __privateMethod(this, _Snowflake_instances, getCurrentTime_fn).call(this);
+            }
+          } else {
+            this.seq = 0;
+          }
+          this.lastTime = time;
+          const timePart = BigInt(time - this.offset) << 22n;
+          const midPart = BigInt(this.mid) << 12n;
+          const seqPart = BigInt(this.seq);
+          const id = timePart | midPart | seqPart;
+          return id.toString(10);
+        } catch (error) {
+          return "0";
+        }
+      }
+      /**
+       * @function decodetoTimestamp
+       * @param {string} id The Snowflake ID to decode
+       * @returns {string} The timestamp (epoch ms) when the ID was generated, or "0" on error
+       * @description decodes a Snowflake ID back to its creation timestamp (epoch ms)
+       */
+      decodetoTimestamp(id, offset = this.offset) {
+        var _a;
+        try {
+          const offsetMs = __privateMethod(_a = _Snowflake, _Snowflake_static, resolveOffsetMs_fn).call(_a, offset);
+          if (!Number.isFinite(offsetMs))
+            throw new Error("Invalid offset");
+          const timePart = BigInt(id) >> 22n;
+          const timestamp = timePart + BigInt(offsetMs);
+          const maxSafe = BigInt(Number.MAX_SAFE_INTEGER);
+          if (timestamp > maxSafe)
+            throw new Error("Timestamp exceeds MAX_SAFE_INTEGER");
+          return String(Number(timestamp));
+        } catch (error) {
+          return "0";
+        }
+      }
+    };
+    _Snowflake_static = new WeakSet();
+    resolveOffsetMs_fn = function(offset) {
+      if (typeof offset === "number")
+        return offset;
+      if (offset instanceof Date)
+        return offset.getTime();
+      const parsed = Date.parse(offset ?? _Snowflake.DEFAULT_OFFSET);
+      return Number.isFinite(parsed) ? parsed : NaN;
+    };
+    _Snowflake_instances = new WeakSet();
+    /**
+     * Retrieves the current timestamp in milliseconds adjusted by offset
+     * @returns {number} Current timestamp in milliseconds adjusted by offset
+     */
+    getCurrentTime_fn = function() {
+      if (typeof this.now === "function")
+        return this.now();
+      if (typeof this.now === "number")
+        return this.now;
+      return Date.now();
+    };
+    /**
+     * @function #waitNextMs
+     * @param {number} time The current timestamp in milliseconds
+     * @returns {Promise<void>} Promise that resolves when the next millisecond is reached
+     * @description Non-blocking wait until the next millisecond
+     */
+    waitNextMs_fn = function(time) {
+      return new Promise((resolve) => {
+        const check = () => {
+          if (__privateMethod(this, _Snowflake_instances, getCurrentTime_fn).call(this) > time)
+            resolve();
+          else
+            setTimeout(check, 0);
+        };
+        check();
+      });
+    };
+    __privateAdd(_Snowflake, _Snowflake_static);
+    __publicField(_Snowflake, "DEFAULT_OFFSET", "2000-01-01T00:00:00Z");
+    __publicField(_Snowflake, "MIN_EPOCH_AGE_MS", 0);
+    var Snowflake = _Snowflake;
+    module.exports = { Snowflake };
+  }
+});
+export default require_index();

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "snowflake-id-monotonic",
+  "version": "1.0.0",
+  "description": "A tiny module to generate monotonic time-based 64-bit unique IDs and decode them back to their creation timestamp, inspired by Twitter Snowflake.",
+  "keywords": [
+    "snowflake",
+    "snowflake-id",
+    "snowflake-id-generator",
+    "monotonic-id",
+    "unique-id",
+    "id-generator",
+    "distributed-id",
+    "time-based-id"
+  ],
+  "homepage": "https://github.com/piscodev/snowflake-id-monotonic#readme",
+  "bugs": {
+    "url": "https://github.com/piscodev/snowflake-id-monotonic/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/piscodev/snowflake-id-monotonic.git"
+  },
+  "license": "MIT",
+  "author": "Princetoniño Piscos",
+  "type": "commonjs",
+
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
+  },
+
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+
+  "scripts": {
+    "build": "node scripts/clean-dist.cjs && tsup src/index.js --format cjs,esm --out-dir dist && node scripts/copy-types.cjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run typecheck",
+    "prepublish": "npm run build && npm test"
+  },
+
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}