cojson 0.8.12 → 0.8.17

package/src/base64url.test.ts

@@ -1,33 +1,33 @@
+import { expect, test } from "vitest";
 import { base64URLtoBytes, bytesToBase64url } from "./base64url.js";
-import { test, expect } from "vitest";
 
 const txt = new TextEncoder();
 
 test("Test our Base64 URL encoding and decoding", () => {
-    // tests from the RFC
+  // tests from the RFC
 
-    expect(base64URLtoBytes("")).toEqual(new Uint8Array([]));
-    expect(bytesToBase64url(new Uint8Array([]))).toEqual("");
+  expect(base64URLtoBytes("")).toEqual(new Uint8Array([]));
+  expect(bytesToBase64url(new Uint8Array([]))).toEqual("");
 
-    expect(bytesToBase64url(txt.encode("f"))).toEqual("Zg==");
-    expect(bytesToBase64url(txt.encode("fo"))).toEqual("Zm8=");
-    expect(bytesToBase64url(txt.encode("foo"))).toEqual("Zm9v");
-    expect(bytesToBase64url(txt.encode("foob"))).toEqual("Zm9vYg==");
-    expect(bytesToBase64url(txt.encode("fooba"))).toEqual("Zm9vYmE=");
-    expect(bytesToBase64url(txt.encode("foobar"))).toEqual("Zm9vYmFy");
-    // reverse
-    expect(base64URLtoBytes("Zg==")).toEqual(txt.encode("f"));
-    expect(base64URLtoBytes("Zm8=")).toEqual(txt.encode("fo"));
-    expect(base64URLtoBytes("Zm9v")).toEqual(txt.encode("foo"));
-    expect(base64URLtoBytes("Zm9vYg==")).toEqual(txt.encode("foob"));
-    expect(base64URLtoBytes("Zm9vYmE=")).toEqual(txt.encode("fooba"));
-    expect(base64URLtoBytes("Zm9vYmFy")).toEqual(txt.encode("foobar"));
+  expect(bytesToBase64url(txt.encode("f"))).toEqual("Zg==");
+  expect(bytesToBase64url(txt.encode("fo"))).toEqual("Zm8=");
+  expect(bytesToBase64url(txt.encode("foo"))).toEqual("Zm9v");
+  expect(bytesToBase64url(txt.encode("foob"))).toEqual("Zm9vYg==");
+  expect(bytesToBase64url(txt.encode("fooba"))).toEqual("Zm9vYmE=");
+  expect(bytesToBase64url(txt.encode("foobar"))).toEqual("Zm9vYmFy");
+  // reverse
+  expect(base64URLtoBytes("Zg==")).toEqual(txt.encode("f"));
+  expect(base64URLtoBytes("Zm8=")).toEqual(txt.encode("fo"));
+  expect(base64URLtoBytes("Zm9v")).toEqual(txt.encode("foo"));
+  expect(base64URLtoBytes("Zm9vYg==")).toEqual(txt.encode("foob"));
+  expect(base64URLtoBytes("Zm9vYmE=")).toEqual(txt.encode("fooba"));
+  expect(base64URLtoBytes("Zm9vYmFy")).toEqual(txt.encode("foobar"));
 
-    expect(
-        base64URLtoBytes("V2hhdCBkb2VzIDIgKyAyLjEgZXF1YWw_PyB-IDQ="),
-    ).toEqual(txt.encode("What does 2 + 2.1 equal?? ~ 4"));
-    // reverse
-    expect(
-        bytesToBase64url(txt.encode("What does 2 + 2.1 equal?? ~ 4")),
-    ).toEqual("V2hhdCBkb2VzIDIgKyAyLjEgZXF1YWw_PyB-IDQ=");
+  expect(base64URLtoBytes("V2hhdCBkb2VzIDIgKyAyLjEgZXF1YWw_PyB-IDQ=")).toEqual(
+    txt.encode("What does 2 + 2.1 equal?? ~ 4"),
+  );
+  // reverse
+  expect(bytesToBase64url(txt.encode("What does 2 + 2.1 equal?? ~ 4"))).toEqual(
+    "V2hhdCBkb2VzIDIgKyAyLjEgZXF1YWw_PyB-IDQ=",
+  );
 });

package/src/base64url.ts

