asn-blocklist 1.20260703.0

package/lib/runtime.cjs

@@ -0,0 +1,239 @@
+"use strict";
+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/entries/runtime.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  classifyWithSets: () => classifyWithSets,
+  createASNSet: () => createASNSet,
+  createEFSet: () => createEFSet,
+  createGRSet: () => createGRSet,
+  normalizeASN: () => normalizeASN
+});
+module.exports = __toCommonJS(runtime_exports);
+
+// src/runtime/base64.ts
+function toUint8Array(data) {
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(data, "base64"));
+  }
+  const decoded = atob(data);
+  const bytes = new Uint8Array(decoded.length);
+  for (let i = 0; i < decoded.length; i++) {
+    bytes[i] = decoded.charCodeAt(i);
+  }
+  return bytes;
+}
+function bitAt(bytes, bitPosition) {
+  return bytes[bitPosition >> 3] >> 7 - (bitPosition & 7) & 1;
+}
+
+// src/runtime/header.ts
+function dataView(bytes) {
+  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function readCommonHeader(bytes) {
+  if (bytes.byteLength < 14) {
+    throw new Error("ASN dataset is too short to contain a valid header");
+  }
+  const view = dataView(bytes);
+  return {
+    offset: view.getUint32(0, true),
+    count: view.getUint32(4, true),
+    range: view.getUint32(8, true),
+    k: view.getUint8(12),
+    l: view.getUint8(13)
+  };
+}
+function metadataFromHeader(header, kind, encoding) {
+  return {
+    kind,
+    encoding,
+    offset: header.offset,
+    count: header.count,
+    range: header.range,
+    minASN: header.offset,
+    maxASN: header.offset + header.range - 1
+  };
+}
+function detectEncoding(header) {
+  if (header.k > 0 && header.l === 0) return "gr";
+  if (header.k === 0 && header.l > 0) return "ef";
+  throw new Error("Unable to detect ASN dataset encoding");
+}
+
+// src/runtime/normalize.ts
+function normalizeASN(input) {
+  if (typeof input === "number") {
+    return Number.isSafeInteger(input) && input > 0 ? input : null;
+  }
+  const value = String(input).trim();
+  const match = /^(?:AS)?(\d+)$/i.exec(value);
+  if (!match) return null;
+  const asn = Number(match[1]);
+  return Number.isSafeInteger(asn) && asn > 0 ? asn : null;
+}
+
+// src/runtime/ef.ts
+function readEFSubHeader(bytes) {
+  if (bytes.byteLength < 28) {
+    throw new Error("ASN EF dataset is too short to contain a valid sub-header");
+  }
+  const view = dataView(bytes);
+  return {
+    lowOffset: view.getUint32(14, true),
+    highOffset: view.getUint32(18, true),
+    selectOffset: view.getUint32(22, true),
+    selectStep: view.getUint16(26, true)
+  };
+}
+function createEFSet(data, options = {}) {
+  const bytes = toUint8Array(data);
+  const header = readCommonHeader(bytes);
+  if (header.l === 0) {
+    throw new Error("ASN dataset is not Elias-Fano encoded");
+  }
+  const view = dataView(bytes);
+  const sub = readEFSubHeader(bytes);
+  const lowMask = (1 << header.l) - 1;
+  const kind = options.kind ?? "hosting";
+  const metadata = metadataFromHeader(header, kind, "ef");
+  function selectZero(n) {
+    if (n === 0) return 0;
+    const sampleIndex = Math.floor((n - 1) / sub.selectStep);
+    let position = view.getUint32(sub.selectOffset + sampleIndex * 4, true);
+    const target = n - sampleIndex * sub.selectStep;
+    let count = 0;
+    while (count < target) {
+      if (bitAt(bytes, sub.highOffset * 8 + position) === 0) {
+        count++;
+      }
+      position++;
+    }
+    return position;
+  }
+  function readLow(index) {
+    let value = 0;
+    const bitPosition = sub.lowOffset * 8 + index * header.l;
+    for (let i = 0; i < header.l; i++) {
+      value = value << 1 | bitAt(bytes, bitPosition + i);
+    }
+    return value;
+  }
+  return {
+    kind,
+    encoding: "ef",
+    metadata,
+    has(input) {
+      const asn = normalizeASN(input);
+      if (asn === null) return false;
+      if (asn < header.offset || asn > header.offset + header.range - 1) return false;
+      const relative = asn - header.offset;
+      const high = relative >> header.l;
+      const low = relative & lowMask;
+      let start;
+      let end;
+      if (high === 0) {
+        start = 0;
+        end = selectZero(1) - 1;
+      } else {
+        const previousZero = selectZero(high);
+        const nextZero = selectZero(high + 1);
+        start = previousZero - high;
+        end = nextZero - (high + 1);
+      }
+      for (let i = start; i < end; i++) {
+        if (readLow(i) === low) return true;
+      }
+      return false;
+    }
+  };
+}
+
+// src/runtime/gr.ts
+function createGRSet(data, options = {}) {
+  const bytes = toUint8Array(data);
+  const header = readCommonHeader(bytes);
+  if (header.k === 0) {
+    throw new Error("ASN dataset is not Golomb-Rice encoded");
+  }
+  const bucket = new Uint16Array(Math.ceil(header.range / 16));
+  if (header.count > 0) {
+    bucket[0] |= 1;
+  }
+  let bitPosition = 14 * 8;
+  let relative = 0;
+  for (let i = 1; i < header.count; i++) {
+    let q = 0;
+    while (bitAt(bytes, bitPosition) === 1) {
+      q++;
+      bitPosition++;
+    }
+    bitPosition++;
+    let r = 0;
+    for (let j = 0; j < header.k; j++) {
+      r = r << 1 | bitAt(bytes, bitPosition);
+      bitPosition++;
+    }
+    relative += q << header.k | r;
+    bucket[relative >> 4] |= 1 << (relative & 15);
+  }
+  const kind = options.kind ?? "hosting";
+  const metadata = metadataFromHeader(header, kind, "gr");
+  return {
+    kind,
+    encoding: "gr",
+    metadata,
+    has(input) {
+      const asn = normalizeASN(input);
+      if (asn === null) return false;
+      const position = asn - header.offset;
+      if (position < 0 || position >= header.range) return false;
+      return (bucket[position >> 4] >> (position & 15) & 1) === 1;
+    }
+  };
+}
+
+// src/runtime/set.ts
+function createASNSet(data, options = {}) {
+  const bytes = toUint8Array(data);
+  const encoding = options.encoding === "auto" || options.encoding === void 0 ? detectEncoding(readCommonHeader(bytes)) : options.encoding;
+  if (encoding === "gr") {
+    return createGRSet(bytes, { kind: options.kind });
+  }
+  return createEFSet(bytes, { kind: options.kind });
+}
+
+// src/runtime/classify.ts
+function classifyWithSets(asn, sets) {
+  if (sets.hosting?.has(asn)) return "hosting";
+  if (sets.access?.has(asn)) return "access";
+  return "unknown";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  classifyWithSets,
+  createASNSet,
+  createEFSet,
+  createGRSet,
+  normalizeASN
+});

