iso-signatures 0.0.1

package/dist/src/asn1.d.ts

@@ -0,0 +1,31 @@
+export const INT_TAG: 2;
+export const BITSTRING_TAG: 3;
+export const OCTET_STRING_TAG: 4;
+export const NULL_TAG: 5;
+export const OBJECT_TAG: 6;
+export const SEQUENCE_TAG: 48;
+export const UNUSED_BIT_PAD: 0;
+export function encodeDERLength(length: number): Uint8Array;
+export function readDERLength(bytes: Uint8Array, offset?: number): {
+    number: number;
+    consumed: number;
+};
+export function skip(input: Uint8Array, expectedTag: number, position: number): number;
+export function into(input: Uint8Array, expectedTag: number, offset: number): {
+    position: number;
+    length: number;
+};
+export function encodeBitString(input: Uint8Array): Uint8Array;
+export function encodeOctetString(input: Uint8Array): Uint8Array;
+export function encodeSequence(sequence: Uint8Array[]): Uint8Array;
+export function readSequence(bytes: Uint8Array, offset?: number): Uint8Array;
+export function encodeInt(input: Uint8Array): Uint8Array;
+export function enterSequence(bytes: Uint8Array, offset?: number): number;
+export function skipSequence(bytes: Uint8Array, offset?: number): number;
+export function skipInt(bytes: Uint8Array, offset?: number): number;
+export function readBitString(bytes: Uint8Array, offset?: number): Uint8Array;
+export function readInt(bytes: Uint8Array, byteOffset?: number): Uint8Array;
+export function readOctetString(bytes: Uint8Array, offset?: number): Uint8Array;
+export function readSequenceWith(readers: [Reader, ...Reader[]], source: Uint8Array, byteOffset?: number): Uint8Array[];
+export type Reader = (bytes: Uint8Array, offset: number) => Uint8Array;
+//# sourceMappingURL=asn1.d.ts.map

package/dist/src/asn1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asn1.d.ts","sourceRoot":"","sources":["../../src/asn1.js"],"names":[],"mappings":"AAIA,wBAA2B;AAC3B,8BAAiC;AACjC,iCAAoC;AACpC,yBAA4B;AAC5B,2BAA8B;AAC9B,8BAAgC;AAEhC,+BAAkC;AAM3B,wCAHI,MAAM,GACJ,UAAU,CAetB;AAOM,qCAJI,UAAU,WACV,MAAM,GACJ;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAsB9C;AAQM,4BALI,UAAU,eACV,MAAM,YACN,MAAM,GACJ,MAAM,CAKlB;AAQM,4BALI,UAAU,eACV,MAAM,UACN,MAAM;cACQ,MAAM;YAAU,MAAM;EAmB9C;AAKM,uCAFI,UAAU,cA8BpB;AAKM,yCAFI,UAAU,cAqBpB;AAKM,yCAFI,UAAU,EAAE,cAgCtB;AAMM,oCAHI,UAAU,WACV,MAAM,cAMhB;AAKM,iCAFI,UAAU,cAkCpB;AAQM,qCALI,UAAU,WACV,MAAM,GACJ,MAAM,CAIyB;AAOrC,oCAJI,UAAU,WACV,MAAM,GACJ,MAAM,CAGgB;AAO5B,+BAJI,UAAU,WACV,MAAM,GACJ,MAAM,CAEuD;AAOnE,qCAJI,UAAU,WACV,MAAM,GACJ,UAAU,CAiBtB;AAOM,+BAJI,UAAU,eACV,MAAM,GACJ,UAAU,CAgBtB;AAOM,uCAJI,UAAU,WACV,MAAM,GACJ,UAAU,CAMtB;AAQM,0CAJI,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,UACrB,UAAU,eACV,MAAM,gBAYhB;6BAfmB,UAAU,UAAS,MAAM,KAAK,UAAU"}

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":""}

package/dist/src/spki.d.ts

@@ -0,0 +1,14 @@
+export namespace spki {
+    export { encode };
+    export { decode };
+}
+/**
+ * @param {Uint8Array} key
+ */
+declare function encode(key: Uint8Array): Uint8Array;
+/**
+ * @param {Uint8Array} info
+ */
+declare function decode(info: Uint8Array): Uint8Array;
+export {};
+//# sourceMappingURL=spki.d.ts.map

