@stateforward/hsm.ts 0.1.0

package/dist/kind.cjs

@@ -0,0 +1,162 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/kind.ts
+var kind_exports = {};
+__export(kind_exports, {
+  IsKind: () => IsKind,
+  Kinds: () => Kinds,
+  MakeKind: () => MakeKind,
+  bases: () => bases,
+  isKind: () => isKind,
+  kind: () => kind,
+  kinds: () => kinds,
+  makeKind: () => makeKind
+});
+module.exports = __toCommonJS(kind_exports);
+var length = 48;
+var idLength = 8;
+var depthMax = length / idLength;
+var idMask = (1 << idLength) - 1;
+var counter = 0;
+var nextId = () => {
+  const id = counter & idMask;
+  counter += 1;
+  return id;
+};
+var extractId = (kindValue, depth) => Math.floor(kindValue / Math.pow(2, idLength * depth)) & idMask;
+var bases = (id) => {
+  const baseKinds = Array(depthMax).fill(0);
+  for (let index = 1; index < depthMax; index += 1) {
+    baseKinds[index - 1] = extractId(id, index);
+  }
+  return baseKinds;
+};
+function kind(...baseKinds) {
+  let result = nextId();
+  const used = {};
+  let usedCount = 0;
+  for (const base of baseKinds) {
+    for (let depth = 0; depth < depthMax; depth += 1) {
+      const baseId = extractId(base, depth);
+      if (baseId === 0) {
+        break;
+      }
+      if (used[baseId]) {
+        continue;
+      }
+      used[baseId] = true;
+      usedCount += 1;
+      result += baseId * Math.pow(2, usedCount * idLength);
+    }
+  }
+  return result;
+}
+function isKind(kindValue, ...baseKinds) {
+  for (const base of baseKinds) {
+    const baseId = base & idMask;
+    if (kindValue === baseId) {
+      return true;
+    }
+    for (let depth = 0; depth < depthMax; depth += 1) {
+      const currentId = extractId(kindValue, depth);
+      if (currentId === baseId) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var makeKind = (...baseKinds) => kind(...baseKinds);
+var kinds = {
+  Null: makeKind(),
+  Element: makeKind(),
+  Partial: 0,
+  Vertex: 0,
+  Constraint: 0,
+  Behavior: 0,
+  Namespace: 0,
+  Concurrent: 0,
+  Sequential: 0,
+  StateMachine: 0,
+  Attribute: 0,
+  State: 0,
+  Model: 0,
+  Transition: 0,
+  Internal: 0,
+  External: 0,
+  Local: 0,
+  Self: 0,
+  Event: 0,
+  CompletionEvent: 0,
+  ChangeEvent: 0,
+  ErrorEvent: 0,
+  TimeEvent: 0,
+  CallEvent: 0,
+  Pseudostate: 0,
+  Initial: 0,
+  FinalState: 0,
+  Choice: 0,
+  Junction: 0,
+  DeepHistory: 0,
+  ShallowHistory: 0
+};
+kinds.Partial = makeKind(kinds.Element);
+kinds.Vertex = makeKind(kinds.Element);
+kinds.Constraint = makeKind(kinds.Element);
+kinds.Behavior = makeKind(kinds.Element);
+kinds.Namespace = makeKind(kinds.Element);
+kinds.Concurrent = makeKind(kinds.Behavior);
+kinds.Sequential = makeKind(kinds.Behavior);
+kinds.StateMachine = makeKind(kinds.Concurrent, kinds.Namespace);
+kinds.Attribute = makeKind(kinds.Element);
+kinds.State = makeKind(kinds.Vertex, kinds.Namespace);
+kinds.Model = makeKind(kinds.State);
+kinds.Transition = makeKind(kinds.Element);
+kinds.Internal = makeKind(kinds.Transition);
+kinds.External = makeKind(kinds.Transition);
+kinds.Local = makeKind(kinds.Transition);
+kinds.Self = makeKind(kinds.Transition);
+kinds.Event = makeKind(kinds.Element);
+kinds.CompletionEvent = makeKind(kinds.Event);
+kinds.ChangeEvent = makeKind(kinds.Event);
+kinds.ErrorEvent = makeKind(kinds.CompletionEvent);
+kinds.TimeEvent = makeKind(kinds.Event);
+kinds.CallEvent = makeKind(kinds.Event);
+kinds.Pseudostate = makeKind(kinds.Vertex);
+kinds.Initial = makeKind(kinds.Pseudostate);
+kinds.FinalState = makeKind(kinds.State);
+kinds.Choice = makeKind(kinds.Pseudostate);
+kinds.Junction = makeKind(kinds.Pseudostate);
+kinds.DeepHistory = makeKind(kinds.Pseudostate);
+kinds.ShallowHistory = makeKind(kinds.Pseudostate);
+var Kinds = kinds;
+var MakeKind = makeKind;
+var IsKind = isKind;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IsKind,
+  Kinds,
+  MakeKind,
+  bases,
+  isKind,
+  kind,
+  kinds,
+  makeKind
+});
+//# sourceMappingURL=kind.cjs.map

package/dist/kind.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/kind.ts"],"sourcesContent":["export type Kind = number;\n\nconst length = 48;\nconst idLength = 8;\nconst depthMax = length / idLength;\nconst idMask = (1 << idLength) - 1;\n\nlet counter = 0;\n\nconst nextId = () => {\n  const id = counter & idMask;\n  counter += 1;\n  return id;\n};\n\nconst extractId = (kindValue: number, depth: number) =>\n  Math.floor(kindValue / Math.pow(2, idLength * depth)) & idMask;\n\nexport const bases = (id: number) => {\n  const baseKinds = Array<number>(depthMax).fill(0);\n\n  for (let index = 1; index < depthMax; index += 1) {\n    baseKinds[index - 1] = extractId(id, index);\n  }\n\n  return baseKinds;\n};\n\nexport function kind(...baseKinds: number[]) {\n  let result = nextId();\n  const used: Record<number, true> = {};\n  let usedCount = 0;\n\n  for (const base of baseKinds) {\n    for (let depth = 0; depth < depthMax; depth += 1) {\n      const baseId = extractId(base, depth);\n      if (baseId === 0) {\n        break;\n      }\n      if (used[baseId]) {\n        continue;\n      }\n\n      used[baseId] = true;\n      usedCount += 1;\n      result += baseId * Math.pow(2, usedCount * idLength);\n    }\n  }\n\n  return result;\n}\n\nexport function isKind(kindValue: number, ...baseKinds: number[]) {\n  for (const base of baseKinds) {\n    const baseId = base & idMask;\n    if (kindValue === baseId) {\n      return true;\n    }\n\n    for (let depth = 0; depth < depthMax; depth += 1) {\n      const currentId = extractId(kindValue, depth);\n      if (currentId === baseId) {\n        return true;\n      }\n    }\n  }\n\n  return false;\n}\n\nexport const makeKind = (...baseKinds: number[]) => kind(...baseKinds);\n\nexport const kinds = {\n  Null: makeKind(),\n  Element: makeKind(),\n  Partial: 0,\n  Vertex: 0,\n  Constraint: 0,\n  Behavior: 0,\n  Namespace: 0,\n  Concurrent: 0,\n  Sequential: 0,\n  StateMachine: 0,\n  Attribute: 0,\n  State: 0,\n  Model: 0,\n  Transition: 0,\n  Internal: 0,\n  External: 0,\n  Local: 0,\n  Self: 0,\n  Event: 0,\n  CompletionEvent: 0,\n  ChangeEvent: 0,\n  ErrorEvent: 0,\n  TimeEvent: 0,\n  CallEvent: 0,\n  Pseudostate: 0,\n  Initial: 0,\n  FinalState: 0,\n  Choice: 0,\n  Junction: 0,\n  DeepHistory: 0,\n  ShallowHistory: 0,\n} satisfies Record<string, Kind>;\n\nkinds.Partial = makeKind(kinds.Element);\nkinds.Vertex = makeKind(kinds.Element);\nkinds.Constraint = makeKind(kinds.Element);\nkinds.Behavior = makeKind(kinds.Element);\nkinds.Namespace = makeKind(kinds.Element);\nkinds.Concurrent = makeKind(kinds.Behavior);\nkinds.Sequential = makeKind(kinds.Behavior);\nkinds.StateMachine = makeKind(kinds.Concurrent, kinds.Namespace);\nkinds.Attribute = makeKind(kinds.Element);\nkinds.State = makeKind(kinds.Vertex, kinds.Namespace);\nkinds.Model = makeKind(kinds.State);\nkinds.Transition = makeKind(kinds.Element);\nkinds.Internal = makeKind(kinds.Transition);\nkinds.External = makeKind(kinds.Transition);\nkinds.Local = makeKind(kinds.Transition);\nkinds.Self = makeKind(kinds.Transition);\nkinds.Event = makeKind(kinds.Element);\nkinds.CompletionEvent = makeKind(kinds.Event);\nkinds.ChangeEvent = makeKind(kinds.Event);\nkinds.ErrorEvent = makeKind(kinds.CompletionEvent);\nkinds.TimeEvent = makeKind(kinds.Event);\nkinds.CallEvent = makeKind(kinds.Event);\nkinds.Pseudostate = makeKind(kinds.Vertex);\nkinds.Initial = makeKind(kinds.Pseudostate);\nkinds.FinalState = makeKind(kinds.State);\nkinds.Choice = makeKind(kinds.Pseudostate);\nkinds.Junction = makeKind(kinds.Pseudostate);\nkinds.DeepHistory = makeKind(kinds.Pseudostate);\nkinds.ShallowHistory = makeKind(kinds.Pseudostate);\n\nexport const Kinds = kinds;\nexport const MakeKind = makeKind;\nexport const IsKind = isKind;\n"],"mappings":"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","names":[]}

package/dist/kind.d.cts

@@ -0,0 +1,75 @@
+type Kind = number;
+declare const bases: (id: number) => number[];
+declare function kind(...baseKinds: number[]): number;
+declare function isKind(kindValue: number, ...baseKinds: number[]): boolean;
+declare const makeKind: (...baseKinds: number[]) => number;
+declare const kinds: {
+    Null: number;
+    Element: number;
+    Partial: number;
+    Vertex: number;
+    Constraint: number;
+    Behavior: number;
+    Namespace: number;
+    Concurrent: number;
+    Sequential: number;
+    StateMachine: number;
+    Attribute: number;
+    State: number;
+    Model: number;
+    Transition: number;
+    Internal: number;
+    External: number;
+    Local: number;
+    Self: number;
+    Event: number;
+    CompletionEvent: number;
+    ChangeEvent: number;
+    ErrorEvent: number;
+    TimeEvent: number;
+    CallEvent: number;
+    Pseudostate: number;
+    Initial: number;
+    FinalState: number;
+    Choice: number;
+    Junction: number;
+    DeepHistory: number;
+    ShallowHistory: number;
+};
+declare const Kinds: {
+    Null: number;
+    Element: number;
+    Partial: number;
+    Vertex: number;
+    Constraint: number;
+    Behavior: number;
+    Namespace: number;
+    Concurrent: number;
+    Sequential: number;
+    StateMachine: number;
+    Attribute: number;
+    State: number;
+    Model: number;
+    Transition: number;
+    Internal: number;
+    External: number;
+    Local: number;
+    Self: number;
+    Event: number;
+    CompletionEvent: number;
+    ChangeEvent: number;
+    ErrorEvent: number;
+    TimeEvent: number;
+    CallEvent: number;
+    Pseudostate: number;
+    Initial: number;
+    FinalState: number;
+    Choice: number;
+    Junction: number;
+    DeepHistory: number;
+    ShallowHistory: number;
+};
+declare const MakeKind: (...baseKinds: number[]) => number;
+declare const IsKind: typeof isKind;
+
+export { IsKind, type Kind, Kinds, MakeKind, bases, isKind, kind, kinds, makeKind };

package/dist/kind.d.ts

@@ -0,0 +1,75 @@
+type Kind = number;
+declare const bases: (id: number) => number[];
+declare function kind(...baseKinds: number[]): number;
+declare function isKind(kindValue: number, ...baseKinds: number[]): boolean;
+declare const makeKind: (...baseKinds: number[]) => number;
+declare const kinds: {
+    Null: number;
+    Element: number;
+    Partial: number;
+    Vertex: number;
+    Constraint: number;
+    Behavior: number;
+    Namespace: number;
+    Concurrent: number;
+    Sequential: number;
+    StateMachine: number;
+    Attribute: number;
+    State: number;
+    Model: number;
+    Transition: number;
+    Internal: number;
+    External: number;
+    Local: number;
+    Self: number;
+    Event: number;
+    CompletionEvent: number;
+    ChangeEvent: number;
+    ErrorEvent: number;
+    TimeEvent: number;
+    CallEvent: number;
+    Pseudostate: number;
+    Initial: number;
+    FinalState: number;
+    Choice: number;
+    Junction: number;
+    DeepHistory: number;
+    ShallowHistory: number;
+};
+declare const Kinds: {
+    Null: number;
+    Element: number;
+    Partial: number;
+    Vertex: number;
+    Constraint: number;
+    Behavior: number;
+    Namespace: number;
+    Concurrent: number;
+    Sequential: number;
+    StateMachine: number;
+    Attribute: number;
+    State: number;
+    Model: number;
+    Transition: number;
+    Internal: number;
+    External: number;
+    Local: number;
+    Self: number;
+    Event: number;
+    CompletionEvent: number;
+    ChangeEvent: number;
+    ErrorEvent: number;
+    TimeEvent: number;
+    CallEvent: number;
+    Pseudostate: number;
+    Initial: number;
+    FinalState: number;
+    Choice: number;
+    Junction: number;
+    DeepHistory: number;
+    ShallowHistory: number;
+};
+declare const MakeKind: (...baseKinds: number[]) => number;
+declare const IsKind: typeof isKind;
+
+export { IsKind, type Kind, Kinds, MakeKind, bases, isKind, kind, kinds, makeKind };

package/dist/kind.js

@@ -0,0 +1,21 @@
+import {
+  IsKind,
+  Kinds,
+  MakeKind,
+  bases,
+  isKind,
+  kind,
+  kinds,
+  makeKind
+} from "./chunk-UO7RF4FF.js";
+export {
+  IsKind,
+  Kinds,
+  MakeKind,
+  bases,
+  isKind,
+  kind,
+  kinds,
+  makeKind
+};
+//# sourceMappingURL=kind.js.map

package/dist/kind.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/muid.cjs

@@ -0,0 +1,345 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/muid.ts
+var muid_exports = {};
+__export(muid_exports, {
+  Generator: () => Generator,
+  MUID: () => MUID,
+  ShardedGenerators: () => ShardedGenerators,
+  add64: () => add64,
+  and64: () => and64,
+  cmp64: () => cmp64,
+  from32: () => from32,
+  getDefaultConfig: () => getDefaultConfig,
+  make: () => make,
+  make64: () => make64,
+  makeMuid: () => makeMuid,
+  newGenerator: () => newGenerator,
+  or64: () => or64,
+  shl64: () => shl64,
+  shr64: () => shr64,
+  sub64: () => sub64
+});
+module.exports = __toCommonJS(muid_exports);
+var defaultEpochValue = 17e11;
+var make64 = (high, low) => ({
+  high: high >>> 0,
+  low: low >>> 0
+});
+var from32 = (value) => make64(0, value >>> 0);
+var add64 = (a, b) => {
+  const low = a.low + b.low >>> 0;
+  const carry = a.low + b.low > 4294967295 ? 1 : 0;
+  const high = a.high + b.high + carry >>> 0;
+  return make64(high, low);
+};
+var sub64 = (a, b) => {
+  const low = a.low - b.low >>> 0;
+  const borrow = a.low < b.low ? 1 : 0;
+  const high = a.high - b.high - borrow >>> 0;
+  return make64(high, low);
+};
+var shl64 = (value, bits) => {
+  if (bits === 0) {
+    return value;
+  }
+  if (bits >= 64) {
+    return make64(0, 0);
+  }
+  if (bits >= 32) {
+    return make64(value.low << bits - 32, 0);
+  }
+  const high = value.high << bits | value.low >>> 32 - bits;
+  const low = value.low << bits;
+  return make64(high >>> 0, low >>> 0);
+};
+var shr64 = (value, bits) => {
+  if (bits === 0) {
+    return value;
+  }
+  if (bits >= 64) {
+    return make64(0, 0);
+  }
+  if (bits >= 32) {
+    return make64(0, value.high >>> bits - 32);
+  }
+  const low = value.low >>> bits | value.high << 32 - bits;
+  const high = value.high >>> bits;
+  return make64(high >>> 0, low >>> 0);
+};
+var or64 = (a, b) => make64((a.high | b.high) >>> 0, (a.low | b.low) >>> 0);
+var and64 = (a, b) => make64((a.high & b.high) >>> 0, (a.low & b.low) >>> 0);
+var cmp64 = (a, b) => {
+  if (a.high < b.high) {
+    return -1;
+  }
+  if (a.high > b.high) {
+    return 1;
+  }
+  if (a.low < b.low) {
+    return -1;
+  }
+  if (a.low > b.low) {
+    return 1;
+  }
+  return 0;
+};
+var gte64 = (a, b) => cmp64(a, b) >= 0;
+var toHex64 = (value) => {
+  if (value.high === 0) {
+    return value.low.toString(16);
+  }
+  const highHex = value.high.toString(16);
+  let lowHex = value.low.toString(16);
+  while (lowHex.length < 8) {
+    lowHex = `0${lowHex}`;
+  }
+  return `${highHex}${lowHex}`;
+};
+var toString64 = (value) => {
+  if (value.high === 0) {
+    return value.low.toString();
+  }
+  if (value.high < 2097152) {
+    return (value.high * 4294967296 + value.low).toString();
+  }
+  return `0x${toHex64(value)}`;
+};
+var toBase32_64 = (value) => {
+  if (value.high === 0) {
+    return value.low.toString(32);
+  }
+  const hex = toHex64(value);
+  let num = 0;
+  let result = "";
+  for (let index = 0; index < hex.length; index += 1) {
+    num = num * 16 + Number.parseInt(hex[index], 16);
+    if (num >= 32) {
+      result += (num % 32).toString(32);
+      num = Math.floor(num / 32);
+    }
+  }
+  if (num > 0) {
+    result = `${num.toString(32)}${result}`;
+  }
+  return result || "0";
+};
+var hashString = (value) => {
+  let hash = make64(2166136261, 0);
+  const prime = from32(16777619);
+  for (let index = 0; index < value.length; index += 1) {
+    const char = from32(value.charCodeAt(index));
+    hash = and64(or64(hash, char), make64(0, 4294967295));
+    if (hash.high === 0) {
+      hash = from32(hash.low * prime.low >>> 0);
+    }
+  }
+  return hash;
+};
+var getMachineIdentifier = () => {
+  if (typeof process !== "undefined") {
+    const identifier = process.env.HOSTNAME ?? process.env.COMPUTERNAME ?? process.release?.name;
+    if (identifier) {
+      return identifier;
+    }
+  }
+  if (typeof navigator !== "undefined") {
+    return `${navigator.userAgent}${navigator.platform}${navigator.hardwareConcurrency ?? ""}`;
+  }
+  return `js-${Math.random().toString(36).slice(2)}`;
+};
+var getRandomBytes = (length) => {
+  const cryptoApi = globalThis.crypto;
+  if (cryptoApi?.getRandomValues) {
+    const values = new Uint8Array(length);
+    cryptoApi.getRandomValues(values);
+    return Array.from(values);
+  }
+  return Array.from({ length }, () => Math.floor(Math.random() * 256));
+};
+var getDefaultConfig = () => {
+  const epoch = make64(
+    Math.floor(defaultEpochValue / 4294967296),
+    defaultEpochValue % 4294967296
+  );
+  const timestampBitLen = 41;
+  const machineIDBitLen = 14;
+  const maxMachineID = (1 << machineIDBitLen) - 1;
+  const identifier = getMachineIdentifier();
+  let machineID;
+  if (identifier) {
+    const hash = hashString(identifier);
+    machineID = from32(hash.low & maxMachineID);
+  } else {
+    const randomBytes = getRandomBytes(4);
+    let randomValue = 0;
+    for (let index = 0; index < 4; index += 1) {
+      randomValue = randomValue << 8 | randomBytes[index];
+    }
+    machineID = from32(randomValue & maxMachineID);
+  }
+  return {
+    epoch,
+    machineID,
+    machineIDBitLen,
+    timestampBitLen
+  };
+};
+var MUID = class {
+  value;
+  constructor(value) {
+    if (typeof value === "number") {
+      this.value = from32(value);
+      return;
+    }
+    if (value && typeof value.high === "number" && typeof value.low === "number") {
+      this.value = make64(value.high, value.low);
+      return;
+    }
+    this.value = make64(0, 0);
+  }
+  toString() {
+    return toBase32_64(this.value);
+  }
+  toHex() {
+    return toHex64(this.value);
+  }
+  toDecimal() {
+    return toString64(this.value);
+  }
+  valueOf() {
+    return this.value;
+  }
+};
+var Generator = class {
+  timestampBitLen;
+  machineIDBitLen;
+  epoch;
+  shardIndex;
+  shardBitLen;
+  counterBitLen;
+  timestampBitShift;
+  machineIDShift;
+  shardIndexShift;
+  counterBitMask;
+  machineID;
+  state;
+  constructor(config = {}, shardIndex = 0, shardBitLen = 0) {
+    this.timestampBitLen = config.timestampBitLen ?? 41;
+    this.machineIDBitLen = config.machineIDBitLen ?? 14;
+    this.epoch = config.epoch ?? make64(
+      Math.floor(defaultEpochValue / 4294967296),
+      defaultEpochValue % 4294967296
+    );
+    this.shardIndex = shardIndex;
+    this.shardBitLen = shardBitLen;
+    this.counterBitLen = 64 - this.timestampBitLen - this.machineIDBitLen - this.shardBitLen;
+    this.timestampBitShift = this.machineIDBitLen + this.shardBitLen + this.counterBitLen;
+    this.machineIDShift = this.shardBitLen + this.counterBitLen;
+    this.shardIndexShift = this.counterBitLen;
+    this.counterBitMask = this.counterBitLen >= 32 ? make64(4294967295, 4294967295) : sub64(shl64(from32(1), this.counterBitLen), from32(1));
+    const machineIDMask = this.machineIDBitLen >= 32 ? make64(4294967295, 4294967295) : sub64(shl64(from32(1), this.machineIDBitLen), from32(1));
+    this.machineID = and64(config.machineID ?? from32(0), machineIDMask);
+    this.shardIndex = (this.shardIndex & (1 << Math.min(this.shardBitLen, 31)) - 1) >>> 0;
+    this.state = from32(1);
+  }
+  id() {
+    let now = sub64(from32(Date.now() & 4294967295), this.epoch);
+    const dateNow = Date.now();
+    if (dateNow > 4294967295) {
+      now = sub64(
+        make64(Math.floor(dateNow / 4294967296), dateNow & 4294967295),
+        this.epoch
+      );
+    }
+    const lastTimestamp = shr64(this.state, this.counterBitLen);
+    let counter = and64(this.state, this.counterBitMask);
+    if (cmp64(now, lastTimestamp) < 0) {
+      now = lastTimestamp;
+    }
+    if (cmp64(now, lastTimestamp) === 0) {
+      if (gte64(counter, this.counterBitMask)) {
+        now = add64(now, from32(1));
+        counter = from32(1);
+      } else {
+        counter = add64(counter, from32(1));
+      }
+    } else {
+      counter = from32(1);
+    }
+    this.state = or64(shl64(now, this.counterBitLen), counter);
+    const timestampPart = shl64(now, this.timestampBitShift);
+    const machineIDPart = shl64(this.machineID, this.machineIDShift);
+    const shardIndexPart = shl64(from32(this.shardIndex), this.shardIndexShift);
+    return new MUID(
+      or64(or64(or64(timestampPart, machineIDPart), shardIndexPart), counter)
+    );
+  }
+};
+var ShardedGenerators = class {
+  pool;
+  size;
+  index = 0;
+  constructor() {
+    const numCPU = typeof navigator !== "undefined" && navigator.hardwareConcurrency ? navigator.hardwareConcurrency : 4;
+    const shardBits = numCPU > 1 ? Math.min(Math.ceil(Math.log2(numCPU)), 5) : 0;
+    const defaultConfig = getDefaultConfig();
+    this.size = 1 << shardBits;
+    this.pool = [];
+    for (let index = 0; index < this.size; index += 1) {
+      this.pool.push(new Generator(defaultConfig, index, shardBits));
+    }
+  }
+  next() {
+    const generator = this.pool[this.index];
+    this.index = (this.index + 1) % this.size;
+    return generator;
+  }
+};
+var defaultGenerator = new Generator(getDefaultConfig(), 0, 0);
+var make = () => defaultGenerator.id();
+var newGenerator = (config = {}, shardIndex = 0, shardBitLen = 0) => new Generator(
+  {
+    ...getDefaultConfig(),
+    ...config
+  },
+  shardIndex,
+  shardBitLen
+);
+var makeMuid = (prefix) => `${prefix}-${make().toString()}`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Generator,
+  MUID,
+  ShardedGenerators,
+  add64,
+  and64,
+  cmp64,
+  from32,
+  getDefaultConfig,
+  make,
+  make64,
+  makeMuid,
+  newGenerator,
+  or64,
+  shl64,
+  shr64,
+  sub64
+});
+//# sourceMappingURL=muid.cjs.map