package/lib/runtime.d.cts

@@ -0,0 +1,17 @@
+import { f as ASNSetOptions, A as ASNSet, C as CreateASNSetOptions, a as ASNInput, b as ASNClass } from './types-BeWCbJlo.cjs';
+export { c as ASNEncoding, d as ASNListKind, e as ASNSetMetadata } from './types-BeWCbJlo.cjs';
+
+declare function createEFSet(data: string | Uint8Array, options?: ASNSetOptions): ASNSet;
+
+declare function createGRSet(data: string | Uint8Array, options?: ASNSetOptions): ASNSet;
+
+declare function createASNSet(data: string | Uint8Array, options?: CreateASNSetOptions): ASNSet;
+
+declare function classifyWithSets(asn: ASNInput, sets: {
+    hosting?: ASNSet;
+    access?: ASNSet;
+}): ASNClass;
+
+declare function normalizeASN(input: ASNInput): number | null;
+
+export { ASNClass, ASNInput, ASNSet, classifyWithSets, createASNSet, createEFSet, createGRSet, normalizeASN };

package/lib/runtime.d.ts

@@ -0,0 +1,17 @@
+import { f as ASNSetOptions, A as ASNSet, C as CreateASNSetOptions, a as ASNInput, b as ASNClass } from './types-BeWCbJlo.js';
+export { c as ASNEncoding, d as ASNListKind, e as ASNSetMetadata } from './types-BeWCbJlo.js';
+
+declare function createEFSet(data: string | Uint8Array, options?: ASNSetOptions): ASNSet;
+
+declare function createGRSet(data: string | Uint8Array, options?: ASNSetOptions): ASNSet;
+
+declare function createASNSet(data: string | Uint8Array, options?: CreateASNSetOptions): ASNSet;
+
+declare function classifyWithSets(asn: ASNInput, sets: {
+    hosting?: ASNSet;
+    access?: ASNSet;
+}): ASNClass;
+
+declare function normalizeASN(input: ASNInput): number | null;
+
+export { ASNClass, ASNInput, ASNSet, classifyWithSets, createASNSet, createEFSet, createGRSet, normalizeASN };