package/dist/src/spki.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spki.d.ts","sourceRoot":"","sources":["../../src/spki.js"],"names":[],"mappings":";;;;AAgBA;;GAEG;AACH,6BAFW,UAAU,cAIpB;AAED;;GAEG;AACH,8BAFW,UAAU,cAUpB"}

package/dist/src/types.d.ts

@@ -0,0 +1,63 @@
+import type { DIDKey } from 'iso-did/key';
+import type { SignatureAlgorithm, KeyType } from 'iso-did/types';
+export interface ISigner<Export extends CryptoKeyPair | string> {
+    /**
+     * JWT signing algorithm
+     */
+    alg: SignatureAlgorithm;
+    /**
+     * Keypair type
+     */
+    type: KeyType;
+    /**
+     * Multicodec identifier for the private key
+     */
+    code?: number;
+    did: DIDKey;
+    /**
+     * Sign a message
+     */
+    sign: (message: Uint8Array) => Promise<Uint8Array>;
+    export: () => Export;
+}
+export interface VerifyInput {
+    signature: Uint8Array;
+    message: Uint8Array;
+    publicKey: Uint8Array;
+}
+export type Verify = (input: VerifyInput) => Promise<boolean>;
+export type Verifier<T extends SignatureAlgorithm> = Record<T, Verify>;
+export type VerifierRegistry<T extends SignatureAlgorithm> = Partial<Verifier<T>>;
+export interface ResolverVerifyInput extends VerifyInput {
+    alg: SignatureAlgorithm;
+}
+export type Cache = (parsed: VerifyInput, verify: Verify) => Promise<boolean>;
+export interface IResolver {
+    verify: (input: ResolverVerifyInput) => Promise<boolean>;
+}
+export interface ResolverOptions {
+    cache?: Cache | boolean | undefined;
+}
+export interface PublicKeyJwk {
+    kty: string;
+    crv: string;
+    x: string;
+    y: string;
+}
+export interface PublicKeyRSAJwk {
+    kty: string;
+    n: string;
+    e: string;
+}
+export interface PrivateKeyRSAJwk extends PublicKeyRSAJwk {
+    d: string;
+    p: string;
+    q: string;
+    dp: string;
+    dq: string;
+    qi: string;
+}
+export type PrivateKeyJwk = PublicKeyJwk & {
+    d: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,KAAK,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAEhE,MAAM,WAAW,OAAO,CAAC,MAAM,SAAS,aAAa,GAAG,MAAM;IAC5D;;OAEG;IACH,GAAG,EAAE,kBAAkB,CAAA;IACvB;;OAEG;IACH,IAAI,EAAE,OAAO,CAAA;IACb;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IAEb,GAAG,EAAE,MAAM,CAAA;IACX;;OAEG;IACH,IAAI,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,CAAA;IAElD,MAAM,EAAE,MAAM,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,UAAU,CAAA;IACrB,OAAO,EAAE,UAAU,CAAA;IACnB,SAAS,EAAE,UAAU,CAAA;CACtB;AACD,MAAM,MAAM,MAAM,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE7D,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,kBAAkB,IAAI,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;AAEtE,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,kBAAkB,IAAI,OAAO,CAClE,QAAQ,CAAC,CAAC,CAAC,CACZ,CAAA;AAED,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,GAAG,EAAE,kBAAkB,CAAA;CACxB;AACD,MAAM,MAAM,KAAK,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE7E,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CACzD;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,SAAS,CAAA;CACpC;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAA;IACX,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,gBAAiB,SAAQ,eAAe;IACvD,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;CACX;AAED,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG;IAAE,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA"}

package/dist/src/utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Create web crypto params for ECDSA.
+ *
+ * @param {import("iso-did/types").SignatureAlgorithm} alg
+ * @returns {{name: 'ECDSA', namedCurve: 'P-256' | 'P-384' | 'P-521', hash: 'SHA-256' | 'SHA-384' | 'SHA-512'}}
+ */
+export function createEcdsaParams(alg: import("iso-did/types").SignatureAlgorithm): {
+    name: 'ECDSA';
+    namedCurve: 'P-256' | 'P-384' | 'P-521';
+    hash: 'SHA-256' | 'SHA-384' | 'SHA-512';
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,uCAHW,OAAO,eAAe,EAAE,kBAAkB,GACxC;IAAC,MAAM,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;IAAC,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAA;CAAC,CA8B7G"}

package/package.json

@@ -0,0 +1,138 @@
+{
+  "name": "iso-signatures",
+  "version": "0.0.1",
+  "description": "Signatures tooling.",
+  "author": "Hugo Dias <hugomrdias@gmail.com> (hugodias.me)",
+  "license": "MIT",
+  "repository": {
+    "url": "hugomrdias/iso-repo",
+    "directory": "packages/iso-signatures"
+  },
+  "homepage": "https://github.com/hugomrdias/iso-repo/tree/main/packages/iso-signatures",
+  "keywords": [
+    "elliptic",
+    "curve",
+    "cryptography",
+    "edwards",
+    "p256",
+    "p384",
+    "p521",
+    "secp256r1",
+    "secp256k1",
+    "ed25519",
+    "ecdsa",
+    "eddsa",
+    "rsa",
+    "signatures"
+  ],
+  "type": "module",
+  "main": "src/index.js",
+  "types": "dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./signers/ecdsa": {
+      "types": "./dist/src/signers/ecdsa.d.ts",
+      "import": "./src/signers/ecdsa.js"
+    },
+    "./signers/eddsa": {
+      "types": "./dist/src/signers/eddsa.d.ts",
+      "import": "./src/signers/eddsa.js"
+    },
+    "./signers/rsa-old": {
+      "types": "./dist/src/signers/rsa-old.d.ts",
+      "import": "./src/signers/rsa-old.js"
+    },
+    "./signers/rsa": {
+      "types": "./dist/src/signers/rsa.d.ts",
+      "import": "./src/signers/rsa.js"
+    },
+    "./verifiers/ecdsa": {
+      "types": "./dist/src/verifiers/ecdsa.d.ts",
+      "import": "./src/verifiers/ecdsa.js"
+    },
+    "./verifiers/eddsa": {
+      "types": "./dist/src/verifiers/eddsa.d.ts",
+      "import": "./src/verifiers/eddsa.js"
+    },
+    "./verifiers/rsa-old": {
+      "types": "./dist/src/verifiers/rsa-old.d.ts",
+      "import": "./src/verifiers/rsa-old.js"
+    },
+    "./verifiers/rsa": {
+      "types": "./dist/src/verifiers/rsa.d.ts",
+      "import": "./src/verifiers/rsa.js"
+    },
+    "./verifiers/resolver": {
+      "types": "./dist/src/verifiers/resolver.d.ts",
+      "import": "./src/verifiers/resolver.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "dist/src/index"
+      ],
+      "signers/*": [
+        "dist/src/signers/*"
+      ],
+      "verifiers/*": [
+        "dist/src/verifiers/*"
+      ]
+    }
+  },
+  "files": [
+    "src",
+    "dist/src/*.d.ts",
+    "dist/src/*.d.ts.map"
+  ],
+  "dependencies": {
+    "@noble/ed25519": "^2.0.0",
+    "iso-base": "^1.0.0",
+    "iso-did": "^1.3.0"
+  },
+  "devDependencies": {
+    "@types/assert": "^1.5.6",
+    "@types/mocha": "^10.0.1",
+    "@types/node": "^20.3.1",
+    "assert": "^2.0.0",
+    "hd-scripts": "^7.0.0",
+    "mocha": "^10.2.0",
+    "playwright-test": "^9.2.0",
+    "type-fest": "^3.12.0",
+    "typescript": "5.1.3"
+  },
+  "eslintConfig": {
+    "extends": [
+      "../../node_modules/hd-scripts/eslint/index.js"
+    ],
+    "parserOptions": {
+      "project": "./tsconfig.json"
+    },
+    "env": {
+      "mocha": true
+    },
+    "ignorePatterns": [
+      "dist"
+    ]
+  },
+  "depcheck": {
+    "specials": [
+      "bin"
+    ],
+    "ignores": [
+      "@types/*",
+      "hd-scripts",
+      "assert",
+      "type-fest"
+    ]
+  },
+  "scripts": {
+    "lint": "tsc --build && eslint '**/*.{js,ts}' && prettier --check '**/*.{js,ts,yml,json}' --ignore-path ../../.gitignore",
+    "test": "tsc --build && pnpm run test:node && pnpm run test:browser",
+    "test:node": "mocha 'test/**/!(*.browser).test.js'",
+    "test:browser": "playwright-test 'test/**/!(*.node).test.js'"
+  }
+}