@@ -2,67 +2,66 @@ const encoder = new TextEncoder();
 const decoder = new TextDecoder();
 
 export function base64URLtoBytes(base64: string) {
-    base64 = base64.replace(/=/g, "");
-    const n = base64.length;
-    const rem = n % 4;
-    const k = rem && rem - 1; // how many bytes the last base64 chunk encodes
-    const m = (n >> 2) * 3 + k; // total encoded bytes
+  base64 = base64.replace(/=/g, "");
+  const n = base64.length;
+  const rem = n % 4;
+  const k = rem && rem - 1; // how many bytes the last base64 chunk encodes
+  const m = (n >> 2) * 3 + k; // total encoded bytes
 
-    const encoded = new Uint8Array(n + 3);
-    encoder.encodeInto(base64 + "===", encoded);
+  const encoded = new Uint8Array(n + 3);
+  encoder.encodeInto(base64 + "===", encoded);
 
-    for (let i = 0, j = 0; i < n; i += 4, j += 3) {
-        const x =
-            (lookup[encoded[i]!]! << 18) +
-            (lookup[encoded[i + 1]!]! << 12) +
-            (lookup[encoded[i + 2]!]! << 6) +
-            lookup[encoded[i + 3]!]!;
-        encoded[j] = x >> 16;
-        encoded[j + 1] = (x >> 8) & 0xff;
-        encoded[j + 2] = x & 0xff;
-    }
-    return new Uint8Array(encoded.buffer, 0, m);
+  for (let i = 0, j = 0; i < n; i += 4, j += 3) {
+    const x =
+      (lookup[encoded[i]!]! << 18) +
+      (lookup[encoded[i + 1]!]! << 12) +
+      (lookup[encoded[i + 2]!]! << 6) +
+      lookup[encoded[i + 3]!]!;
+    encoded[j] = x >> 16;
+    encoded[j + 1] = (x >> 8) & 0xff;
+    encoded[j + 2] = x & 0xff;
+  }
+  return new Uint8Array(encoded.buffer, 0, m);
 }
 
 export function bytesToBase64url(bytes: Uint8Array) {
-    // const before = performance.now();
-    const m = bytes.length;
-    const k = m % 3;
-    const n = Math.floor(m / 3) * 4 + (k && k + 1);
-    const N = Math.ceil(m / 3) * 4;
-    const encoded = new Uint8Array(N);
+  // const before = performance.now();
+  const m = bytes.length;
+  const k = m % 3;
+  const n = Math.floor(m / 3) * 4 + (k && k + 1);
+  const N = Math.ceil(m / 3) * 4;
+  const encoded = new Uint8Array(N);
 
-    for (let i = 0, j = 0; j < m; i += 4, j += 3) {
-        const y =
-            (bytes[j]! << 16) + (bytes[j + 1]! << 8) + (bytes[j + 2]! | 0);
-        encoded[i] = encodeLookup[y >> 18]!;
-        encoded[i + 1] = encodeLookup[(y >> 12) & 0x3f]!;
-        encoded[i + 2] = encodeLookup[(y >> 6) & 0x3f]!;
-        encoded[i + 3] = encodeLookup[y & 0x3f]!;
-    }
+  for (let i = 0, j = 0; j < m; i += 4, j += 3) {
+    const y = (bytes[j]! << 16) + (bytes[j + 1]! << 8) + (bytes[j + 2]! | 0);
+    encoded[i] = encodeLookup[y >> 18]!;
+    encoded[i + 1] = encodeLookup[(y >> 12) & 0x3f]!;
+    encoded[i + 2] = encodeLookup[(y >> 6) & 0x3f]!;
+    encoded[i + 3] = encodeLookup[y & 0x3f]!;
+  }
 
-    let base64 = decoder.decode(new Uint8Array(encoded.buffer, 0, n));
-    if (k === 1) base64 += "==";
-    if (k === 2) base64 += "=";
-    // const after = performance.now();
-    // console.log(
-    //     "bytesToBase64url bandwidth in MB/s for length",
-    //     (1000 * bytes.length / (after - before)) / (1024 * 1024),
-    //     bytes.length
-    // );
-    return base64;
+  let base64 = decoder.decode(new Uint8Array(encoded.buffer, 0, n));
+  if (k === 1) base64 += "==";
+  if (k === 2) base64 += "=";
+  // const after = performance.now();
+  // console.log(
+  //     "bytesToBase64url bandwidth in MB/s for length",
+  //     (1000 * bytes.length / (after - before)) / (1024 * 1024),
+  //     bytes.length
+  // );
+  return base64;
 }
 
 const alphabet =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
 
 const lookup = new Uint8Array(128);
 for (const [i, a] of Array.from(alphabet).entries()) {
-    lookup[a.charCodeAt(0)] = i;
+  lookup[a.charCodeAt(0)] = i;
 }
 lookup["=".charCodeAt(0)] = 0;
 
 const encodeLookup = new Uint8Array(64);
 for (const [i, a] of Array.from(alphabet).entries()) {
-    encodeLookup[i] = a.charCodeAt(0);
+  encodeLookup[i] = a.charCodeAt(0);
 }

