monopolyline 0.0.2

package/README.md

@@ -0,0 +1,119 @@
+# monopolyline
+
+A flexible compression library for trajectories and tabular data. Extends standard Google Polyline encoding to support custom schemas, tuples, timestamps, and missing telemetry data while preserving massive bandwidth savings.
+
+- **Custom Decimal Precision**: Compress down to integer coordinates (`precision: 0`) or retain extreme sub-meter detail (`precision: 10`).
+- **Generic Schema Support**: Define custom object or tuple structures (`{ lat: 'decimal', speed: 'integer' }`) for generic data encoding.
+- **Sparse Data Strategies**: Choose from `naive`, `bitmap`, and `columnar` strategies to massively optimize missing telemetry data depending on your dataset shape.
+
+## Installation
+
+```bash
+npm install monopolyline
+```
+
+## Usage (Legacy Mode)
+
+If no schema is provided, the library defaults to legacy mode (`lat`, `lng`, `time`, `acc`).
+
+```typescript
+import { encode, decode } from 'monopolyline';
+
+// Example GPS points
+const points = [
+  { lat: 37.7749, lng: -122.4194, time: 1672531200000, acc: 10 },
+  { lat: 37.7750, lng: -122.4195, time: 1672531205000, acc: 12 },
+];
+
+// Encode
+const encoded = encode(points, {
+  precision: 5,
+  includeTime: true,
+  includeAccuracy: true,
+  sparseStrategy: 'bitmap'
+});
+
+// Decode
+const decoded = decode(encoded, {
+  precision: 5,
+  includeTime: true,
+  includeAccuracy: true,
+  sparseStrategy: 'bitmap'
+});
+```
+
+## Usage (Generic Schema)
+
+You can define custom fields. Schema types support `object` and `tuple` formats. You can also import the `Schema` type for TypeScript support.
+
+```typescript
+import { encode, decode, Schema } from 'monopolyline';
+```
+
+### Schema Type Definition
+
+```typescript
+export type FieldType = 'decimal' | 'integer';
+
+export type Schema = 
+  | { type: 'object'; fields: Record<string, FieldType> }
+  | { type: 'tuple'; fields: FieldType[] };
+```
+
+### Object Schema
+```typescript
+const data = [
+  { lat: 38.5, lng: -120.2, speed: 50 },
+  { lat: 40.7, lng: -120.95, speed: null }, // Missing data
+  { lat: 43.2, lng: -126.4, speed: 60 }
+];
+
+const opts = {
+  schema: {
+    type: 'object',
+    fields: {
+      lat: 'decimal',
+      lng: 'decimal',
+      speed: 'integer'
+    }
+  },
+  sparseStrategy: 'bitmap'
+};
+
+const encoded = encode(data, opts);
+const decoded = decode(encoded, opts);
+```
+
+### Tuple Schema
+Great for minimizing JSON payload overhead before compression.
+```typescript
+const data = [
+  [38.5, -120.2, 50],
+  [40.7, -120.95, null],
+  [43.2, -126.4, 60]
+];
+
+const opts = {
+  schema: {
+    type: 'tuple',
+    fields: ['decimal', 'decimal', 'integer']
+  },
+  sparseStrategy: 'columnar'
+};
+
+const encoded = encode(data, opts);
+const decoded = decode(encoded, opts);
+```
+
+## Sparse Strategies API
+
+When a schema is used or `includeTime`/`includeAccuracy` is enabled, the library needs to know how to handle missing data.
+
+- `naive` (default): Assumes data is dense. If a field is missing, it falls back to a zero-delta (repeating the previous value). Very fast, but wasteful on sparse data.
+- `bitmap`: Prepends a bitmask for each row to indicate which dimensions are present. The most balanced approach for moderate or uneven sparsity.
+- `columnar`: Radically restructures the encoding block into columns (e.g. Latitudes -> Longitudes -> Speeds) and prepends an efficient bit-packed presence map array. Best for highly sparse data, though slightly heavier computationally.
+
+## Advanced Usage
+
+For extreme data compression on massive payloads, this string output pairs perfectly with LZ-based algorithms like `lz-string` or standard `pako` (Deflate). Because Polyline outputs ASCII characters, it achieves very high Deflate ratios.
+