package/readme.md

@@ -0,0 +1,59 @@
+# iso-signatures [![NPM Version](https://img.shields.io/npm/v/iso-signatures.svg)](https://www.npmjs.com/package/iso-signatures) [![License](https://img.shields.io/npm/l/iso-signatures.svg)](https://github.com/hugomrdias/iso-repo/blob/main/license) [![iso-did](https://github.com/hugomrdias/iso-repo/actions/workflows/iso-signatures.yml/badge.svg)](https://github.com/hugomrdias/iso-repo/actions/workflows/iso-signatures.yml)
+
+> Isomorphic signatures tooling
+
+## Install
+
+```bash
+pnpm install iso-signatures
+```
+
+## Usage
+
+```js
+import { EdDSASigner } from 'iso-signatures/signers/eddsa'
+import * as EdDSA from 'iso-signatures/verifiers/eddsa'
+
+const message = new TextEncoder().encode('hello world')
+const resolver = new Resolver({
+  ...EdDSA.verifier,
+})
+const signer = await EdDSASigner.generate()
+const signature = await signer.sign(message)
+const verified = await resolver.verify({
+  signature,
+  message,
+  ...signer,
+})
+```
+
+```js
+import { EdDSASigner } from 'iso-signatures/signers/eddsa'
+import * as EdDSA from 'iso-signatures/verifiers/eddsa'
+import * as ECDSA from 'iso-signatures/verifiers/ecdsa'
+import * as RSA from 'iso-signatures/verifiers/rsa'
+
+const message = new TextEncoder().encode('hello world')
+const resolver = new Resolver(
+  {
+    ...ECDSA.verifier,
+    ...EdDSA.verifier,
+  },
+  { cache: true }
+)
+const signer = await EdDSASigner.generate()
+const signature = await signer.sign(message)
+const verified = await resolver.verify({
+  signature,
+  message,
+  ...signer.did, // Signer and DID both have `alg` property that the resolver uses to find the correct verifier
+})
+```
+
+## Docs
+
+Check <https://hugomrdias.github.io/iso-repo/modules/iso_signatures.html>
+
+## License
+
+MIT © [Hugo Dias](http://hugodias.me)

package/src/asn1.js

@@ -0,0 +1,329 @@
+/**
+ * ASN1 Tags as per https://luca.ntop.org/Teaching/Appunti/asn1.html
+ */
+const TAG_SIZE = 1
+export const INT_TAG = 0x02
+export const BITSTRING_TAG = 0x03
+export const OCTET_STRING_TAG = 0x04
+export const NULL_TAG = 0x05
+export const OBJECT_TAG = 0x06
+export const SEQUENCE_TAG = 0x30
+
+export const UNUSED_BIT_PAD = 0x00
+
+/**
+ * @param {number} length
+ * @returns {Uint8Array}
+ */
+export const encodeDERLength = (length) => {
+  if (length <= 127) {
+    return new Uint8Array([length])
+  }
+
+  /** @type {number[]} */
+  const octets = []
+  while (length !== 0) {
+    octets.push(length & 0xff)
+    length = length >>> 8
+  }
+  octets.reverse()
+  return new Uint8Array([0x80 | (octets.length & 0xff), ...octets])
+}
+
+/**
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ * @returns {{number: number, consumed: number}}
+ */
+export const readDERLength = (bytes, offset = 0) => {
+  if ((bytes[offset] & 0x80) === 0) {
+    return { number: bytes[offset], consumed: 1 }
+  }
+
+  const numberBytes = bytes[offset] & 0x7f
+  /* c8 ignore next 5 */
+  if (bytes.length < numberBytes + 1) {
+    throw new Error(
+      `ASN parsing error: Too few bytes. Expected encoded length's length to be at least ${numberBytes}`
+    )
+  }
+
+  let length = 0
+  for (let i = 0; i < numberBytes; i++) {
+    length = length << 8
+    length = length | bytes[offset + i + 1]
+  }
+
+  return { number: length, consumed: numberBytes + 1 }
+}
+
+/**
+ * @param {Uint8Array} input
+ * @param {number} expectedTag
+ * @param {number} position
+ * @returns {number}
+ */
+export const skip = (input, expectedTag, position) => {
+  const parsed = into(input, expectedTag, position)
+  return parsed.position + parsed.length
+}
+
+/**
+ * @param {Uint8Array} input
+ * @param {number} expectedTag
+ * @param {number} offset
+ * @returns {{ position: number, length: number }}
+ */
+export const into = (input, expectedTag, offset) => {
+  const actualTag = input[offset]
+  /* c8 ignore next 7 */
+  if (actualTag !== expectedTag) {
+    throw new Error(
+      `ASN parsing error: Expected tag 0x${expectedTag.toString(
+        16
+      )} at position ${offset}, but got 0x${actualTag.toString(16)}.`
+    )
+  }
+
+  // length
+  const length = readDERLength(input, offset + TAG_SIZE)
+  const position = offset + TAG_SIZE + length.consumed
+
+  // content
+  return { position, length: length.number }
+}
+
+/**
+ * @param {Uint8Array} input
+ */
+export const encodeBitString = (input) => {
+  // encode input length + 1 for unused bit pad
+  const length = encodeDERLength(input.byteLength + 1)
+  // allocate a buffer of desired size
+  const bytes = new Uint8Array(
+    TAG_SIZE + // ASN_BITSTRING_TAG
+      length.byteLength +
+      1 + // amount of unused bits at the end of our bitstring
+      input.byteLength
+  )
+
+  let byteOffset = 0
+  // write bytestring tag
+  bytes[byteOffset] = BITSTRING_TAG
+  byteOffset += TAG_SIZE
+
+  // write length of the bytestring
+  bytes.set(length, byteOffset)
+  byteOffset += length.byteLength
+
+  // write unused bits at the end of our bitstring
+  bytes[byteOffset] = UNUSED_BIT_PAD
+  byteOffset += 1
+
+  // write actual data into bitstring
+  bytes.set(input, byteOffset)
+
+  return bytes
+}
+
+/**
+ * @param {Uint8Array} input
+ */
+export const encodeOctetString = (input) => {
+  // encode input length
+  const length = encodeDERLength(input.byteLength)
+  // allocate a buffer of desired size
+  const bytes = new Uint8Array(TAG_SIZE + length.byteLength + input.byteLength)
+
+  let byteOffset = 0
+  // write octet string tag
+  bytes[byteOffset] = OCTET_STRING_TAG
+  byteOffset += TAG_SIZE
+
+  // write octet string length
+  bytes.set(length, byteOffset)
+  byteOffset += length.byteLength
+
+  // write actual data into bitstring
+  bytes.set(input, byteOffset)
+
+  return bytes
+}
+
+/**
+ * @param {Uint8Array[]} sequence
+ */
+export const encodeSequence = (sequence) => {
+  // calculate bytelength for all the parts
+  let byteLength = 0
+  for (const item of sequence) {
+    byteLength += item.byteLength
+  }
+
+  // encode sequence byte length
+  const length = encodeDERLength(byteLength)
+
+  // allocate the buffer to write sequence into
+  const bytes = new Uint8Array(TAG_SIZE + length.byteLength + byteLength)
+
+  let byteOffset = 0
+
+  // write the sequence tag
+  bytes[byteOffset] = SEQUENCE_TAG
+  byteOffset += TAG_SIZE
+
+  // write sequence length
+  bytes.set(length, byteOffset)
+  byteOffset += length.byteLength
+
+  // write each item in the sequence
+  for (const item of sequence) {
+    bytes.set(item, byteOffset)
+    byteOffset += item.byteLength
+  }
+
+  return bytes
+}
+
+/**
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ */
+export const readSequence = (bytes, offset = 0) => {
+  const { position, length } = into(bytes, SEQUENCE_TAG, offset)
+
+  return new Uint8Array(bytes.buffer, bytes.byteOffset + position, length)
+}
+
+/**
+ * @param {Uint8Array} input
+ */
+export const encodeInt = (input) => {
+  const extra = input.byteLength === 0 || input[0] & 0x80 ? 1 : 0
+
+  // encode input length
+  const length = encodeDERLength(input.byteLength + extra)
+  // allocate a buffer of desired size
+  const bytes = new Uint8Array(
+    TAG_SIZE + // INT_TAG
+      length.byteLength +
+      input.byteLength +
+      extra
+  )
+
+  let byteOffset = 0
+  // write octet string tag
+  bytes[byteOffset] = INT_TAG
+  byteOffset += TAG_SIZE
+
+  // write int length
+  bytes.set(length, byteOffset)
+  byteOffset += length.byteLength
+
+  // add 0 if the most-significant bit is set
+  if (extra > 0) {
+    bytes[byteOffset] = UNUSED_BIT_PAD
+    byteOffset += extra
+  }
+
+  // write actual data into bitstring
+  bytes.set(input, byteOffset)
+
+  return bytes
+}
+
+/**
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ * @returns {number}
+ */
+
+export const enterSequence = (bytes, offset = 0) =>
+  into(bytes, SEQUENCE_TAG, offset).position
+
+/**
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ * @returns {number}
+ */
+export const skipSequence = (bytes, offset = 0) =>
+  skip(bytes, SEQUENCE_TAG, offset)
+
+/**
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ * @returns {number}
+ */
+export const skipInt = (bytes, offset = 0) => skip(bytes, INT_TAG, offset)
+
+/**
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ * @returns {Uint8Array}
+ */
+export const readBitString = (bytes, offset = 0) => {
+  const { position, length } = into(bytes, BITSTRING_TAG, offset)
+  const tag = bytes[position]
+  /* c8 ignore next 5 */
+  if (tag !== UNUSED_BIT_PAD) {
+    throw new Error(
+      `Can not read bitstring, expected length to be multiple of 8, but got ${tag} unused bits in last byte.`
+    )
+  }
+
+  return new Uint8Array(
+    bytes.buffer,
+    bytes.byteOffset + position + 1,
+    length - 1
+  )
+}
+
+/**
+ * @param {Uint8Array} bytes
+ * @param {number} byteOffset
+ * @returns {Uint8Array}
+ */
+export const readInt = (bytes, byteOffset = 0) => {
+  const { position, length } = into(bytes, INT_TAG, byteOffset)
+  let delta = 0
+
+  // drop leading 0s
+  while (bytes[position + delta] === 0) {
+    delta++
+  }
+
+  return new Uint8Array(
+    bytes.buffer,
+    bytes.byteOffset + position + delta,
+    length - delta
+  )
+}
+
+/**
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ * @returns {Uint8Array}
+ */
+export const readOctetString = (bytes, offset = 0) => {
+  const { position, length } = into(bytes, OCTET_STRING_TAG, offset)
+
+  return new Uint8Array(bytes.buffer, bytes.byteOffset + position, length)
+}
+
+/**
+ * @typedef {(bytes:Uint8Array, offset:number) => Uint8Array} Reader
+ * @param {[Reader, ...Reader[]]} readers
+ * @param {Uint8Array} source
+ * @param {number} byteOffset
+ */
+export const readSequenceWith = (readers, source, byteOffset = 0) => {
+  const results = []
+  const sequence = readSequence(source, byteOffset)
+  let offset = 0
+  for (const read of readers) {
+    const chunk = read(sequence, offset)
+    results.push(chunk)
+    offset = chunk.byteOffset + chunk.byteLength - sequence.byteOffset
+  }
+  return results
+}

package/src/index.js

@@ -0,0 +1 @@
+throw new Error('Incorrect "iso-signatures" usage. Import submodules instead')