package/src/coValue.ts

@@ -1,68 +1,68 @@
-import { JsonObject, JsonValue } from "./jsonValue.js";
-import { RawCoID } from "./ids.js";
+import { CoValueCore } from "./coValueCore.js";
+import { RawProfile as Profile, RawAccount } from "./coValues/account.js";
+import { RawCoList } from "./coValues/coList.js";
 import { RawCoMap } from "./coValues/coMap.js";
 import { RawBinaryCoStream, RawCoStream } from "./coValues/coStream.js";
-import { RawCoList } from "./coValues/coList.js";
-import { CoValueCore } from "./coValueCore.js";
 import { RawGroup } from "./coValues/group.js";
-import { RawAccount, RawProfile as Profile } from "./coValues/account.js";
+import { RawCoID } from "./ids.js";
+import { JsonObject, JsonValue } from "./jsonValue.js";
 
 export type CoID<T extends RawCoValue> = RawCoID & {
-    readonly __type: T;
+  readonly __type: T;
 };
 
 export interface RawCoValue {
-    /** The `CoValue`'s (precisely typed) `CoID` */
-    id: CoID<this>;
-    core: CoValueCore;
-    /** Specifies which kind of `CoValue` this is */
-    type: string;
-    /** The `CoValue`'s (precisely typed) static metadata */
-    headerMeta: JsonObject | null;
-    /** The `Group` this `CoValue` belongs to (determining permissions) */
-    group: RawGroup;
-    /** Returns an immutable JSON presentation of this `CoValue` */
-    toJSON(): JsonValue;
-    atTime(time: number): this;
-    /** Lets you subscribe to future updates to this CoValue (whether made locally or by other users).
-     *
-     * Takes a listener function that will be called with the current state for each update.
-     *
-     * Returns an unsubscribe function.
-     *
-     * Used internally by `useTelepathicData()` for reactive updates on changes to a `CoValue`. */
-    subscribe(listener: (coValue: this) => void): () => void;
+  /** The `CoValue`'s (precisely typed) `CoID` */
+  id: CoID<this>;
+  core: CoValueCore;
+  /** Specifies which kind of `CoValue` this is */
+  type: string;
+  /** The `CoValue`'s (precisely typed) static metadata */
+  headerMeta: JsonObject | null;
+  /** The `Group` this `CoValue` belongs to (determining permissions) */
+  group: RawGroup;
+  /** Returns an immutable JSON presentation of this `CoValue` */
+  toJSON(): JsonValue;
+  atTime(time: number): this;
+  /** Lets you subscribe to future updates to this CoValue (whether made locally or by other users).
+   *
+   * Takes a listener function that will be called with the current state for each update.
+   *
+   * Returns an unsubscribe function.
+   *
+   * Used internally by `useTelepathicData()` for reactive updates on changes to a `CoValue`. */
+  subscribe(listener: (coValue: this) => void): () => void;
 }
 
 export type AnyRawCoValue =
-    | RawCoMap
-    | RawGroup
-    | RawAccount
-    | Profile
-    | RawCoList
-    | RawCoStream
-    | RawBinaryCoStream;
+  | RawCoMap
+  | RawGroup
+  | RawAccount
+  | Profile
+  | RawCoList
+  | RawCoStream
+  | RawBinaryCoStream;
 
 export function expectMap(content: RawCoValue): RawCoMap {
-    if (content.type !== "comap") {
-        throw new Error("Expected map");
-    }
+  if (content.type !== "comap") {
+    throw new Error("Expected map");
+  }
 
-    return content as RawCoMap;
+  return content as RawCoMap;
 }
 
 export function expectList(content: RawCoValue): RawCoList {
-    if (content.type !== "colist") {
-        throw new Error("Expected list");
-    }
+  if (content.type !== "colist") {
+    throw new Error("Expected list");
+  }
 
-    return content as RawCoList;
+  return content as RawCoList;
 }
 
 export function expectStream(content: RawCoValue): RawCoStream {
-    if (content.type !== "costream") {
-        throw new Error("Expected stream");
-    }
+  if (content.type !== "costream") {
+    throw new Error("Expected stream");
+  }
 
-    return content as RawCoStream;
+  return content as RawCoStream;
 }