package/index.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it } from 'bun:test';
+import { encode, decode, EncodeOptions, Schema } from './index';
+
+describe('monopolyline backwards compatibility', () => {
+  it('encodes and decodes lat/lng successfully (naive)', () => {
+    const points = [
+      { lat: 38.5, lng: -120.2 },
+      { lat: 40.7, lng: -120.95 },
+      { lat: 43.252, lng: -126.453 }
+    ];
+    const encoded = encode(points);
+    const decoded = decode(encoded);
+    expect(decoded.length).toBe(3);
+    expect(decoded[0].lat).toBeCloseTo(38.5, 5);
+    expect(decoded[2].lat).toBeCloseTo(43.252, 5);
+  });
+
+  it('handles optional time and acc correctly in bitmap mode', () => {
+    const points = [
+      { lat: 38.5, lng: -120.2, time: 1000, acc: 10 },
+      { lat: 40.7, lng: -120.95, time: 1005 },
+      { lat: 43.2, lng: -126.4, acc: 20 },
+      { lat: 43.3, lng: -126.5 }
+    ];
+    const opts: EncodeOptions = {
+      includeTime: true,
+      includeAccuracy: true,
+      sparseStrategy: 'bitmap'
+    };
+    const encoded = encode(points, opts);
+    const decoded = decode(encoded, opts);
+    expect(decoded[0].time).toBe(1000);
+    expect(decoded[0].acc).toBe(10);
+    expect(decoded[1].time).toBe(1005);
+    expect(decoded[1].acc).toBeUndefined();
+    expect(decoded[2].time).toBeUndefined();
+    expect(decoded[2].acc).toBe(20);
+    expect(decoded[3].time).toBeUndefined();
+    expect(decoded[3].acc).toBeUndefined();
+  });
+
+  it('handles optional time and acc correctly in columnar mode', () => {
+    const points = [
+      { lat: 38.5, lng: -120.2, time: 1000, acc: 10 },
+      { lat: 40.7, lng: -120.95, time: 1005 },
+      { lat: 43.2, lng: -126.4, acc: 20 },
+      { lat: 43.3, lng: -126.5 }
+    ];
+    const opts: EncodeOptions = {
+      includeTime: true,
+      includeAccuracy: true,
+      sparseStrategy: 'columnar'
+    };
+    const encoded = encode(points, opts);
+    const decoded = decode(encoded, opts);
+    expect(decoded[0].time).toBe(1000);
+    expect(decoded[0].acc).toBe(10);
+    expect(decoded[1].time).toBe(1005);
+    expect(decoded[1].acc).toBeUndefined();
+    expect(decoded[2].time).toBeUndefined();
+    expect(decoded[2].acc).toBe(20);
+    expect(decoded[3].time).toBeUndefined();
+    expect(decoded[3].acc).toBeUndefined();
+  });
+});
+
+describe('monopolyline generic schema', () => {
+  it('supports object schema with naive strategy', () => {
+    const data = [
+      { lat: 38.5, lng: -120.2, speed: 50 },
+      { lat: 40.7, lng: -120.95, speed: 55 }, // if a field is missing, naive uses previous value
+      { lat: 43.2, lng: -126.4 }
+    ];
+    const opts: EncodeOptions = {
+      schema: {
+        type: 'object',
+        fields: {
+          lat: 'decimal',
+          lng: 'decimal',
+          speed: 'integer'
+        }
+      } as Schema,
+      sparseStrategy: 'naive'
+    };
+    const encoded = encode(data, opts);
+    const decoded = decode(encoded, opts);
+    expect(decoded.length).toBe(3);
+    expect(decoded[0].speed).toBe(50);
+    expect(decoded[1].speed).toBe(55);
+    expect(decoded[2].speed).toBe(55); // Naive carries forward the last known delta which was 0
+  });
+
+  it('supports object schema with bitmap strategy', () => {
+    const data = [
+      { lat: 38.5, lng: -120.2, speed: 50 },
+      { lat: 40.7, lng: -120.95 },
+      { lat: 43.2, lng: -126.4, speed: 60 }
+    ];
+    const opts: EncodeOptions = {
+      schema: {
+        type: 'object',
+        fields: {
+          lat: 'decimal',
+          lng: 'decimal',
+          speed: 'integer'
+        }
+      },
+      sparseStrategy: 'bitmap'
+    };
+    const encoded = encode(data, opts);
+    const decoded = decode(encoded, opts);
+    expect(decoded.length).toBe(3);
+    expect(decoded[0].speed).toBe(50);
+    expect(decoded[1].speed).toBeUndefined();
+    expect(decoded[2].speed).toBe(60);
+  });
+
+  it('supports tuple schema with columnar strategy', () => {
+    const data = [
+      [38.5, -120.2, 50, 100],
+      [40.7, -120.95, null, 105],
+      [43.2, -126.4, 60, null]
+    ];
+    const opts: EncodeOptions = {
+      schema: {
+        type: 'tuple',
+        fields: ['decimal', 'decimal', 'integer', 'integer']
+      },
+      sparseStrategy: 'columnar'
+    };
+    const encoded = encode(data, opts);
+    const decoded = decode(encoded, opts);
+    
+    expect(decoded.length).toBe(3);
+    expect(decoded[0][0]).toBeCloseTo(38.5, 5);
+    expect(decoded[0][2]).toBe(50);
+    expect(decoded[1][2]).toBeUndefined();
+    expect(decoded[1][3]).toBe(105);
+    expect(decoded[2][2]).toBe(60);
+    expect(decoded[2][3]).toBeUndefined();
+  });
+});

