bit-sequence 1.1.0 → 1.2.0

package/.github/dependabot.yml

@@ -0,0 +1,29 @@
+version: 2
+updates:
+  - package-ecosystem: 'github-actions'
+    directory: '/'
+    schedule:
+      interval: 'daily'
+    commit-message:
+      prefix: 'chore'
+      include: 'scope'
+    cooldown:
+      default-days: 5
+  - package-ecosystem: 'npm'
+    directory: '/'
+    schedule:
+      interval: 'daily'
+    commit-message:
+      prefix: 'chore'
+      include: 'scope'
+    cooldown:
+      default-days: 5
+  - package-ecosystem: 'gomod'
+    directory: '/go'
+    schedule:
+      interval: 'daily'
+    commit-message:
+      prefix: 'chore'
+      include: 'scope'
+    cooldown:
+      default-days: 5

package/.github/workflows/go.yml

@@ -0,0 +1,47 @@
+name: Go CI
+on: [push, pull_request]
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [macos-latest, ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    defaults:
+      run:
+        working-directory: go
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v6
+      - name: Setup Go
+        uses: actions/setup-go@v6
+        with:
+          go-version: '1.25'
+          cache-dependency-path: go/go.mod
+      - name: Run tests
+        run: go test -v ./...
+      - name: Vet
+        run: go vet ./...
+      - name: Check formatting
+        if: runner.os != 'Windows'
+        run: |
+          test -z "$(gofmt -l .)" || (gofmt -d . && exit 1)
+
+  staticcheck:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: go
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v6
+      - name: Setup Go
+        uses: actions/setup-go@v6
+        with:
+          go-version: '1.25'
+          cache-dependency-path: go/go.mod
+      - name: Install staticcheck
+        run: go install honnef.co/go/tools/cmd/staticcheck@latest
+      - name: Run staticcheck
+        run: staticcheck ./...

package/.github/workflows/test-and-release.yml

@@ -0,0 +1,56 @@
+name: Test & Maybe Release
+on: [push, pull_request]
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        node: [lts/*, current]
+        os: [macos-latest, ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v6
+      - name: Use Node.js ${{ matrix.node }}
+        uses: actions/setup-node@v6
+        with:
+          node-version: ${{ matrix.node }}
+      - name: Install Dependencies
+        run: npm install --no-progress
+      - name: Check build is up to date
+        run: |
+          npm run build
+          git diff --exit-code || (echo "::error::Build artifacts not committed. Run 'npm run build' and commit the changes." && exit 1)
+      - name: Run tests
+        run: npm test
+
+  release:
+    name: Release
+    needs: [test]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+      id-token: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: lts/*
+          registry-url: 'https://registry.npmjs.org'
+      - name: Install dependencies
+        run: npm install --no-progress --no-package-lock --no-save
+      - name: Build
+        run: npm run build
+      - name: Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_CONFIG_PROVENANCE: true
+        run: npx semantic-release

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+## [1.2.0](https://github.com/rvagg/bit-sequence/compare/v1.1.0...v1.2.0) (2026-02-16)
+
+### Features
+
+* dep & CI updates & minor modernisation ([d37d229](https://github.com/rvagg/bit-sequence/commit/d37d229fea152b35e0329af0304bf9abb502abd7))
+
+### Trivial Changes
+
+* **deps:** bump actions/setup-go from 5 to 6 ([#3](https://github.com/rvagg/bit-sequence/issues/3)) ([8786d6d](https://github.com/rvagg/bit-sequence/commit/8786d6d92408d6ffe069eae6b5cd8bb00c4d2919))

package/README.md

@@ -1,6 +1,8 @@
 # bit-sequence
 
-**Turn an arbitrary sequence of bits from a byte array and turn it into an integer**
+[![NPM](https://nodei.co/npm/bit-sequence.svg?style=flat&data=n,v&color=blue)](https://nodei.co/npm/bit-sequence/)
+
+**Turn an arbitrary sequence of bits from a byte array into an integer**
 
 * [JavaScript](#javascript)
   * [Example](#example)
@@ -8,9 +10,11 @@
 * [Go](#go)
 * [License and Copyright](#license-and-copyright)
 
-## JavaScript
+## Requirements
 
-[![NPM](https://nodei.co/npm/bit-sequence.svg)](https://nodei.co/npm/bit-sequence/)
+Node.js >= 20
+
+## JavaScript
 
 Given an `Array`-like containing bytes (unsigned 8-bit integers), extract an arbitrary sequence of the underlying bits and convert them into an unsigned integer value.
 
@@ -19,8 +23,8 @@ Useful for cases where a sub-sequence of bits within a longer byte sequence is u
 ### Example
 
 ```js
-const bitSequence = require('bit-sequence')
-const assert = require('assert')
+import bitSequence from 'bit-sequence'
+import assert from 'node:assert'
 const bytes = new Uint8Array([ 0b00010101, 0b10101000, 0b00000000, 0b00000000 ])
 //               extract bits from here ^         to here ^
 const int = bitSequence(bytes, 7, 11)

package/go/go.mod

@@ -1,3 +1,3 @@
 module github.com/rvagg/bit-sequence/go
 
-go 1.12
+go 1.25

package/js/bit-sequence.js

@@ -4,7 +4,7 @@
  * @param {number} bitLength
  * @returns {number}
  */
-function bitSequence (bytes, bitStart, bitLength) {
+export default function bitSequence (bytes, bitStart, bitLength) {
   // making an assumption that bytes is an Array-like that will give us one
   // byte per element, so either an Array full of 8-bit integers or a
   // Uint8Array or a Node.js Buffer, or something like that
@@ -54,5 +54,3 @@ function bitSequence (bytes, bitStart, bitLength) {
 
   return result
 }
-
-module.exports = bitSequence

package/js/test.js

@@ -1,5 +1,6 @@
-const assert = require('assert')
-const bitSequence = require('./bit-sequence.js')
+import { test } from 'node:test'
+import assert from 'node:assert'
+import bitSequence from './bit-sequence.js'
 
 function binaryStringToBytes (s) {
   const byteLength = Math.ceil(s.length / 8)
@@ -11,104 +12,92 @@ function binaryStringToBytes (s) {
   return bytes
 }
 
-// sanity check binaryStringToBytes
-;[
-  '00000001:01',
-  '10000000:80',
-  '11111111:ff',
-  '11000000:c0',
-  '11110000:f0',
-  '1111111111111111:ffff',
-  '0000000000000001:0001',
-  '000000000000000000000001:000001',
-  '111111111111111111111111:ffffff',
-  '100000001000000010000000:808080',
-  '10000000100000001000000010000000:80808080',
-  '10000000111111111000000011111111:80ff80ff',
-  '001:01',
-  '111:07',
-  '1111:0f',
-  '01111:0f',
-  '001111:0f',
-  '0000001111:000f',
-  '10000000000001111:01000f'
-].forEach((s) => {
-  const [ binary, hex ] = s.split(':')
-  const bytesHex = Array.prototype.map.call(
-    binaryStringToBytes(binary),
-    (b) => b.toString(16).padStart(2, '0')
-  ).join('')
-  // console.log(binary, '=>', binaryStringToBytes(binary).toString('hex'), '<>', hex, '?', parseInt(binary, 2).toString(16))
-  assert.strictEqual(bytesHex, hex)
-  // sanity check the sanity check by reading the binary
-  assert.strictEqual(bytesHex.replace(/^0+/, ''), parseInt(binary, 2).toString(16))
+test('binaryStringToBytes sanity check', () => {
+  ;[
+    '00000001:01',
+    '10000000:80',
+    '11111111:ff',
+    '11000000:c0',
+    '11110000:f0',
+    '1111111111111111:ffff',
+    '0000000000000001:0001',
+    '000000000000000000000001:000001',
+    '111111111111111111111111:ffffff',
+    '100000001000000010000000:808080',
+    '10000000100000001000000010000000:80808080',
+    '10000000111111111000000011111111:80ff80ff',
+    '001:01',
+    '111:07',
+    '1111:0f',
+    '01111:0f',
+    '001111:0f',
+    '0000001111:000f',
+    '10000000000001111:01000f'
+  ].forEach((s) => {
+    const [binary, hex] = s.split(':')
+    const bytesHex = Array.prototype.map.call(
+      binaryStringToBytes(binary),
+      (b) => b.toString(16).padStart(2, '0')
+    ).join('')
+    assert.strictEqual(bytesHex, hex)
+    assert.strictEqual(bytesHex.replace(/^0+/, ''), parseInt(binary, 2).toString(16))
+  })
 })
 
-const testCases = [
-  '00000001',
-  '11111111',
-  '01010101',
-  '10001000',
-  '0000000000000001',
-  '0000000100000001',
-  '1111111111111111',
-  '1010101010101010',
-  '0101010101010101',
-  '1001001001001001',
-  '0100100100100100',
-  '1000100010001000',
-  '0100010001000100',
-  '1111111100000000',
-  '0000000011111111',
-  '0000111111110000',
-  '000000000000000000000001',
-  '111111111111111111111111',
-  '001001100100110010011111',
-  '00000000000000000000000000000001',
-  '11111111111111111111111111111111',
-  '10000000000000000000000000000001',
-  '10001100010110011110001010111010',
-  '1111111111111111111111111111111111111111111111111111111111111111',
-  '0000000000000000000000000000000000000000000000000000000000000001',
-  '1000000000000000000000000000000000000000000000000000000000000001',
-  '1010110100111110101110101001010001000000001101011101110010011111',
-  '11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111',
-  '1111101000010110000011111100000101110000010110111001100000000000',
-  '10010101000110001000101011111111101000010110000011111100000101110000010110111001111000011001000000001000111101010010101001110000'
-]
+test('bitSequence extracts correct bit sequences', () => {
+  const testCases = [
+    '00000001',
+    '11111111',
+    '01010101',
+    '10001000',
+    '0000000000000001',
+    '0000000100000001',
+    '1111111111111111',
+    '1010101010101010',
+    '0101010101010101',
+    '1001001001001001',
+    '0100100100100100',
+    '1000100010001000',
+    '0100010001000100',
+    '1111111100000000',
+    '0000000011111111',
+    '0000111111110000',
+    '000000000000000000000001',
+    '111111111111111111111111',
+    '001001100100110010011111',
+    '00000000000000000000000000000001',
+    '11111111111111111111111111111111',
+    '10000000000000000000000000000001',
+    '10001100010110011110001010111010',
+    '1111111111111111111111111111111111111111111111111111111111111111',
+    '0000000000000000000000000000000000000000000000000000000000000001',
+    '1000000000000000000000000000000000000000000000000000000000000001',
+    '1010110100111110101110101001010001000000001101011101110010011111',
+    '11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111',
+    '1111101000010110000011111100000101110000010110111001100000000000',
+    '10010101000110001000101011111111101000010110000011111100000101110000010110111001111000011001000000001000111101010010101001110000'
+  ]
 
-let makeFixture = false
-if (process.argv[2] == '--fixture') {
-  makeFixture = true
-}
-let asserts = 0
-let tooBig = 0
-testCases.forEach((s) => {
-  const bytes = binaryStringToBytes(s)
+  let asserts = 0
+  let tooBig = 0
+  testCases.forEach((s) => {
+    const bytes = binaryStringToBytes(s)
 
-  for (let start = 0; start < bytes.length * 8; start++) {
-    for (let length = 1; length <= bytes.length * 8 - start; length++) {
-      const expected = parseInt(s.substring(start, start + length), 2)
-      if (makeFixture && length <= 32) {
-        console.log([
-          Buffer.from(binaryStringToBytes(s)).toString('hex'),
-          start,
-          length,
-          expected
-        ].join(','))
-      }
-      const actual = bitSequence(bytes, start, length)
-      if (actual != expected && actual > Number.MAX_SAFE_INTEGER) {
-        tooBig++
-        continue
+    for (let start = 0; start < bytes.length * 8; start++) {
+      for (let length = 1; length <= bytes.length * 8 - start; length++) {
+        const expected = parseInt(s.substring(start, start + length), 2)
+        const actual = bitSequence(bytes, start, length)
+        if (actual !== expected && actual > Number.MAX_SAFE_INTEGER) {
+          tooBig++
+          continue
+        }
+        asserts++
+        assert.strictEqual(actual, expected, `[${s}] start=${start} length=${length} ${actual} <> ${expected}`)
+        assert.ok(actual >= 0, 'sanity check that we\'re only dealing with unsigned integers')
       }
-      // console.log(`[${s}] start=${start} length=${length} ${actual} <> ${expected}`)
-      asserts++
-      assert.strictEqual(actual, expected, `[${s}] start=${start} length=${length} ${actual} <> ${expected}`)
-      assert.ok(actual >= 0, 'sanity check that we\'re only dealing with unsigned integers')
     }
-  }
-})
+  })
 
-assert.ok(asserts > 10000, 'did a lot of asserts')
-assert.ok(tooBig < 200, 'not too many non-matches beyond MAX_SAFE_INTEGER')
+  assert.ok(asserts > 10000, 'did a lot of asserts')
+  assert.ok(tooBig < 200, 'not too many non-matches beyond MAX_SAFE_INTEGER')
+})

package/package.json

@@ -1,16 +1,133 @@
 {
   "name": "bit-sequence",
-  "version": "1.1.0",
-  "description": "Turn an arbitrary sequence of bits from a byte array and turn it into an integer",
+  "version": "1.2.0",
+  "description": "Turn an arbitrary sequence of bits from a byte array into an integer",
+  "type": "module",
   "main": "js/bit-sequence.js",
-  "types": "js/bit-sequence.d.ts",
+  "types": "types/bit-sequence.d.ts",
+  "exports": {
+    ".": {
+      "import": "./js/bit-sequence.js",
+      "types": "./types/bit-sequence.d.ts"
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
   "scripts": {
-    "test": "node js/test.js"
+    "lint": "standard js/*.js",
+    "build": "npm run build:types",
+    "build:types": "tsc --build",
+    "test:unit": "node --test js/test.js",
+    "test": "npm run lint && npm run build:types && npm run test:unit"
   },
   "author": "Rod <rod@vagg.org> (http://r.va.gg/)",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "git://github.com/rvagg/bit-sequence.git"
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.6",
+    "@semantic-release/npm": "^13.1.4",
+    "@semantic-release/release-notes-generator": "^14.1.0",
+    "conventional-changelog-conventionalcommits": "^9.1.0",
+    "semantic-release": "^25.0.3",
+    "standard": "^17.1.2",
+    "typescript": "^5.9.3"
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "types/*"
+      ],
+      "types/*": [
+        "types/*"
+      ]
+    }
+  },
+  "release": {
+    "branches": [
+      "master"
+    ],
+    "plugins": [
+      [
+        "@semantic-release/commit-analyzer",
+        {
+          "preset": "conventionalcommits",
+          "releaseRules": [
+            {
+              "breaking": true,
+              "release": "major"
+            },
+            {
+              "revert": true,
+              "release": "patch"
+            },
+            {
+              "type": "feat",
+              "release": "minor"
+            },
+            {
+              "type": "fix",
+              "release": "patch"
+            },
+            {
+              "type": "chore",
+              "release": "patch"
+            },
+            {
+              "type": "docs",
+              "release": "patch"
+            },
+            {
+              "type": "test",
+              "release": "patch"
+            },
+            {
+              "scope": "no-release",
+              "release": false
+            }
+          ]
+        }
+      ],
+      [
+        "@semantic-release/release-notes-generator",
+        {
+          "preset": "conventionalcommits",
+          "presetConfig": {
+            "types": [
+              {
+                "type": "feat",
+                "section": "Features"
+              },
+              {
+                "type": "fix",
+                "section": "Bug Fixes"
+              },
+              {
+                "type": "chore",
+                "section": "Trivial Changes"
+              },
+              {
+                "type": "docs",
+                "section": "Trivial Changes"
+              },
+              {
+                "type": "test",
+                "section": "Tests"
+              }
+            ]
+          }
+        }
+      ],
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      "@semantic-release/git"
+    ]
   }
 }

package/tsconfig.json

@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": true,
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitReturns": false,
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "strictFunctionTypes": false,
+    "strictNullChecks": true,
+    "strictPropertyInitialization": true,
+    "strictBindCallApply": true,
+    "strict": true,
+    "alwaysStrict": true,
+    "esModuleInterop": true,
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "types",
+    "skipLibCheck": true,
+    "stripInternal": true,
+    "emitDeclarationOnly": true,
+    "baseUrl": "."
+  },
+  "include": [
+    "js/bit-sequence.js"
+  ],
+  "exclude": [
+    "node_modules",
+    "types/*"
+  ]
+}

package/types/bit-sequence.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {Uint8Array} bytes
+ * @param {number} bitStart
+ * @param {number} bitLength
+ * @returns {number}
+ */
+export default function bitSequence(bytes: Uint8Array, bitStart: number, bitLength: number): number;
+//# sourceMappingURL=bit-sequence.d.ts.map

package/types/bit-sequence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bit-sequence.d.ts","sourceRoot":"","sources":["../js/bit-sequence.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,2CALW,UAAU,YACV,MAAM,aACN,MAAM,GACJ,MAAM,CAmDlB"}

package/types/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../js/bit-sequence.js"],"version":"5.9.3"}

package/.travis.yml

@@ -1,19 +0,0 @@
-language: node_js
-matrix:
-  include:
-    - name: "Node.js 8"
-      node_js: 8
-    - name: "Node.js 10"
-      node_js: 10
-    - name: "Node.js 12"
-      node_js: 12
-    - name: "Node.js current"
-      node_js: "node"
-    - name: "Node.js LTS"
-      node_js: "lts/*"
-    - name: "Go"
-      language: go
-      go: 1.x
-      script: cd go && go test
-script:
-  - npm test

package/js/bit-sequence.d.ts

@@ -1,9 +0,0 @@
-export = bitSequence;
-/**
- * @param {Uint8Array} bytes
- * @param {number} bitStart
- * @param {number} bitLength
- * @returns {number}
- */
-declare function bitSequence(bytes: Uint8Array, bitStart: number, bitLength: number): number;
-//# sourceMappingURL=bit-sequence.d.ts.map

package/js/bit-sequence.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bit-sequence.d.ts","sourceRoot":"","sources":["./bit-sequence.js"],"names":[],"mappings":";AAAA;;;;;GAKG;AACH,oCALW,UAAU,YACV,MAAM,aACN,MAAM,GACJ,MAAM,CAmDlB"}