installed eslint

node/eslint.config.js

@@ -0,0 +1,14 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import tseslint from 'typescript-eslint'
+import { defineConfig } from 'eslint/config'
+
+export default defineConfig([
+    {
+        files: ['**/*.ts'],
+        plugins: { js },
+        extends: ['js/recommended'],
+        languageOptions: { globals: { ...globals.browser, ...globals.node } },
+    },
+    tseslint.configs.recommended,
+])

node/package.json

@@ -3,6 +3,7 @@
     "version": "2.0.0",
     "description": "flag/bitflag helper",
     "main": "index.js",
+    "type": "module",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/louisdevie/multiflag.git"
@@ -21,9 +22,10 @@
         "build": "tsup",
         "postbuild": "cp package.json README.md ../LICENSE dist",
         "test": "vitest --ui",
+        "lint": "eslint",
         "coverage": "vitest run --coverage",
         "type-check": "tsc --noEmit",
-        "format": "prettier --write src/ tests/"
+        "format": "prettier --write src/ tests/ *.js *.ts"
     },
     "tsup": {
         "entry": [
@@ -36,12 +38,17 @@
         "clean": true
     },
     "devDependencies": {
+        "@eslint/js": "^10.0.1",
         "@vitest/coverage-v8": "^4.0.18",
         "@vitest/ui": "^4.0.18",
+        "eslint": "^10.0.2",
+        "eslint-plugin-simple-import-sort": "^12.1.1",
+        "globals": "^17.4.0",
         "prettier": "^3.8.1",
         "ts-node": "^10.9.2",
         "tsup": "^8.5.1",
         "typescript": "^5.9.3",
+        "typescript-eslint": "^8.56.1",
         "vitest": "^4.0.18"
     }
 }

node/src/flagsets/index.ts

@@ -135,4 +135,4 @@ export { ArrayFlagSet } from './array'
 export { Base64BitFlagSet } from './base64'
 export { BigBitFlagSet } from './bigint'
 export { CollectionFlagSet } from './collection'
-export { BitFlagSet } from './number'
+export { BitFlagSet, BitFlags } from './number'

node/src/flagsets/number.ts

@@ -2,6 +2,47 @@ import type { FlagSet } from '.'
 import { BitFlagsIterator, EnumerateFlags, useIterator } from '~/enumeration'
 import { FlagDefinition, FlagsDictionary } from '~/definitions'
 