package/index.ts

@@ -0,0 +1,542 @@
+export type FieldType = 'decimal' | 'integer';
+
+export type Schema = 
+  | { type: 'object'; fields: Record<string, FieldType> }
+  | { type: 'tuple'; fields: FieldType[] };
+
+export interface Point {
+  lat: number;
+  lng: number;
+  time?: number; // Epoch timestamp in milliseconds
+  acc?: number; // Accuracy in meters
+}
+
+export type SparseStrategy = 'naive' | 'bitmap' | 'columnar';
+
+export interface EncodeOptions {
+  /**
+   * Number of decimal places for 'decimal' fields.
+   * Default: 5 (Standard Google Polyline)
+   */
+  precision?: number;
+  
+  /**
+   * Schema definition to make encoding/decoding generic.
+   * If provided, `includeTime` and `includeAccuracy` are ignored.
+   */
+  schema?: Schema;
+
+  /**
+   * Include the time dimension in the encoded polyline.
+   * Default: false
+   * @deprecated Use `schema` instead for generic data structures.
+   */
+  includeTime?: boolean;
+  
+  /**
+   * Include the accuracy dimension in the encoded polyline.
+   * Default: false
+   * @deprecated Use `schema` instead for generic data structures.
+   */
+  includeAccuracy?: boolean;
+  
+  /**
+   * Strategy for encoding sparse data (missing values).
+   * 'naive' (default): Encodes missing values as 0 delta (repeats previous value).
+   * 'bitmap': Adds a small presence bitmask to each point to skip missing values.
+   * 'columnar': Splits the array into columns (lats, lngs, etc) with run-length presence flags.
+   */
+  sparseStrategy?: SparseStrategy;
+}
+
+/**
+ * Encodes a numeric value using ZigZag encoding and base64-like chunking.
+ */
+function encodeNumber(value: number): string {
+  let zz = value < 0 ? -value * 2 - 1 : value * 2;
+  let str = "";
+  
+  while (zz >= 0x20) {
+    str += String.fromCharCode((0x20 | (zz & 0x1f)) + 63);
+    zz = Math.floor(zz / 32);
+  }
+  str += String.fromCharCode(zz + 63);
+  return str;
+}
+
+/**
+ * Decodes a single numeric value from the encoded string starting at the given index.
+ */
+function decodeNumber(str: string, index: number): [number, number] {
+  let b = 0;
+  let result = 0;
+  let factor = 1;
+
+  do {
+    if (index >= str.length) {
+      throw new Error("Invalid polyline string: unexpected end of string");
+    }
+    b = str.charCodeAt(index++) - 63;
+    result += (b & 0x1f) * factor;
+    factor *= 32;
+  } while (b >= 0x20);
+
+  const value = result % 2 === 1 ? -(Math.floor(result / 2) + 1) : Math.floor(result / 2);
+  return [value, index];
+}
+
+/**
+ * Encodes an array of data into an extended polyline string.
+ */
+export function encode(data: any[], options: EncodeOptions = {}): string {
+  if (!options.schema) {
+    return encodeLegacy(data as Point[], options);
+  }
+  return encodeGeneric(data, options);
+}
+
+/**
+ * Decodes an extended polyline string back into an array of data.
+ */
+export function decode(str: string, options: EncodeOptions = {}): any[] {
+  if (!options.schema) {
+    return decodeLegacy(str, options);
+  }
+  return decodeGeneric(str, options);
+}
+
+function encodeGeneric(data: any[], options: EncodeOptions): string {
+  const precision = options.precision ?? 5;
+  const factor = Math.pow(10, precision);
+  const sparseStrategy = options.sparseStrategy ?? 'naive';
+  const schema = options.schema!;
+
+  const schemaFields: { key: string | number, type: FieldType }[] = [];
+  if (schema.type === 'object') {
+    for (const key of Object.keys(schema.fields)) {
+      schemaFields.push({ key, type: schema.fields[key] });
+    }
+  } else {
+    for (let i = 0; i < schema.fields.length; i++) {
+      schemaFields.push({ key: i, type: schema.fields[i] });
+    }
+  }
+
+  let result = "";
+
+  if (sparseStrategy === 'columnar') {
+    result += encodeNumber(data.length);
+    for (let i = 0; i < schemaFields.length; i++) {
+      const field = schemaFields[i];
+      let prev = 0;
+      let presence = 0;
+      let bitIndex = 0;
+      let presenceStrs = "";
+      let dataStrs = "";
+      for (const pt of data) {
+        const val = pt[field.key];
+        if (val != null) {
+          presence |= (1 << bitIndex);
+          const scaled = field.type === 'decimal' ? Math.round((val as number) * factor) : Math.round(val as number);
+          dataStrs += encodeNumber(scaled - prev);
+          prev = scaled;
+        }
+        bitIndex++;
+        if (bitIndex === 30) {
+          presenceStrs += encodeNumber(presence);
+          presence = 0;
+          bitIndex = 0;
+        }
+      }
+      if (bitIndex > 0) presenceStrs += encodeNumber(presence);
+      result += presenceStrs + dataStrs;
+    }
+    return result;
+  }
+
+  // naive or bitmap
+  const prevs = new Array(schemaFields.length).fill(0);
+  
+  for (const pt of data) {
+    if (sparseStrategy === 'bitmap') {
+      let bitmask = 0;
+      for (let i = 0; i < schemaFields.length; i++) {
+        if (pt[schemaFields[i].key] != null) bitmask |= (1 << i);
+      }
+      result += encodeNumber(bitmask);
+    }
+    
+    for (let i = 0; i < schemaFields.length; i++) {
+      const field = schemaFields[i];
+      const val = pt[field.key];
+      if (sparseStrategy === 'bitmap') {
+        if (val != null) {
+          const scaled = field.type === 'decimal' ? Math.round((val as number) * factor) : Math.round(val as number);
+          result += encodeNumber(scaled - prevs[i]);
+          prevs[i] = scaled;
+        }
+      } else {
+        // naive
+        if (val != null) {
+          const scaled = field.type === 'decimal' ? Math.round((val as number) * factor) : Math.round(val as number);
+          result += encodeNumber(scaled - prevs[i]);
+          prevs[i] = scaled;
+        } else {
+          result += encodeNumber(0);
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+function decodeGeneric(str: string, options: EncodeOptions): any[] {
+  const precision = options.precision ?? 5;
+  const factor = Math.pow(10, precision);
+  const sparseStrategy = options.sparseStrategy ?? 'naive';
+  const schema = options.schema!;
+
+  const schemaFields: { key: string | number, type: FieldType }[] = [];
+  if (schema.type === 'object') {
+    for (const key of Object.keys(schema.fields)) {
+      schemaFields.push({ key, type: schema.fields[key] });
+    }
+  } else {
+    for (let i = 0; i < schema.fields.length; i++) {
+      schemaFields.push({ key: i, type: schema.fields[i] });
+    }
+  }
+
+  let index = 0;
+
+  if (sparseStrategy === 'columnar') {
+    if (str.length === 0) return [];
+    let ptCount = 0;
+    [ptCount, index] = decodeNumber(str, index);
+    
+    const results: any[] = Array.from({ length: ptCount }, () => (schema.type === 'tuple' ? [] : {}));
+
+    for (let f = 0; f < schemaFields.length; f++) {
+      const field = schemaFields[f];
+      
+      const presenceFlags: boolean[] = [];
+      const numPresenceInts = Math.ceil(ptCount / 30);
+      for (let i = 0; i < numPresenceInts; i++) {
+        let p = 0;
+        [p, index] = decodeNumber(str, index);
+        for (let b = 0; b < 30 && (i * 30 + b) < ptCount; b++) {
+          presenceFlags.push((p & (1 << b)) !== 0);
+        }
+      }
+      
+      let prev = 0;
+      for (let i = 0; i < ptCount; i++) {
+        if (presenceFlags[i]) {
+          let delta = 0;
+          [delta, index] = decodeNumber(str, index);
+          prev += delta;
+          const val = field.type === 'decimal' ? prev / factor : prev;
+          results[i][field.key] = val;
+        }
+      }
+    }
+    return results;
+  }
+
+  const prevs = new Array(schemaFields.length).fill(0);
+  const results: any[] = [];
+  
+  while (index < str.length) {
+    let bitmask = (1 << schemaFields.length) - 1; // default all present
+    if (sparseStrategy === 'bitmap') {
+      [bitmask, index] = decodeNumber(str, index);
+    }
+    
+    const pt: any = schema.type === 'tuple' ? [] : {};
+    
+    for (let f = 0; f < schemaFields.length; f++) {
+      const field = schemaFields[f];
+      
+      if (sparseStrategy === 'bitmap') {
+        if ((bitmask & (1 << f)) !== 0) {
+          let delta = 0;
+          [delta, index] = decodeNumber(str, index);
+          prevs[f] += delta;
+          pt[field.key] = field.type === 'decimal' ? prevs[f] / factor : prevs[f];
+        }
+      } else {
+        // naive
+        let delta = 0;
+        [delta, index] = decodeNumber(str, index);
+        prevs[f] += delta;
+        pt[field.key] = field.type === 'decimal' ? prevs[f] / factor : prevs[f];
+      }
+    }
+    
+    results.push(pt);
+  }
+
+  return results;
+}
+
+function encodeLegacy(points: Point[], options: EncodeOptions): string {
+  const precision = options.precision ?? 5;
+  const factor = Math.pow(10, precision);
+  const includeTime = options.includeTime ?? false;
+  const includeAccuracy = options.includeAccuracy ?? false;
+  const sparseStrategy = options.sparseStrategy ?? 'naive';
+
+  let result = "";
+
+  if (sparseStrategy === 'columnar') {
+    result += encodeNumber(points.length);
+    
+    let prevLat = 0, prevLng = 0;
+    for (const point of points) {
+      const lat = Math.round(point.lat * factor);
+      const lng = Math.round(point.lng * factor);
+      result += encodeNumber(lat - prevLat);
+      result += encodeNumber(lng - prevLng);
+      prevLat = lat; prevLng = lng;
+    }
+    
+    if (includeTime) {
+      let prevTime = 0;
+      let timePresence = 0;
+      let bitIndex = 0;
+      let presenceStrs = "";
+      let dataStrs = "";
+      for (const point of points) {
+        if (point.time != null) {
+          timePresence |= (1 << bitIndex);
+          const time = Math.round(point.time);
+          dataStrs += encodeNumber(time - prevTime);
+          prevTime = time;
+        }
+        bitIndex++;
+        if (bitIndex === 30) {
+          presenceStrs += encodeNumber(timePresence);
+          timePresence = 0;
+          bitIndex = 0;
+        }
+      }
+      if (bitIndex > 0) presenceStrs += encodeNumber(timePresence);
+      result += presenceStrs + dataStrs;
+    }
+    
+    if (includeAccuracy) {
+      let prevAcc = 0;
+      let accPresence = 0;
+      let bitIndex = 0;
+      let presenceStrs = "";
+      let dataStrs = "";
+      for (const point of points) {
+        if (point.acc != null) {
+          accPresence |= (1 << bitIndex);
+          const acc = Math.round(point.acc);
+          dataStrs += encodeNumber(acc - prevAcc);
+          prevAcc = acc;
+        }
+        bitIndex++;
+        if (bitIndex === 30) {
+          presenceStrs += encodeNumber(accPresence);
+          accPresence = 0;
+          bitIndex = 0;
+        }
+      }
+      if (bitIndex > 0) presenceStrs += encodeNumber(accPresence);
+      result += presenceStrs + dataStrs;
+    }
+    return result;
+  }
+
+  let prevLat = 0;
+  let prevLng = 0;
+  let prevTime = 0;
+  let prevAcc = 0;
+
+  for (const point of points) {
+    const lat = Math.round(point.lat * factor);
+    const lng = Math.round(point.lng * factor);
+    
+    if (sparseStrategy === 'bitmap' && (includeTime || includeAccuracy)) {
+      let bitmask = 0;
+      if (includeTime && point.time != null) bitmask |= 1;
+      if (includeAccuracy && point.acc != null) bitmask |= 2;
+      result += encodeNumber(bitmask);
+    }
+
+    result += encodeNumber(lat - prevLat);
+    result += encodeNumber(lng - prevLng);
+    prevLat = lat;
+    prevLng = lng;
+
+    if (sparseStrategy === 'bitmap') {
+      if (includeTime && point.time != null) {
+        const time = Math.round(point.time);
+        result += encodeNumber(time - prevTime);
+        prevTime = time;
+      }
+      if (includeAccuracy && point.acc != null) {
+        const acc = Math.round(point.acc);
+        result += encodeNumber(acc - prevAcc);
+        prevAcc = acc;
+      }
+    } else {
+      if (includeTime) {
+        if (point.time != null) {
+          const time = Math.round(point.time);
+          result += encodeNumber(time - prevTime);
+          prevTime = time;
+        } else {
+          result += encodeNumber(0);
+        }
+      }
+      if (includeAccuracy) {
+        if (point.acc != null) {
+          const acc = Math.round(point.acc);
+          result += encodeNumber(acc - prevAcc);
+          prevAcc = acc;
+        } else {
+          result += encodeNumber(0);
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+function decodeLegacy(str: string, options: EncodeOptions): Point[] {
+  const precision = options.precision ?? 5;
+  const factor = Math.pow(10, precision);
+  const includeTime = options.includeTime ?? false;
+  const includeAccuracy = options.includeAccuracy ?? false;
+  const sparseStrategy = options.sparseStrategy ?? 'naive';
+
+  let index = 0;
+  const points: Point[] = [];
+
+  if (sparseStrategy === 'columnar') {
+    if (str.length === 0) return points;
+    let ptCount = 0;
+    [ptCount, index] = decodeNumber(str, index);
+    
+    let prevLat = 0;
+    let prevLng = 0;
+    for (let i = 0; i < ptCount; i++) {
+      let dLat = 0, dLng = 0;
+      [dLat, index] = decodeNumber(str, index);
+      [dLng, index] = decodeNumber(str, index);
+      prevLat += dLat;
+      prevLng += dLng;
+      points.push({ lat: prevLat / factor, lng: prevLng / factor });
+    }
+    
+    if (includeTime) {
+      const presenceFlags: boolean[] = [];
+      const numPresenceInts = Math.ceil(ptCount / 30);
+      for (let i = 0; i < numPresenceInts; i++) {
+        let p = 0;
+        [p, index] = decodeNumber(str, index);
+        for (let b = 0; b < 30 && (i * 30 + b) < ptCount; b++) {
+          presenceFlags.push((p & (1 << b)) !== 0);
+        }
+      }
+      let prevTime = 0;
+      for (let i = 0; i < ptCount; i++) {
+        if (presenceFlags[i]) {
+          let dTime = 0;
+          [dTime, index] = decodeNumber(str, index);
+          prevTime += dTime;
+          points[i].time = prevTime;
+        }
+      }
+    }
+    
+    if (includeAccuracy) {
+      const presenceFlags: boolean[] = [];
+      const numPresenceInts = Math.ceil(ptCount / 30);
+      for (let i = 0; i < numPresenceInts; i++) {
+        let p = 0;
+        [p, index] = decodeNumber(str, index);
+        for (let b = 0; b < 30 && (i * 30 + b) < ptCount; b++) {
+          presenceFlags.push((p & (1 << b)) !== 0);
+        }
+      }
+      let prevAcc = 0;
+      for (let i = 0; i < ptCount; i++) {
+        if (presenceFlags[i]) {
+          let dAcc = 0;
+          [dAcc, index] = decodeNumber(str, index);
+          prevAcc += dAcc;
+          points[i].acc = prevAcc;
+        }
+      }
+    }
+    return points;
+  }
+
+  let prevLat = 0;
+  let prevLng = 0;
+  let prevTime = 0;
+  let prevAcc = 0;
+
+  while (index < str.length) {
+    let bitmask = 3;
+    if (sparseStrategy === 'bitmap' && (includeTime || includeAccuracy)) {
+      [bitmask, index] = decodeNumber(str, index);
+    }
+
+    let dLat = 0;
+    let dLng = 0;
+
+    [dLat, index] = decodeNumber(str, index);
+    [dLng, index] = decodeNumber(str, index);
+    prevLat += dLat;
+    prevLng += dLng;
+
+    const point: Point = {
+      lat: prevLat / factor,
+      lng: prevLng / factor,
+    };
+
+    if (sparseStrategy === 'bitmap') {
+      if (includeTime && (bitmask & 1)) {
+        let dTime = 0;
+        [dTime, index] = decodeNumber(str, index);
+        prevTime += dTime;
+        point.time = prevTime;
+      }
+      if (includeAccuracy && (bitmask & 2)) {
+        let dAcc = 0;
+        [dAcc, index] = decodeNumber(str, index);
+        prevAcc += dAcc;
+        point.acc = prevAcc;
+      }
+    } else {
+      if (includeTime) {
+        let dTime = 0;
+        [dTime, index] = decodeNumber(str, index);
+        if (dTime !== 0) {
+          prevTime += dTime;
+          point.time = prevTime;
+        }
+      }
+      if (includeAccuracy) {
+        let dAcc = 0;
+        [dAcc, index] = decodeNumber(str, index);
+        if (dAcc !== 0) {
+          prevAcc += dAcc;
+          point.acc = prevAcc;
+        }
+      }
+    }
+
+    points.push(point);
+  }
+
+  return points;
+}
+

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "monopolyline",
+  "version": "0.0.2",
+  "description": "An extended Google Polyline encoder/decoder supporting timestamps, accuracy, and sparse data strategies.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test"
+  },
+  "keywords": [
+    "polyline",
+    "gps",
+    "compression",
+    "encoding"
+  ],
+  "author": "mizulu",
+  "license": "",
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "bun-types": "latest"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "target": "ES6",
+    "module": "CommonJS",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true
+  },
+  "include": ["index.ts"]
+}