package/lib/runtime.js

@@ -0,0 +1,208 @@
+// src/runtime/base64.ts
+function toUint8Array(data) {
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(data, "base64"));
+  }
+  const decoded = atob(data);
+  const bytes = new Uint8Array(decoded.length);
+  for (let i = 0; i < decoded.length; i++) {
+    bytes[i] = decoded.charCodeAt(i);
+  }
+  return bytes;
+}
+function bitAt(bytes, bitPosition) {
+  return bytes[bitPosition >> 3] >> 7 - (bitPosition & 7) & 1;
+}
+
+// src/runtime/header.ts
+function dataView(bytes) {
+  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function readCommonHeader(bytes) {
+  if (bytes.byteLength < 14) {
+    throw new Error("ASN dataset is too short to contain a valid header");
+  }
+  const view = dataView(bytes);
+  return {
+    offset: view.getUint32(0, true),
+    count: view.getUint32(4, true),
+    range: view.getUint32(8, true),
+    k: view.getUint8(12),
+    l: view.getUint8(13)
+  };
+}
+function metadataFromHeader(header, kind, encoding) {
+  return {
+    kind,
+    encoding,
+    offset: header.offset,
+    count: header.count,
+    range: header.range,
+    minASN: header.offset,
+    maxASN: header.offset + header.range - 1
+  };
+}
+function detectEncoding(header) {
+  if (header.k > 0 && header.l === 0) return "gr";
+  if (header.k === 0 && header.l > 0) return "ef";
+  throw new Error("Unable to detect ASN dataset encoding");
+}
+
+// src/runtime/normalize.ts
+function normalizeASN(input) {
+  if (typeof input === "number") {
+    return Number.isSafeInteger(input) && input > 0 ? input : null;
+  }
+  const value = String(input).trim();
+  const match = /^(?:AS)?(\d+)$/i.exec(value);
+  if (!match) return null;
+  const asn = Number(match[1]);
+  return Number.isSafeInteger(asn) && asn > 0 ? asn : null;
+}
+
+// src/runtime/ef.ts
+function readEFSubHeader(bytes) {
+  if (bytes.byteLength < 28) {
+    throw new Error("ASN EF dataset is too short to contain a valid sub-header");
+  }
+  const view = dataView(bytes);
+  return {
+    lowOffset: view.getUint32(14, true),
+    highOffset: view.getUint32(18, true),
+    selectOffset: view.getUint32(22, true),
+    selectStep: view.getUint16(26, true)
+  };
+}
+function createEFSet(data, options = {}) {
+  const bytes = toUint8Array(data);
+  const header = readCommonHeader(bytes);
+  if (header.l === 0) {
+    throw new Error("ASN dataset is not Elias-Fano encoded");
+  }
+  const view = dataView(bytes);
+  const sub = readEFSubHeader(bytes);
+  const lowMask = (1 << header.l) - 1;
+  const kind = options.kind ?? "hosting";
+  const metadata = metadataFromHeader(header, kind, "ef");
+  function selectZero(n) {
+    if (n === 0) return 0;
+    const sampleIndex = Math.floor((n - 1) / sub.selectStep);
+    let position = view.getUint32(sub.selectOffset + sampleIndex * 4, true);
+    const target = n - sampleIndex * sub.selectStep;
+    let count = 0;
+    while (count < target) {
+      if (bitAt(bytes, sub.highOffset * 8 + position) === 0) {
+        count++;
+      }
+      position++;
+    }
+    return position;
+  }
+  function readLow(index) {
+    let value = 0;
+    const bitPosition = sub.lowOffset * 8 + index * header.l;
+    for (let i = 0; i < header.l; i++) {
+      value = value << 1 | bitAt(bytes, bitPosition + i);
+    }
+    return value;
+  }
+  return {
+    kind,
+    encoding: "ef",
+    metadata,
+    has(input) {
+      const asn = normalizeASN(input);
+      if (asn === null) return false;
+      if (asn < header.offset || asn > header.offset + header.range - 1) return false;
+      const relative = asn - header.offset;
+      const high = relative >> header.l;
+      const low = relative & lowMask;
+      let start;
+      let end;
+      if (high === 0) {
+        start = 0;
+        end = selectZero(1) - 1;
+      } else {
+        const previousZero = selectZero(high);
+        const nextZero = selectZero(high + 1);
+        start = previousZero - high;
+        end = nextZero - (high + 1);
+      }
+      for (let i = start; i < end; i++) {
+        if (readLow(i) === low) return true;
+      }
+      return false;
+    }
+  };
+}
+
+// src/runtime/gr.ts
+function createGRSet(data, options = {}) {
+  const bytes = toUint8Array(data);
+  const header = readCommonHeader(bytes);
+  if (header.k === 0) {
+    throw new Error("ASN dataset is not Golomb-Rice encoded");
+  }
+  const bucket = new Uint16Array(Math.ceil(header.range / 16));
+  if (header.count > 0) {
+    bucket[0] |= 1;
+  }
+  let bitPosition = 14 * 8;
+  let relative = 0;
+  for (let i = 1; i < header.count; i++) {
+    let q = 0;
+    while (bitAt(bytes, bitPosition) === 1) {
+      q++;
+      bitPosition++;
+    }
+    bitPosition++;
+    let r = 0;
+    for (let j = 0; j < header.k; j++) {
+      r = r << 1 | bitAt(bytes, bitPosition);
+      bitPosition++;
+    }
+    relative += q << header.k | r;
+    bucket[relative >> 4] |= 1 << (relative & 15);
+  }
+  const kind = options.kind ?? "hosting";
+  const metadata = metadataFromHeader(header, kind, "gr");
+  return {
+    kind,
+    encoding: "gr",
+    metadata,
+    has(input) {
+      const asn = normalizeASN(input);
+      if (asn === null) return false;
+      const position = asn - header.offset;
+      if (position < 0 || position >= header.range) return false;
+      return (bucket[position >> 4] >> (position & 15) & 1) === 1;
+    }
+  };
+}
+
+// src/runtime/set.ts
+function createASNSet(data, options = {}) {
+  const bytes = toUint8Array(data);
+  const encoding = options.encoding === "auto" || options.encoding === void 0 ? detectEncoding(readCommonHeader(bytes)) : options.encoding;
+  if (encoding === "gr") {
+    return createGRSet(bytes, { kind: options.kind });
+  }
+  return createEFSet(bytes, { kind: options.kind });
+}
+
+// src/runtime/classify.ts
+function classifyWithSets(asn, sets) {
+  if (sets.hosting?.has(asn)) return "hosting";
+  if (sets.access?.has(asn)) return "access";
+  return "unknown";
+}
+export {
+  classifyWithSets,
+  createASNSet,
+  createEFSet,
+  createGRSet,
+  normalizeASN
+};

package/lib/types-BeWCbJlo.d.cts

@@ -0,0 +1,27 @@
+type ASNInput = number | `AS${number}` | string;
+type ASNClass = "hosting" | "access" | "unknown";
+type ASNListKind = "hosting" | "access";
+type ASNEncoding = "gr" | "ef";
+interface ASNSetMetadata {
+    kind: ASNListKind;
+    encoding: ASNEncoding;
+    offset: number;
+    count: number;
+    range: number;
+    minASN: number;
+    maxASN: number;
+}
+interface ASNSet {
+    readonly kind: ASNListKind;
+    readonly encoding: ASNEncoding;
+    readonly metadata: ASNSetMetadata;
+    has(asn: ASNInput): boolean;
+}
+interface ASNSetOptions {
+    kind?: ASNListKind;
+}
+interface CreateASNSetOptions extends ASNSetOptions {
+    encoding?: ASNEncoding | "auto";
+}
+
+export type { ASNSet as A, CreateASNSetOptions as C, ASNInput as a, ASNClass as b, ASNEncoding as c, ASNListKind as d, ASNSetMetadata as e, ASNSetOptions as f };

package/lib/types-BeWCbJlo.d.ts

@@ -0,0 +1,27 @@
+type ASNInput = number | `AS${number}` | string;
+type ASNClass = "hosting" | "access" | "unknown";
+type ASNListKind = "hosting" | "access";
+type ASNEncoding = "gr" | "ef";
+interface ASNSetMetadata {
+    kind: ASNListKind;
+    encoding: ASNEncoding;
+    offset: number;
+    count: number;
+    range: number;
+    minASN: number;
+    maxASN: number;
+}
+interface ASNSet {
+    readonly kind: ASNListKind;
+    readonly encoding: ASNEncoding;
+    readonly metadata: ASNSetMetadata;
+    has(asn: ASNInput): boolean;
+}
+interface ASNSetOptions {
+    kind?: ASNListKind;
+}
+interface CreateASNSetOptions extends ASNSetOptions {
+    encoding?: ASNEncoding | "auto";
+}
+
+export type { ASNSet as A, CreateASNSetOptions as C, ASNInput as a, ASNClass as b, ASNEncoding as c, ASNListKind as d, ASNSetMetadata as e, ASNSetOptions as f };

package/package.json

@@ -0,0 +1,109 @@
+{
+  "name": "asn-blocklist",
+  "version": "1.20260703.0",
+  "description": "Auto-updated ASN blocklist and access-network list from PeeringDB",
+  "type": "module",
+  "main": "./lib/index.cjs",
+  "module": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "require": "./lib/index.cjs"
+    },
+    "./runtime": {
+      "types": "./lib/runtime.d.ts",
+      "import": "./lib/runtime.js",
+      "require": "./lib/runtime.cjs"
+    },
+    "./hosting/ef": {
+      "types": "./lib/hosting/ef.d.ts",
+      "import": "./lib/hosting/ef.js",
+      "require": "./lib/hosting/ef.cjs"
+    },
+    "./hosting/gr": {
+      "types": "./lib/hosting/gr.d.ts",
+      "import": "./lib/hosting/gr.js",
+      "require": "./lib/hosting/gr.cjs"
+    },
+    "./access/ef": {
+      "types": "./lib/access/ef.d.ts",
+      "import": "./lib/access/ef.js",
+      "require": "./lib/access/ef.cjs"
+    },
+    "./access/gr": {
+      "types": "./lib/access/gr.d.ts",
+      "import": "./lib/access/gr.js",
+      "require": "./lib/access/gr.cjs"
+    },
+    "./data/hosting-ef": {
+      "types": "./lib/data/hosting-ef.d.ts",
+      "import": "./lib/data/hosting-ef.js",
+      "require": "./lib/data/hosting-ef.cjs"
+    },
+    "./data/hosting-gr": {
+      "types": "./lib/data/hosting-gr.d.ts",
+      "import": "./lib/data/hosting-gr.js",
+      "require": "./lib/data/hosting-gr.cjs"
+    },
+    "./data/access-ef": {
+      "types": "./lib/data/access-ef.d.ts",
+      "import": "./lib/data/access-ef.js",
+      "require": "./lib/data/access-ef.cjs"
+    },
+    "./data/access-gr": {
+      "types": "./lib/data/access-gr.d.ts",
+      "import": "./lib/data/access-gr.js",
+      "require": "./lib/data/access-gr.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "generate": "node src/generate/index.cjs",
+    "generate:modules": "node scripts/generate-modules.cjs",
+    "build": "npm run generate:modules && tsup",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "prepack": "npm run build",
+    "update:sizes": "node scripts/update-sizes.cjs",
+    "set-version": "node scripts/set-version.cjs",
+    "check:data": "node scripts/check-data.cjs"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/InsightFlare/asn-blocklist.git"
+  },
+  "bugs": {
+    "url": "https://github.com/InsightFlare/asn-blocklist/issues"
+  },
+  "homepage": "https://github.com/InsightFlare/asn-blocklist#readme",
+  "keywords": [
+    "asn",
+    "autonomous-system",
+    "blocklist",
+    "datacenter",
+    "hosting",
+    "peeringdb",
+    "bot-detection",
+    "analytics"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^24.0.10",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3"
+  },
+  "overrides": {
+    "esbuild": "^0.28.1"
+  }
+}