+export const BitFlags = {
+    /**
+     * Computes the union of two sets of bitflags.
+     * Any bits that are set in either of the inputs will be set in the result.
+     */
+    union(first: number, second: number): number {
+        return first | second
+    },
+
+    /**
+     * Computes the intersection of two sets of bitflags.
+     * Only bits that are set in both of the inputs will be set in the result.
+     */
+    intersection(first: number, second: number): number {
+        return first & second
+    },
+
+    /**
+     * Computes the difference between two sets of bitflags.
+     * Only bits that are set in the first input and not set in the second will be set in the result.
+     */
+    difference(first: number, second: number): number {
+        return first & ~second
+    },
+
+    /**
+     * Tests if a set of bitflags is a superset of the other.
+     * Return `true` if every bit that is set in the second input is also set in the first.
+     */
+    isSuperset(first: number, second: number): boolean {
+        return (first & second) === second
+    },
+
+    /**
+     * Returns an iterable over the individual bits that are set.
+     */
+    enumerate(flags: number): EnumerateFlags<number> {
+        return useIterator(flags, BitFlagsIterator)
+    },
+}
+
 export class BitFlagSet implements FlagSet<number, number> {
     private readonly _dictionary: FlagsDictionary<number, number>
 
@@ -22,19 +63,19 @@ export class BitFlagSet implements FlagSet<number, number> {
     }
 
     public union(first: number, second: number): number {
-        return first | second
+        return BitFlags.union(first, second)
     }
 
     public intersection(first: number, second: number): number {
-        return first & second
+        return BitFlags.intersection(first, second)
     }
 
     public difference(first: number, second: number): number {
-        return first & ~second
+        return BitFlags.difference(first, second)
     }
 
     public isSuperset(first: number, second: number): boolean {
-        return (first & second) === second
+        return BitFlags.isSuperset(first, second)
     }
 
     public hasAny(flags: number, required: number): boolean {
@@ -46,7 +87,7 @@ export class BitFlagSet implements FlagSet<number, number> {
     }
 
     public enumerate(flags: number): EnumerateFlags<number> {
-        return useIterator(flags, BitFlagsIterator)
+        return BitFlags.enumerate(flags)
     }
 
     public maximum(flags: number): number {

node/src/index.ts

@@ -6,6 +6,7 @@ export {
     Base64BitFlagSet,
     BigBitFlagSet,
     BitFlagSet,
+    BitFlags,
     CollectionFlagSet,
     FlagSet,
 } from './flagsets'

node/tests/flagsets/number.test.ts

@@ -1,4 +1,4 @@
-import { BitFlagSet, createBitFlagSet } from '~'
+import { BitFlags, BitFlagSet, createBitFlagSet } from '~'
 import { describe, expect, test } from 'vitest'
 
 describe(BitFlagSet, () => {
@@ -34,45 +34,37 @@ describe(BitFlagSet, () => {
     })
 
     test('union', () => {
-        const flags = createBitFlagSet([])
-
-        expect(flags.union(0, 0)).toEqual(0)
-        expect(flags.union(1, 0)).toEqual(1)
-        expect(flags.union(0, 2)).toEqual(2)
-        expect(flags.union(1, 2)).toEqual(3)
-        expect(flags.union(3, 6)).toEqual(7)
+        expect(BitFlags.union(0, 0)).toEqual(0)
+        expect(BitFlags.union(1, 0)).toEqual(1)
+        expect(BitFlags.union(0, 2)).toEqual(2)
+        expect(BitFlags.union(1, 2)).toEqual(3)
+        expect(BitFlags.union(3, 6)).toEqual(7)
     })
 
     test('difference', () => {
-        const flags = createBitFlagSet([])
-
-        expect(flags.difference(0, 0)).toEqual(0)
-        expect(flags.difference(1, 0)).toEqual(1)
-        expect(flags.difference(3, 6)).toEqual(1)
-        expect(flags.difference(6, 3)).toEqual(4)
-        expect(flags.difference(8, 17)).toEqual(8)
+        expect(BitFlags.difference(0, 0)).toEqual(0)
+        expect(BitFlags.difference(1, 0)).toEqual(1)
+        expect(BitFlags.difference(3, 6)).toEqual(1)
+        expect(BitFlags.difference(6, 3)).toEqual(4)
+        expect(BitFlags.difference(8, 17)).toEqual(8)
     })
 
     test('intersection', () => {
-        const flags = createBitFlagSet([])
-
-        expect(flags.intersection(0, 0)).toEqual(0)
-        expect(flags.intersection(1, 0)).toEqual(0)
-        expect(flags.intersection(1, 2)).toEqual(0)
-        expect(flags.intersection(1, 3)).toEqual(1)
-        expect(flags.intersection(11, 5)).toEqual(1)
-        expect(flags.intersection(11, 7)).toEqual(3)
+        expect(BitFlags.intersection(0, 0)).toEqual(0)
+        expect(BitFlags.intersection(1, 0)).toEqual(0)
+        expect(BitFlags.intersection(1, 2)).toEqual(0)
+        expect(BitFlags.intersection(1, 3)).toEqual(1)
+        expect(BitFlags.intersection(11, 5)).toEqual(1)
+        expect(BitFlags.intersection(11, 7)).toEqual(3)
     })
 
     test('isSuperset', () => {
-        const flags = createBitFlagSet([])
-
-        expect(flags.isSuperset(0, 0)).toBe(true)
-        expect(flags.isSuperset(3, 0)).toBe(true)
-        expect(flags.isSuperset(3, 1)).toBe(true)
-        expect(flags.isSuperset(3, 3)).toBe(true)
-        expect(flags.isSuperset(0, 3)).toBe(false)
-        expect(flags.isSuperset(8, 4)).toBe(false)
+        expect(BitFlags.isSuperset(0, 0)).toBe(true)
+        expect(BitFlags.isSuperset(3, 0)).toBe(true)
+        expect(BitFlags.isSuperset(3, 1)).toBe(true)
+        expect(BitFlags.isSuperset(3, 3)).toBe(true)
+        expect(BitFlags.isSuperset(0, 3)).toBe(false)
+        expect(BitFlags.isSuperset(8, 4)).toBe(false)
     })
 
     test('hasAny', () => {
@@ -108,14 +100,12 @@ describe(BitFlagSet, () => {
     })
 
     test('enumerate', () => {
-        const flags = createBitFlagSet([])
-
-        expect([...flags.enumerate(0)]).toEqual([])
-        expect([...flags.enumerate(1)]).toEqual([1])
-        expect([...flags.enumerate(2)]).toEqual([2])
-        expect([...flags.enumerate(3)]).toEqual([1, 2])
-        expect([...flags.enumerate(11)]).toEqual([1, 2, 8])
-        expect([...flags.enumerate(100)]).toEqual([4, 32, 64])
+        expect([...BitFlags.enumerate(0)]).toEqual([])
+        expect([...BitFlags.enumerate(1)]).toEqual([1])
+        expect([...BitFlags.enumerate(2)]).toEqual([2])
+        expect([...BitFlags.enumerate(3)]).toEqual([1, 2])
+        expect([...BitFlags.enumerate(11)]).toEqual([1, 2, 8])
+        expect([...BitFlags.enumerate(100)]).toEqual([4, 32, 64])
     })
 
     test('maximum', () => {