@chr33s/pdf-unicode-trie 5.0.0 → 5.0.2

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@chr33s/pdf-unicode-trie",
-  "version": "5.0.0",
+  "version": "5.0.2",
   "description": "Unicode Trie data structure for fast character metadata lookup, ported from ICU",
   "type": "module",
   "sideEffects": false,
+  "files": [
+    "dist/**",
+    "src/**"
+  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -27,7 +31,7 @@
   "license": "MIT",
   "homepage": "https://github.com/chr33s/pdf",
   "dependencies": {
-    "@chr33s/pdf-common": "file:../common"
+    "@chr33s/pdf-common": "5.0.2"
   },
   "devDependencies": {
     "@types/node": "24.10.1",

package/test/builder.test.ts

@@ -1,151 +0,0 @@
-import { describe, expect, test } from "vitest";
-import UnicodeTrieBuilder from "../src/builder.js";
-
-describe("UnicodeTrieBuilder", () => {
-  describe("constructor", () => {
-    test("should accept null initial value", () => {
-      const builder = new UnicodeTrieBuilder(null, 0);
-      expect(builder.get(0x0100)).toBe(0);
-    });
-
-    test("should accept null error value", () => {
-      const builder = new UnicodeTrieBuilder(0, null);
-      expect(builder.get(-1)).toBe(0);
-    });
-
-    test("should use default values when not provided", () => {
-      const builder = new UnicodeTrieBuilder();
-      expect(builder.get(0x0100)).toBe(0);
-      expect(builder.get(-1)).toBe(0);
-    });
-  });
-
-  describe("set", () => {
-    test("should set values for individual code points", () => {
-      const builder = new UnicodeTrieBuilder(0, 0);
-      builder.set(0x0041, 1);
-      builder.set(0x0042, 2);
-      builder.set(0x0043, 3);
-
-      expect(builder.get(0x0041)).toBe(1);
-      expect(builder.get(0x0042)).toBe(2);
-      expect(builder.get(0x0043)).toBe(3);
-    });
-
-    test("should overwrite previous values", () => {
-      const builder = new UnicodeTrieBuilder(0, 0);
-      builder.set(0x0041, 100);
-      expect(builder.get(0x0041)).toBe(100);
-
-      builder.set(0x0041, 200);
-      expect(builder.get(0x0041)).toBe(200);
-    });
-
-    test("should handle supplementary plane code points", () => {
-      const builder = new UnicodeTrieBuilder(0, 0);
-      builder.set(0x1f600, 128512); // Emoji code point
-
-      expect(builder.get(0x1f600)).toBe(128512);
-    });
-  });
-
-  describe("setRange", () => {
-    test("should set range without overwrite", () => {
-      const builder = new UnicodeTrieBuilder(0, 0);
-      builder.set(0x50, 99);
-      builder.setRange(0x40, 0x60, 50, false);
-
-      // Existing value should not be overwritten
-      expect(builder.get(0x50)).toBe(99);
-      // Other values in range should be set
-      expect(builder.get(0x40)).toBe(50);
-      expect(builder.get(0x60)).toBe(50);
-    });
-
-    test("should set range with overwrite", () => {
-      const builder = new UnicodeTrieBuilder(0, 0);
-      builder.set(0x50, 99);
-      builder.setRange(0x40, 0x60, 50, true);
-
-      // Existing value should be overwritten
-      expect(builder.get(0x50)).toBe(50);
-      expect(builder.get(0x40)).toBe(50);
-      expect(builder.get(0x60)).toBe(50);
-    });
-
-    test("should handle single code point range", () => {
-      const builder = new UnicodeTrieBuilder(0, 0);
-      builder.setRange(0x100, 0x100, 42, true);
-
-      expect(builder.get(0x100)).toBe(42);
-      expect(builder.get(0x0ff)).toBe(0);
-      expect(builder.get(0x101)).toBe(0);
-    });
-
-    test("should handle large ranges", () => {
-      const builder = new UnicodeTrieBuilder(0, 0);
-      builder.setRange(0x0, 0xffff, 1, true);
-
-      expect(builder.get(0x0)).toBe(1);
-      expect(builder.get(0x8000)).toBe(1);
-      expect(builder.get(0xffff)).toBe(1);
-      expect(builder.get(0x10000)).toBe(0); // Beyond range
-    });
-  });
-
-  describe("freeze", () => {
-    test("should return compacted trie", () => {
-      const builder = new UnicodeTrieBuilder(10, 20);
-      builder.set(0x1000, 100);
-
-      const trie = builder.freeze();
-      expect(trie.get(0x1000)).toBe(100);
-      expect(trie.get(0x1001)).toBe(10);
-      expect(trie.get(-1)).toBe(20);
-    });
-
-    test("should return same values as builder", () => {
-      const builder = new UnicodeTrieBuilder(5, 999);
-      builder.setRange(0x100, 0x1ff, 50, true);
-      builder.set(0x150, 75);
-
-      const trie = builder.freeze();
-
-      for (let cp = 0x100; cp <= 0x1ff; cp++) {
-        expect(trie.get(cp)).toBe(builder.get(cp));
-      }
-    });
-  });
-
-  describe("toBuffer", () => {
-    test("should produce buffer that can be loaded", async () => {
-      const builder = new UnicodeTrieBuilder(1, 2);
-      builder.set(0x5000, 500);
-
-      const buffer = await builder.toBuffer();
-      expect(buffer).toBeInstanceOf(Buffer);
-      expect(buffer.length).toBeGreaterThan(12); // Header is 12 bytes
-
-      // Verify header values
-      const highStart = buffer.readUInt32LE(0);
-      const errorValue = buffer.readUInt32LE(4);
-      expect(errorValue).toBe(2);
-      expect(highStart).toBeGreaterThan(0);
-    });
-
-    test("should produce valid compressed output", async () => {
-      const builder = new UnicodeTrieBuilder(0, 0);
-      builder.setRange(0x0, 0xff, 1, true);
-
-      const buffer = await builder.toBuffer();
-
-      // Import UnicodeTrie to verify
-      const { default: UnicodeTrie } = await import("../src/index.js");
-      const trie = await UnicodeTrie.create(buffer);
-
-      expect(trie.get(0x00)).toBe(1);
-      expect(trie.get(0xff)).toBe(1);
-      expect(trie.get(0x100)).toBe(0);
-    });
-  });
-});

package/test/swap.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { swap32LE } from "../src/swap.js";
-
-describe("swap32LE", () => {
-  test("should not modify array on little-endian systems", () => {
-    // Most modern systems are little-endian, so this is the common case
-    const input = new Uint8Array([0x12, 0x34, 0x56, 0x78]);
-
-    // On little-endian systems, this should be a no-op
-    // On big-endian systems, it will swap bytes
-    swap32LE(input);
-
-    // We check that the function runs without error
-    // The actual byte order depends on the system endianness
-    expect(input.length).toBe(4);
-  });
-
-  test("should handle empty array", () => {
-    const input = new Uint8Array([]);
-    expect(() => swap32LE(input)).not.toThrow();
-  });
-
-  test("should handle multiple 32-bit values", () => {
-    const input = new Uint8Array([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]);
-    expect(() => swap32LE(input)).not.toThrow();
-    expect(input.length).toBe(8);
-  });
-
-  test("should work with array that is multiple of 4 bytes", () => {
-    const input = new Uint8Array(12);
-    for (let i = 0; i < 12; i++) {
-      input[i] = i;
-    }
-    expect(() => swap32LE(input)).not.toThrow();
-  });
-});

package/test/trie.test.ts

@@ -1,125 +0,0 @@
-import { describe, expect, test } from "vitest";
-import UnicodeTrieBuilder from "../src/builder.js";
-import UnicodeTrie from "../src/unicode-trie.js";
-
-describe("UnicodeTrie", () => {
-  describe("get", () => {
-    test("should return errorValue for negative code points", async () => {
-      const builder = new UnicodeTrieBuilder(0, 999);
-      const trie = builder.freeze();
-      expect(trie.get(-1)).toBe(999);
-      expect(trie.get(-100)).toBe(999);
-    });
-
-    test("should return errorValue for code points above 0x10FFFF", async () => {
-      const builder = new UnicodeTrieBuilder(0, 888);
-      const trie = builder.freeze();
-      expect(trie.get(0x110000)).toBe(888);
-      expect(trie.get(0x200000)).toBe(888);
-    });
-
-    test("should handle BMP code points (0x0000-0xFFFF)", async () => {
-      const builder = new UnicodeTrieBuilder(0, 0);
-      builder.set(0x0041, 65); // 'A'
-      builder.set(0x0061, 97); // 'a'
-      builder.set(0x0000, 1); // NUL
-      builder.set(0xffff, 2); // Last BMP
-
-      const trie = builder.freeze();
-      expect(trie.get(0x0041)).toBe(65);
-      expect(trie.get(0x0061)).toBe(97);
-      expect(trie.get(0x0000)).toBe(1);
-      expect(trie.get(0xffff)).toBe(2);
-    });
-
-    test("should handle lead surrogate range (0xD800-0xDBFF)", async () => {
-      const builder = new UnicodeTrieBuilder(0, 0);
-      builder.set(0xd800, 100);
-      builder.set(0xdbff, 101);
-
-      const trie = builder.freeze();
-      expect(trie.get(0xd800)).toBe(100);
-      expect(trie.get(0xdbff)).toBe(101);
-    });
-
-    test("should handle supplementary code points (0x10000-0x10FFFF)", async () => {
-      const builder = new UnicodeTrieBuilder(0, 0);
-      builder.set(0x10000, 200); // First supplementary
-      builder.set(0x1f600, 201); // Emoji
-      builder.set(0x10ffff, 202); // Last valid
-
-      const trie = builder.freeze();
-      expect(trie.get(0x10000)).toBe(200);
-      expect(trie.get(0x1f600)).toBe(201);
-      expect(trie.get(0x10ffff)).toBe(202);
-    });
-
-    test("should return initial value for unset code points", async () => {
-      const builder = new UnicodeTrieBuilder(42, 0);
-      const trie = builder.freeze();
-
-      expect(trie.get(0x0100)).toBe(42);
-      expect(trie.get(0x5000)).toBe(42);
-    });
-  });
-
-  describe("fromJSON", () => {
-    test("should create trie from JSON object", async () => {
-      const builder = new UnicodeTrieBuilder(10, 666);
-      builder.set(0x0041, 100);
-      const frozen = builder.freeze();
-
-      const json = {
-        data: frozen.data,
-        highStart: frozen.highStart,
-        errorValue: frozen.errorValue,
-      };
-
-      const trie = UnicodeTrie.fromJSON(json);
-      expect(trie.get(0x0041)).toBe(100);
-      expect(trie.get(0x0042)).toBe(10);
-      expect(trie.get(-1)).toBe(666);
-    });
-
-    test("should accept Int32Array as data", () => {
-      const data = new Int32Array([1, 2, 3, 4]);
-      const json = {
-        data,
-        highStart: 0x110000,
-        errorValue: 0,
-      };
-
-      const trie = UnicodeTrie.fromJSON(json);
-      expect(trie.data).toBeInstanceOf(Uint32Array);
-    });
-  });
-
-  describe("create", () => {
-    test("should detect JSON format and use fromJSON", async () => {
-      const builder = new UnicodeTrieBuilder(5, 500);
-      builder.set(0x0100, 99);
-      const frozen = builder.freeze();
-
-      const json = {
-        data: frozen.data,
-        highStart: frozen.highStart,
-        errorValue: frozen.errorValue,
-      };
-
-      const trie = await UnicodeTrie.create(json);
-      expect(trie.get(0x0100)).toBe(99);
-      expect(trie.get(-1)).toBe(500);
-    });
-
-    test("should detect buffer format and use fromBuffer", async () => {
-      const builder = new UnicodeTrieBuilder(7, 700);
-      builder.set(0x0200, 77);
-
-      const buffer = await builder.toBuffer();
-      const trie = await UnicodeTrie.create(buffer);
-
-      expect(trie.get(0x0200)).toBe(77);
-      expect(trie.get(-1)).toBe(700);
-    });
-  });
-});

package/test/unicode-trie.test.ts

@@ -1,258 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import UnicodeTrieBuilder from "../src/builder.js";
-import UnicodeTrie from "../src/index.js";
-
-describe("unicode trie", () => {
-  test("set", () => {
-    const trie = new UnicodeTrieBuilder(10, 666);
-    trie.set(0x4567, 99);
-    expect(trie.get(0x4566)).toBe(10);
-    expect(trie.get(0x4567)).toBe(99);
-    expect(trie.get(-1)).toBe(666);
-    expect(trie.get(0x110000)).toBe(666);
-  });
-
-  test("set -> compacted trie", () => {
-    const builder = new UnicodeTrieBuilder(10, 666);
-    builder.set(0x4567, 99);
-
-    const trie = builder.freeze();
-    expect(trie.get(0x4566)).toBe(10);
-    expect(trie.get(0x4567)).toBe(99);
-    expect(trie.get(-1)).toBe(666);
-    expect(trie.get(0x110000)).toBe(666);
-  });
-
-  test("setRange", () => {
-    const trie = new UnicodeTrieBuilder(10, 666);
-    trie.setRange(13, 6666, 7788, false);
-    trie.setRange(6000, 7000, 9900, true);
-
-    expect(trie.get(12)).toBe(10);
-    expect(trie.get(13)).toBe(7788);
-    expect(trie.get(5999)).toBe(7788);
-    expect(trie.get(6000)).toBe(9900);
-    expect(trie.get(7000)).toBe(9900);
-    expect(trie.get(7001)).toBe(10);
-    expect(trie.get(0x110000)).toBe(666);
-  });
-
-  test("setRange -> compacted trie", () => {
-    const builder = new UnicodeTrieBuilder(10, 666);
-    builder.setRange(13, 6666, 7788, false);
-    builder.setRange(6000, 7000, 9900, true);
-
-    const trie = builder.freeze();
-    expect(trie.get(12)).toBe(10);
-    expect(trie.get(13)).toBe(7788);
-    expect(trie.get(5999)).toBe(7788);
-    expect(trie.get(6000)).toBe(9900);
-    expect(trie.get(7000)).toBe(9900);
-    expect(trie.get(7001)).toBe(10);
-    expect(trie.get(0x110000)).toBe(666);
-  });
-
-  test("toBuffer produces valid compressed output", async () => {
-    const builder = new UnicodeTrieBuilder();
-    builder.set(0x4567, 99);
-
-    const buf = await builder.toBuffer();
-    // Verify buffer has correct header format
-    expect(buf.length).toBeGreaterThan(12);
-    // Verify high start and error values in header
-    expect(buf.readUInt32LE(0)).toBe(builder.freeze().highStart);
-    expect(buf.readUInt32LE(4)).toBe(builder.freeze().errorValue);
-    // Verify that the output can be loaded back as a valid trie
-    const trie = await UnicodeTrie.create(buf);
-    expect(trie.get(0x4567)).toBe(99);
-    expect(trie.get(0x4566)).toBe(0);
-  });
-
-  test("should work with compressed serialization format", async () => {
-    const builder = new UnicodeTrieBuilder(10, 666);
-    builder.setRange(13, 6666, 7788, false);
-    builder.setRange(6000, 7000, 9900, true);
-
-    const buf = await builder.toBuffer();
-    const trie = await UnicodeTrie.create(buf);
-    expect(trie.get(12)).toBe(10);
-    expect(trie.get(13)).toBe(7788);
-    expect(trie.get(5999)).toBe(7788);
-    expect(trie.get(6000)).toBe(9900);
-    expect(trie.get(7000)).toBe(9900);
-    expect(trie.get(7001)).toBe(10);
-    expect(trie.get(0x110000)).toBe(666);
-  });
-
-  const rangeTests = [
-    {
-      ranges: [
-        [0, 0, 0, 0],
-        [0, 0x40, 0, 0],
-        [0x40, 0xe7, 0x1234, 0],
-        [0xe7, 0x3400, 0, 0],
-        [0x3400, 0x9fa6, 0x6162, 0],
-        [0x9fa6, 0xda9e, 0x3132, 0],
-        [0xdada, 0xeeee, 0x87ff, 0],
-        [0xeeee, 0x11111, 1, 0],
-        [0x11111, 0x44444, 0x6162, 0],
-        [0x44444, 0x60003, 0, 0],
-        [0xf0003, 0xf0004, 0xf, 0],
-        [0xf0004, 0xf0006, 0x10, 0],
-        [0xf0006, 0xf0007, 0x11, 0],
-        [0xf0007, 0xf0040, 0x12, 0],
-        [0xf0040, 0x110000, 0, 0],
-      ],
-      check: [
-        [0, 0],
-        [0x40, 0],
-        [0xe7, 0x1234],
-        [0x3400, 0],
-        [0x9fa6, 0x6162],
-        [0xda9e, 0x3132],
-        [0xdada, 0],
-        [0xeeee, 0x87ff],
-        [0x11111, 1],
-        [0x44444, 0x6162],
-        [0xf0003, 0],
-        [0xf0004, 0xf],
-        [0xf0006, 0x10],
-        [0xf0007, 0x11],
-        [0xf0040, 0x12],
-        [0x110000, 0],
-      ],
-    },
-    {
-      ranges: [
-        [0, 0, 0, 0],
-        [0x21, 0x7f, 0x5555, 1],
-        [0x2f800, 0x2fedc, 0x7a, 1],
-        [0x72, 0xdd, 3, 1],
-        [0xdd, 0xde, 4, 0],
-        [0x201, 0x240, 6, 1],
-        [0x241, 0x280, 6, 1],
-        [0x281, 0x2c0, 6, 1],
-        [0x2f987, 0x2fa98, 5, 1],
-        [0x2f777, 0x2f883, 0, 1],
-        [0x2f900, 0x2ffaa, 1, 0],
-        [0x2ffaa, 0x2ffab, 2, 1],
-        [0x2ffbb, 0x2ffc0, 7, 1],
-      ],
-      check: [
-        [0, 0],
-        [0x21, 0],
-        [0x72, 0x5555],
-        [0xdd, 3],
-        [0xde, 4],
-        [0x201, 0],
-        [0x240, 6],
-        [0x241, 0],
-        [0x280, 6],
-        [0x281, 0],
-        [0x2c0, 6],
-        [0x2f883, 0],
-        [0x2f987, 0x7a],
-        [0x2fa98, 5],
-        [0x2fedc, 0x7a],
-        [0x2ffaa, 1],
-        [0x2ffab, 2],
-        [0x2ffbb, 0],
-        [0x2ffc0, 7],
-        [0x110000, 0],
-      ],
-    },
-    {
-      ranges: [
-        [0, 0, 9, 0],
-        [0x31, 0xa4, 1, 0],
-        [0x3400, 0x6789, 2, 0],
-        [0x8000, 0x89ab, 9, 1],
-        [0x9000, 0xa000, 4, 1],
-        [0xabcd, 0xbcde, 3, 1],
-        [0x55555, 0x110000, 6, 1],
-        [0xcccc, 0x55555, 6, 1],
-      ],
-      check: [
-        [0, 9],
-        [0x31, 9],
-        [0xa4, 1],
-        [0x3400, 9],
-        [0x6789, 2],
-        [0x9000, 9],
-        [0xa000, 4],
-        [0xabcd, 9],
-        [0xbcde, 3],
-        [0xcccc, 9],
-        [0x110000, 6],
-      ],
-    },
-    {
-      ranges: [[0, 0, 3, 0]],
-      check: [
-        [0, 3],
-        [0x110000, 3],
-      ],
-    },
-    {
-      ranges: [
-        [0, 0, 3, 0],
-        [0, 0x110000, 5, 1],
-      ],
-      check: [
-        [0, 3],
-        [0x110000, 5],
-      ],
-    },
-  ] as const;
-
-  type TrieLike = { get: (codePoint: number) => number };
-
-  const findMismatch = (trie: TrieLike, checks: readonly (readonly [number, number])[]) => {
-    let start = 0;
-    for (const [end, expected] of checks) {
-      for (let codePoint = start; codePoint < end; codePoint++) {
-        const actual = trie.get(codePoint);
-        if (actual !== expected) {
-          return { codePoint, expected, actual } as const;
-        }
-      }
-      start = end;
-    }
-    return null;
-  };
-
-  test("should pass range tests", () => {
-    for (const rangeTest of rangeTests) {
-      let initialValue = 0;
-      let errorValue = 0x0bad;
-      let index = 0;
-
-      if (rangeTest.ranges[index][1] < 0) {
-        errorValue = rangeTest.ranges[index][2];
-        index++;
-      }
-
-      initialValue = rangeTest.ranges[index++][2];
-      const builder = new UnicodeTrieBuilder(initialValue, errorValue);
-
-      for (const range of rangeTest.ranges.slice(index)) {
-        builder.setRange(range[0], range[1] - 1, range[2], range[3] !== 0);
-      }
-
-      const frozen = builder.freeze();
-
-      const builderMismatch = findMismatch(builder, rangeTest.check);
-      const builderMessage = builderMismatch
-        ? `builder mismatch at U+${builderMismatch.codePoint.toString(16)}: expected ${builderMismatch.expected}, got ${builderMismatch.actual}`
-        : undefined;
-      expect(builderMismatch, builderMessage).toBeNull();
-
-      const frozenMismatch = findMismatch(frozen, rangeTest.check);
-      const frozenMessage = frozenMismatch
-        ? `frozen mismatch at U+${frozenMismatch.codePoint.toString(16)}: expected ${frozenMismatch.expected}, got ${frozenMismatch.actual}`
-        : undefined;
-      expect(frozenMismatch, frozenMessage).toBeNull();
-    }
-  });
-});

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist"
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["dist", "test", "scripts", "node_modules"]
-}

package/tsconfig.typecheck.json

@@ -1,14 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "noEmit": true,
-    "rootDir": "."
-  },
-  "include": [
-    "**/*.ts",
-  ],
-  "exclude": [
-    "dist",
-    "node_modules"
-  ]
-}

package/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    environment: "node",
-    include: ["test/**/*.test.ts"],
-  },
-});