@astarship/subsecond-id 0.0.0-stage → 0.5.0

package/dist/index.mjs

@@ -0,0 +1,759 @@
+// Source/SsId.ts
+var SsIdTicker_ = 0;
+var SsIdLastId_ = 0n;
+var SsIdSource_ = 0;
+function SsIdSetSource(source) {
+  if (source < 0 || source > SubsecondIdSourceMax) {
+    throw new RangeError(`SsId source out of range: ${source}`);
+  }
+  SsIdSource_ = source;
+}
+function SsIdGetSource() {
+  return SsIdSource_;
+}
+var SsIdSecondsPerYear = 365.25 * 24 * 60 * 60;
+var SsIdFourYearSeconds = 4 * SsIdSecondsPerYear;
+function SsIdWindowStart(now) {
+  const t = now ?? TimestampSeconds();
+  const Year = Math.floor(t / SsIdSecondsPerYear);
+  const WindowYear = Math.floor(Year / 4) * 4 * SsIdSecondsPerYear;
+  return Math.floor(WindowYear);
+}
+function SsIdWindowCount(now) {
+  const t = now ?? TimestampSeconds();
+  return Math.floor(Math.floor(t / SsIdSecondsPerYear) / 4);
+}
+function SsIdNext(_rng) {
+  const Ticker_ = SsIdTicker_;
+  const Ticker = Ticker_ < SsIdTickerMax ? Ticker_ + 1 : SsIdResetTicker();
+  SsIdTicker_ = Ticker;
+  const Seconds = TimestampSeconds() - SsIdWindowStart() & SsIdHotTimestampMax;
+  const Id = BigInt(SsIdHotMsb) << 63n | BigInt(Seconds) << 36n | BigInt(Ticker) << 28n | BigInt(SsIdSource_);
+  if (Id <= SsIdLastId_) {
+    const [LastSeconds, LastTicker] = SsIdUnpack(SsIdLastId_);
+    let NewSeconds = LastSeconds;
+    let NewTicker = LastTicker + 1;
+    if (NewTicker > SsIdTickerMax) {
+      NewTicker = 1;
+      NewSeconds = LastSeconds + 1 & SsIdHotTimestampMax;
+    }
+    const Stepped = BigInt(SsIdHotMsb) << 63n | BigInt(NewSeconds) << 36n | BigInt(NewTicker) << 28n | BigInt(SsIdSource_);
+    SsIdLastId_ = Stepped;
+    SsIdTicker_ = NewTicker;
+    return Stepped;
+  }
+  SsIdLastId_ = Id;
+  return Id;
+}
+function SsIdResetTicker() {
+  SsIdTicker_ = 1;
+  return SsIdTicker_;
+}
+function SsIdPack(timestamp, ticker, source) {
+  const sec = timestamp & SsIdHotTimestampMax;
+  return BigInt(SsIdHotMsb) << 63n | BigInt(sec) << 36n | BigInt(ticker) << 28n | BigInt(source);
+}
+function SsIdUnpack(id) {
+  const seconds = Number(id >> 36n & 0x7FFFFFFn);
+  const ticker = Number(id >> 28n & 0xFFn);
+  const source = Number(id & 0x0FFFFFFFn);
+  return [seconds, ticker, source];
+}
+function SsIdTimestamp(id) {
+  return SsIdUnpack(id)[0];
+}
+function SsIdTicker(id) {
+  return SsIdUnpack(id)[1];
+}
+function SsIdSource(id) {
+  return SsIdUnpack(id)[2];
+}
+function SsIdMsb(id) {
+  return Number(id >> 63n & 1n);
+}
+function SsIdNextHex(rng) {
+  const HexCount = 16;
+  return SsIdNext(rng).toString(16).padStart(HexCount, "0");
+}
+function SsIdPrint(id) {
+  const [seconds, ticker, source] = SsIdUnpack(id);
+  return SsIdMsb(id).toString().padStart(1, "0") + "." + BinaryPadBits(seconds, SsIdHotTimestampBits) + "." + BinaryPadBits(ticker, SsIdTickerBits) + "." + BinaryPadBits(source, SsIdSourceBits);
+}
+function BinaryPadBits(value, bits) {
+  return value.toString(2).padStart(bits, "0");
+}
+
+// Source/SsLId.ts
+var tmt_ticker = 0;
+var tmt_timestamp = TimestampSeconds();
+function SsLIdTimestamp(id) {
+  return Number(id >> 32n);
+}
+function SsLIdTicker(id) {
+  return Number(id & 0xFFFFFFFFn);
+}
+function SsLIdUnpack(id) {
+  return [SsLIdTimestamp(id), SsLIdTicker(id)];
+}
+function SsLIdPack(timestamp, ticker) {
+  return BigInt(timestamp) << 32n | BigInt(ticker);
+}
+function SsLIdPrint(id) {
+  const [timestamp, ticker] = SsLIdUnpack(id);
+  const time = new Date(timestamp * 1e3);
+  return "TMT:{ " + time.toISOString().split("T")[0] + " tick:" + ticker + " }";
+}
+function SsLIdNext() {
+  const timestamp = TimestampSeconds();
+  let ticker = tmt_ticker;
+  if (timestamp !== tmt_timestamp) {
+    tmt_timestamp = timestamp;
+    ticker = 0;
+  } else if (ticker >= TmtTickerMax) {
+    let now = timestamp;
+    while (now === tmt_timestamp) now = TimestampSeconds();
+    tmt_timestamp = now;
+    ticker = 0;
+  }
+  tmt_ticker = ticker + 1;
+  return SsLIdPack(timestamp, ticker);
+}
+function SsLIdNextHex() {
+  return SsLIdNext().toString(16).padStart(16, "0");
+}
+
+// Source/SsUId.ts
+var uid_source = 0n;
+var uid_ticker = 0;
+var uid_timestamp = TimestampSeconds();
+var uid_last_id = 0n;
+function SsUIdTimestamp(subsec_id) {
+  const shift = BigInt(SsUIdSourceBits + SsUIdTickerBits);
+  return subsec_id >> shift;
+}
+function SsUIdTicker(subsec_id) {
+  const sourceBits = BigInt(SsUIdSourceBits);
+  const mask = (1n << BigInt(SsUIdTickerBits)) - 1n;
+  return subsec_id >> sourceBits & mask;
+}
+function SsUIdSource(subsec_id) {
+  const mask = (1n << BigInt(SsUIdSourceBits)) - 1n;
+  return subsec_id & mask;
+}
+function SsUIdPack(timestamp, ticker, source) {
+  const ts = BigInt(timestamp);
+  const tk = BigInt(ticker);
+  const shift = BigInt(SsUIdTickerBits + SsUIdSourceBits);
+  return ts << shift | tk << BigInt(SsUIdSourceBits) | source;
+}
+function SsUIdUnpack(subsec_id) {
+  return [SsUIdTimestamp(subsec_id), SsUIdTicker(subsec_id), SsUIdSource(subsec_id)];
+}
+function SsUIdPrint(subsec_id) {
+  const [timestamp, ticker, source] = SsUIdUnpack(subsec_id);
+  const time = new Date(Number(timestamp) * 1e3);
+  return "SSE:{ timestamp: " + time.toISOString().split("T")[0] + "\n       tick   :" + ticker.toString() + "\n       source :" + source.toString(16) + " }";
+}
+function SsUIdSourceId() {
+  return uid_source;
+}
+function SsUIdSourceNext(rng) {
+  const Rng = rng ?? SsIdRng;
+  let source = 0n;
+  while (source === 0n) {
+    source = BigIntInRange(Rng, 1n, (1n << BigInt(SsUIdSourceBits)) - 1n);
+  }
+  uid_source = source;
+}
+function SsUIdSourceIncrement() {
+  const max = (1n << BigInt(SsUIdSourceBits)) - 1n;
+  if (uid_source >= max) {
+    uid_source = 1n;
+  } else {
+    uid_source = uid_source + 1n;
+  }
+}
+function SsUIdNext(rng) {
+  const Rng = rng ?? SsIdRng;
+  const timestamp = TimestampSeconds();
+  let ticker = uid_ticker;
+  if (timestamp !== uid_timestamp) {
+    uid_timestamp = timestamp;
+    ticker = 0;
+  } else if (ticker >= SsUIdTickerMax) {
+    const next = TimestampSecondsNext();
+    uid_timestamp = next;
+    ticker = 0;
+  }
+  uid_ticker = ticker + 1;
+  if (uid_source === 0n) {
+    SsUIdSourceNext(Rng);
+  }
+  const id = SsUIdPack(timestamp, ticker, uid_source);
+  if (id <= uid_last_id) {
+    uid_last_id = uid_last_id + 1n;
+    return uid_last_id;
+  }
+  uid_last_id = id;
+  return id;
+}
+function SsUIdNextHex(rng, dest = "") {
+  return dest + SsUIdNext(rng).toString(16).padStart(32, "0");
+}
+function SsUIdNextBuffer(rng) {
+  const id = SsUIdNext(rng);
+  const buf = Buffer.alloc(16);
+  for (let i = 0; i < 16; i++) {
+    buf[i] = Number(id >> BigInt(i * 8) & 0xFFn);
+  }
+  return buf;
+}
+
+// Source/index.ts
+import { randomInt as _cryptoRng } from "crypto";
+var SsIdRng = (min, max) => {
+  if (max + 1 < 2 ** 48) {
+    return _cryptoRng(min, max + 1);
+  }
+  const hi = _cryptoRng(0, 2 ** 24);
+  const lo = _cryptoRng(0, 2 ** 24);
+  const val = hi * 2 ** 24 + lo;
+  return Math.min(min + val, max);
+};
+function SsIdSetRng(rng) {
+  SsIdRng = rng;
+}
+var NumberMantissaBits = 53;
+var SsIdSourceBits = 28;
+var SsIdTickerBits = 8;
+var SsIdHotTimestampBits = 27;
+var SsIdHotMsb = 1;
+var SsIdTickerSourceBits = SsIdSourceBits + SsIdTickerBits;
+var SsIdHotTimestampMax = (1 << SsIdHotTimestampBits) - 1;
+var SsIdColdTimestampBits = 34;
+var SsIdColdTickerBits = 29;
+var SsIdColdMsb = 0;
+var SsIdAnonymousTimestampBits = 27;
+var SsIdAnonymousRandomBits = 31;
+var SsIdAnonymousSecondsMin = 126230400;
+var SsIdAnonymousSecondsMax = 130424704;
+var SsIdTickerMax = (1 << SsIdTickerBits) - 1;
+var SubsecondIdSourceMax = (1 << SsIdSourceBits) - 1;
+var TmtTimestampBits = 32;
+var TmtTickerBits = 32;
+var TmtTickerMax = 2 ** TmtTickerBits - 1;
+var SsUIdSourceBits = 76;
+var SsUIdTickerBits = 16;
+var SsUIdTimestampBits2 = 36;
+var SsUIdTickerMax = (1n << BigInt(SsUIdTickerBits)) - 1n;
+function NumberToHex(value, dest = "") {
+  let hex = value.toString(16);
+  if (value < 10) return dest + "0" + hex;
+  return dest + hex;
+}
+function PrintHexByte(input, dest = "") {
+  if (input < 0n || input > 15n) return dest;
+  return dest + NumberToHex(input & 15) + NumberToHex(input >> 4 & 15);
+}
+function ByteCountBits(value) {
+  if (value < 16) {
+    if (value < 4) {
+      if (value < 2) {
+        if (value < 1) return 0;
+        else return 1;
+      } else return 2;
+    } else {
+      if (value < 8) return 3;
+      else return 4;
+    }
+  } else {
+    if (value < 64) {
+      if (value < 32) return 5;
+      else return 6;
+    } else if (value < 128) return 7;
+  }
+  return 8;
+}
+function CountAssertedBits(value) {
+  let count = 0;
+  while (value < 64) {
+    count += value & 1;
+    value >>= 1;
+  }
+  return count;
+}
+function CountLeadingOnes(value) {
+  let count = 0;
+  while (count < 64) {
+    if (!(value >> 63 - count++ & 1)) break;
+  }
+  return count;
+}
+function CountLeadingZeros(value) {
+  let count = 0;
+  while (count < 64) {
+    if (value >> 63 - count++ & 1) break;
+  }
+  return count;
+}
+function NumberCountBytes(value) {
+  if (value <= 4294967295) {
+    if (value <= 65535) {
+      if (value <= 255)
+        return 1;
+      else
+        return 2;
+    } else {
+      if (value <= 16777215)
+        return 3;
+      else
+        return 4;
+    }
+  } else {
+    if (value <= 281474976710655) {
+      if (value <= 1099511627775)
+        return 5;
+      else
+        return 6;
+    }
+  }
+  return 7;
+}
+function NumberCountBits(value) {
+  if (value === 0) return 1;
+  const Bits = NumberCountBytes(value) - 1 << 3;
+  let msb = value < 1 << 30 ? value >> Bits : Number(BigInt(value) >> BigInt(Bits));
+  return Bits + ByteCountBits(msb);
+}
+function NumberPrint(value, char_count, pad = " ") {
+  const Value = value.toString();
+  if (char_count <= 3) return "0".repeat(char_count);
+  if (Value.length > char_count)
+    return Value.substring(0, char_count - 3) + "...";
+  return pad.repeat(char_count - Value.length) + Value;
+}
+function BigIntPrint(value, char_count, pad = " ") {
+  const Value = value.toString();
+  if (char_count <= 3) return "0".repeat(char_count);
+  if (Value.length > char_count)
+    return Value.substring(0, char_count - 3) + "...";
+  return pad.repeat(char_count - Value.length) + Value;
+}
+function BinaryCount(value) {
+  const v = BigInt(value);
+  if (v === 0n) return 1;
+  return v.toString(2).length;
+}
+function BigIntCountBytes(value) {
+  const Bits = BinaryCount(value);
+  return (Bits >> 3) + (Bits & 7 ? 1 : 0);
+}
+function BigIntCountBits(value) {
+  const ByteCount = BigIntCountBytes(value);
+  return (ByteCount - 1 << 3) + NumberCountBits(Number(value));
+}
+function NumberCountDecimals(value) {
+  if (value < 0) value *= -1;
+  if (value < 1e8) {
+    if (value < 1e4) {
+      if (value < 100) {
+        if (value < 10)
+          return 1;
+        else
+          return 2;
+      } else {
+        if (value < 1e3)
+          return 3;
+        else
+          return 4;
+      }
+    } else {
+      if (value < 1e6) {
+        if (value < 1e5)
+          return 5;
+        else
+          return 6;
+      } else {
+        if (value < 1e7)
+          return 7;
+        else
+          return 8;
+      }
+    }
+  } else {
+    if (value < 1e12) {
+      if (value < 1e10) {
+        if (value < 1e9)
+          return 9;
+        else
+          return 10;
+      } else {
+        if (value < 1e11)
+          return 11;
+        else
+          return 12;
+      }
+    } else {
+      if (value < 1e14) {
+        if (value < 1e13)
+          return 13;
+        else
+          return 14;
+      } else {
+        if (value < 1e15)
+          return 15;
+        else
+          return 16;
+      }
+    }
+  }
+}
+function NumberPad(value, digit_count, pad = " ") {
+  const DecimalCount = NumberCountDecimals(value);
+  if (DecimalCount > digit_count) {
+    if (digit_count <= 3) return ".".repeat(digit_count);
+    return value.toString().substring(0, digit_count - 3) + "...";
+  }
+  return pad.repeat(digit_count - DecimalCount) + value;
+}
+function CountDecimals(value) {
+  switch (typeof value) {
+    case "bigint":
+      return BigIntCountDecimals(BigInt(value));
+    case "number":
+      return NumberCountDecimals(Number(value));
+  }
+  const Value = String(value);
+  let i = 0;
+  let c = Value.charCodeAt(i);
+  let leading_zero_count = 0;
+  if (c == "0".charCodeAt(0)) {
+    c = Value.charCodeAt(++i);
+    while (c == "0".charCodeAt(0)) c = Value.charCodeAt(++i);
+    leading_zero_count = i;
+  }
+  while (c != void 0 && c >= "0".charCodeAt(0) && c <= "9".charCodeAt(0))
+    c = Value.charCodeAt(++i);
+  return i - leading_zero_count;
+}
+function BigIntCountDecimals(value) {
+  if (value < 0n) value *= -1n;
+  let decimal_count = 0;
+  const B53DecimalMax = 1000000000000000n;
+  while (value >= B53DecimalMax) {
+    decimal_count += 15;
+    value /= B53DecimalMax;
+  }
+  return decimal_count + NumberCountDecimals(Number(value));
+}
+function BigIntToBuffer2(value) {
+  const ByteCount = BigIntCountBytes(value);
+  const Buf = Buffer.alloc(ByteCount);
+  for (let index = 0; index < ByteCount; ++index) {
+    Buf[index] = Number(value >> BigInt(index << 3) & 0xffn);
+  }
+  return Buf;
+}
+function NumberToBuffer(value) {
+  const ByteCount = NumberCountBytes(value);
+  const Buf = Buffer.alloc(ByteCount);
+  for (let index = 0; index < ByteCount; ++index) {
+    Buf[index] = value >> (index << 3) & 255;
+  }
+  return Buf;
+}
+function BigIntPad(value, decimals_max, pad = " ") {
+  const DecimalCount = BigIntCountDecimals(value);
+  if (DecimalCount > decimals_max) {
+    if (decimals_max <= 3) return pad.repeat(decimals_max);
+    return value.toString().substring(0, decimals_max - 3) + "...";
+  }
+  return pad.repeat(decimals_max - DecimalCount) + value;
+}
+function BinaryPad(value, bit_count = 64, prefix = "0b", pad = "0") {
+  if (bit_count <= 0) return "";
+  const str = typeof value === "string" ? String(value) : value == void 0 ? "" : value.toString(2);
+  if (bit_count < str.length) {
+    if (bit_count < 3) return prefix + ".".repeat(bit_count);
+    return prefix + str.substring(0, bit_count - 3) + "...";
+  }
+  return prefix + pad.repeat(bit_count - str.length) + str;
+}
+function BinaryPadBits2(value, bit_count = 64, prefix = "0b") {
+  return BinaryPad(value, bit_count, prefix) + ":" + (typeof value === "string" ? String(value).length : BigInt(value ?? 0n).toString(2).length);
+}
+function BufferToBigInt(buf) {
+  let result = 0n;
+  for (let i = 0; i < buf.length; ++i)
+    result |= BigInt(buf[i] ?? 0) << BigInt(i << 3);
+  return result;
+}
+function BufferToHex(buf) {
+  let result = "";
+  for (let i = 0; i < buf.length; ++i)
+    result = PrintHexByte(buf[i] ?? 0, result);
+  return result;
+}
+function HexPad(value, bit_count = 64, prefix = "0x", pad = "0") {
+  if (bit_count <= 0) return "";
+  const HexCount = (bit_count >> 2) + (bit_count & 3 ? 1 : 0);
+  let hex = typeof value === "string" ? String(value) : value == void 0 ? "" : value.toString(16);
+  if (hex.length > HexCount) {
+    if (HexCount < 3) return prefix + ".".repeat(HexCount);
+    return prefix + hex.substring(0, HexCount - 3) + "...";
+  }
+  return prefix + pad.repeat(HexCount - hex.length) + hex;
+}
+function HexPadBits(value, bit_count = 64, prefix = "0x") {
+  return HexPad(value, bit_count, prefix) + ":" + (typeof value === "string" ? String(value).length : BinaryCount(BigInt(value ?? 0n)));
+}
+function HexToNibble(input) {
+  if (input == void 0) return -1;
+  let c = input.charCodeAt(0);
+  if (c < "0".charCodeAt(0) || c > "z".charCodeAt(0)) return -1;
+  if (c <= "9".charCodeAt(0))
+    return c - "0".charCodeAt(0);
+  if (c >= "a".charCodeAt(0))
+    return c - "a".charCodeAt(0) + 10;
+  if (c < "A".charCodeAt(0) || c > "Z".charCodeAt(0))
+    return -1;
+  return c - "A".charCodeAt(0) + 10;
+}
+function HexToBigInt(hex) {
+  let result = 0n;
+  let length = hex.length;
+  if (hex == void 0 || length == 0) return result;
+  let i = 0;
+  while (--length >= 0)
+    result |= BigInt(HexToNibble(hex[i++]) << (length << 2));
+  return result;
+}
+function HexToNumber(hex) {
+  let result = 0;
+  let length = hex.length;
+  if (hex == void 0 || length == 0) return result;
+  let i = 0;
+  while (--length >= 0)
+    result |= HexToNibble(hex[i++]) << (length << 2);
+  return result;
+}
+function HexToBuffer(hex) {
+  let length = hex.length;
+  let j = 0;
+  let nibble = hex[j];
+  while (nibble == "0") nibble = hex[++j];
+  let count = length - j;
+  const LSb = count & 1;
+  const ByteCount = (count >> 1) + LSb;
+  const Buf = Buffer.alloc(ByteCount);
+  if (ByteCount <= 0) return Buf;
+  let i = ByteCount - 1;
+  let a = HexToNibble(nibble);
+  if (a < 0) return Buf;
+  if (LSb == 1) {
+    Buf[i--] = a;
+    a = HexToNibble(hex[++j]);
+    if (a < 0) return Buf;
+  }
+  while (a >= 0) {
+    let b = HexToNibble(hex[++j]);
+    if (b < 0) {
+      Buf[i] = a;
+      return Buf;
+    }
+    Buf[i--] = a << 4 | b;
+    a = HexToNibble(hex[++j]);
+  }
+  return Buf;
+}
+function BigIntInRange(rng, min = 0, max = 281474976710655) {
+  if (min > max) return 0n;
+  if (min == max) return BigInt(min);
+  const Max = BigInt(max);
+  const Min = BigInt(min);
+  const Range = Max - Min;
+  const RangeBits = BigInt(BinaryCount(Range));
+  let result = 0n;
+  let count = RangeBits - 1n;
+  while (count > 48n) {
+    count -= 48n;
+    result |= BigInt(rng(0, 281474976710655)) << count;
+  }
+  const Shift = RangeBits - count;
+  const Remainder = Number(Range >> Shift);
+  if (Remainder != 0)
+    result |= BigInt(rng(0, Remainder)) << Shift;
+  return Min + result;
+}
+function NumberInRange(rng, min = 0, max = 281474976710655) {
+  return Number(BigIntInRange(rng, min, max));
+}
+function BigIntInBitRange(rng, bit_min = 1, bit_max = 64) {
+  if (bit_min <= 0 || bit_max <= 0 || bit_min > bit_max) return 0n;
+  const Max = (1n << BigInt(bit_max)) - 1n;
+  const Min = bit_min == 1n ? 0n : 1n << BigInt(bit_min) - 1n;
+  return BigIntInRange(rng, Min, Max);
+}
+function NumberInBitRange(rng, bit_min, bit_max) {
+  if (bit_min <= 0 || bit_max <= 0 || bit_min > bit_max || bit_max > 52) return 0;
+  const Max = (1 << bit_max) - 1;
+  const Min = bit_min == 1 ? 0 : 1 << bit_min - 1;
+  return NumberInRange(rng, Min, Max);
+}
+function BitRangeMinMax(bit_min = 0, bit_max = 64) {
+  const Max = (1n << BigInt(bit_max)) - 1n;
+  const Min = bit_min <= 1n ? -1n : (1n << BigInt(bit_min) - 1n) - 1n;
+  return [Number(Min), Number(Max)];
+}
+function BigIntIsInBitRange(value, bit_min = 0, bit_max = 64) {
+  const V = BigInt(value);
+  const Max = (1n << BigInt(bit_max)) - 1n;
+  const Min = bit_min <= 1n ? 0n : 1n << BigInt(bit_min) - 1n;
+  return V >= Min && V <= Max;
+}
+function BigIntRandom(rng, bit_count = 64) {
+  return BigIntInBitRange(rng, 0, bit_count);
+}
+function NumberRandom(rng) {
+  return rng(Number.MIN_VALUE, Number.MAX_VALUE);
+}
+function NumberNZ(rng, min = Number.MIN_VALUE, max = Number.MAX_VALUE) {
+  let generated = 0;
+  if (min >= max || max - min == generated) return generated;
+  while (generated == 0) {
+    generated = rng(Number.MIN_VALUE, Number.MAX_VALUE);
+  }
+  return generated;
+}
+function NumberNZFromNeg1To1(rng) {
+  let generated = 0;
+  while (generated == 0) {
+    generated = rng(-1, 1);
+  }
+  return generated;
+}
+function TimestampSeconds() {
+  return Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3);
+}
+function TimestampSecondsNext() {
+  let time_start = TimestampSeconds();
+  let now = time_start;
+  while (now == time_start) now = TimestampSeconds();
+  return now;
+}
+function TimestampSecondsNextBigInt() {
+  return BigInt(TimestampSecondsNext());
+}
+function TimestampSecondsAsBigInt() {
+  return BigInt(TimestampSeconds());
+}
+export {
+  BigIntCountBits,
+  BigIntCountBytes,
+  BigIntCountDecimals,
+  BigIntInBitRange,
+  BigIntInRange,
+  BigIntIsInBitRange,
+  BigIntPad,
+  BigIntPrint,
+  BigIntRandom,
+  BigIntToBuffer2 as BigIntToBuffer,
+  BinaryCount,
+  BinaryPad,
+  BinaryPadBits2 as BinaryPadBits,
+  BitRangeMinMax,
+  BufferToBigInt,
+  BufferToHex,
+  ByteCountBits,
+  CountAssertedBits,
+  CountDecimals,
+  CountLeadingOnes,
+  CountLeadingZeros,
+  HexPad,
+  HexPadBits,
+  HexToBigInt,
+  HexToBuffer,
+  HexToNibble,
+  HexToNumber,
+  NumberCountBits,
+  NumberCountBytes,
+  NumberCountDecimals,
+  NumberInBitRange,
+  NumberInRange,
+  NumberMantissaBits,
+  NumberNZ,
+  NumberNZFromNeg1To1,
+  NumberPad,
+  NumberPrint,
+  NumberRandom,
+  NumberToBuffer,
+  NumberToHex,
+  PrintHexByte,
+  SsIdAnonymousRandomBits,
+  SsIdAnonymousSecondsMax,
+  SsIdAnonymousSecondsMin,
+  SsIdAnonymousTimestampBits,
+  SsIdColdMsb,
+  SsIdColdTickerBits,
+  SsIdColdTimestampBits,
+  SsIdFourYearSeconds,
+  SsIdGetSource,
+  SsIdHotMsb,
+  SsIdHotTimestampBits,
+  SsIdHotTimestampMax,
+  SsIdLastId_,
+  SsIdMsb,
+  SsIdNext,
+  SsIdNextHex,
+  SsIdPack,
+  SsIdPrint,
+  SsIdResetTicker,
+  SsIdRng,
+  SsIdSecondsPerYear,
+  SsIdSetRng,
+  SsIdSetSource,
+  SsIdSource,
+  SsIdSourceBits,
+  SsIdSource_,
+  SsIdTicker,
+  SsIdTickerBits,
+  SsIdTickerMax,
+  SsIdTickerSourceBits,
+  SsIdTicker_,
+  SsIdTimestamp,
+  SsIdUnpack,
+  SsIdWindowCount,
+  SsIdWindowStart,
+  SsLIdNext,
+  SsLIdNextHex,
+  SsLIdPack,
+  SsLIdPrint,
+  SsLIdTicker,
+  SsLIdTimestamp,
+  SsLIdUnpack,
+  SsUIdNext,
+  SsUIdNextBuffer,
+  SsUIdNextHex,
+  SsUIdPack,
+  SsUIdPrint,
+  SsUIdSource,
+  SsUIdSourceBits,
+  SsUIdSourceId,
+  SsUIdSourceIncrement,
+  SsUIdSourceNext,
+  SsUIdTicker,
+  SsUIdTickerBits,
+  SsUIdTickerMax,
+  SsUIdTimestamp,
+  SsUIdTimestampBits2 as SsUIdTimestampBits,
+  SsUIdUnpack,
+  SubsecondIdSourceMax,
+  TimestampSeconds,
+  TimestampSecondsAsBigInt,
+  TimestampSecondsNext,
+  TimestampSecondsNextBigInt,
+  TmtTickerBits,
+  TmtTickerMax,
+  TmtTimestampBits
+};
+//# sourceMappingURL=index.mjs.map