@atcute/cbor 1.0.5 → 1.0.7

package/dist/bytes.js

@@ -1,11 +1,11 @@
-import { decode, encode } from './base64.js';
+import { fromBase64, toBase64 } from '@atcute/multibase';
 export class BytesWrapper {
     buf;
     constructor(buf) {
         this.buf = buf;
     }
     get $bytes() {
-        return encode(this.buf);
+        return toBase64(this.buf);
     }
     toJSON() {
         return { $bytes: this.$bytes };
@@ -18,6 +18,6 @@ export const fromBytes = (bytes) => {
     if (bytes instanceof BytesWrapper) {
         return bytes.buf;
     }
-    return decode(bytes.$bytes);
+    return fromBase64(bytes.$bytes);
 };
 //# sourceMappingURL=bytes.js.map

package/dist/bytes.js.map

@@ -1 +1 @@
-{"version":3,"file":"bytes.js","sourceRoot":"","sources":["../lib/bytes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAM7C,MAAM,OAAO,YAAY;IACL;IAAnB,YAAmB,GAAe;QAAf,QAAG,GAAH,GAAG,CAAY;IAAG,CAAC;IAEtC,IAAI,MAAM;QACT,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAED,MAAM;QACL,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC;IAChC,CAAC;CACD;AAED,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,GAAe,EAAS,EAAE;IACjD,OAAO,IAAI,YAAY,CAAC,GAAG,CAAC,CAAC;AAC9B,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAAY,EAAc,EAAE;IACrD,IAAI,KAAK,YAAY,YAAY,EAAE,CAAC;QACnC,OAAO,KAAK,CAAC,GAAG,CAAC;IAClB,CAAC;IAED,OAAO,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;AAC7B,CAAC,CAAC"}
+{"version":3,"file":"bytes.js","sourceRoot":"","sources":["../lib/bytes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAMzD,MAAM,OAAO,YAAY;IACL;IAAnB,YAAmB,GAAe;QAAf,QAAG,GAAH,GAAG,CAAY;IAAG,CAAC;IAEtC,IAAI,MAAM;QACT,OAAO,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC3B,CAAC;IAED,MAAM;QACL,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC;IAChC,CAAC;CACD;AAED,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,GAAe,EAAS,EAAE;IACjD,OAAO,IAAI,YAAY,CAAC,GAAG,CAAC,CAAC;AAC9B,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAAY,EAAc,EAAE;IACrD,IAAI,KAAK,YAAY,YAAY,EAAE,CAAC;QACnC,OAAO,KAAK,CAAC,GAAG,CAAC;IAClB,CAAC;IAED,OAAO,UAAU,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;AACjC,CAAC,CAAC"}

package/dist/cid-link.js

@@ -1,5 +1,5 @@
-import * as base32 from '@atcute/base32';
 import { decode, parse } from '@atcute/cid';
+import { toBase32 } from '@atcute/multibase';
 export class CIDLinkWrapper {
     $bytes;
     constructor($bytes) {
@@ -9,7 +9,7 @@ export class CIDLinkWrapper {
         return decode(this.$bytes);
     }
     get $link() {
-        return 'b' + base32.encode(this.$bytes);
+        return 'b' + toBase32(this.$bytes);
     }
     toJSON() {
         return { $link: this.$link };

package/dist/cid-link.js.map

@@ -1 +1 @@
-{"version":3,"file":"cid-link.js","sourceRoot":"","sources":["../lib/cid-link.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAY,MAAM,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAMtD,MAAM,OAAO,cAAc;IACP;IAAnB,YAAmB,MAAkB;QAAlB,WAAM,GAAN,MAAM,CAAY;IAAG,CAAC;IAEzC,IAAI,IAAI;QACP,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC5B,CAAC;IAED,IAAI,KAAK;QACR,OAAO,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACzC,CAAC;IAED,MAAM;QACL,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC;IAC9B,CAAC;CACD;AAED,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAAuB,EAAW,EAAE;IAC7D,IAAI,KAAK,YAAY,UAAU,EAAE,CAAC;QACjC,OAAO,IAAI,cAAc,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAED,OAAO,IAAI,cAAc,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AACxC,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,IAAa,EAAO,EAAE;IACjD,IAAI,IAAI,YAAY,cAAc,EAAE,CAAC;QACpC,OAAO,IAAI,CAAC,IAAI,CAAC;IAClB,CAAC;IAED,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC1B,CAAC,CAAC"}
+{"version":3,"file":"cid-link.js","sourceRoot":"","sources":["../lib/cid-link.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,MAAM,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAM7C,MAAM,OAAO,cAAc;IACP;IAAnB,YAAmB,MAAkB;QAAlB,WAAM,GAAN,MAAM,CAAY;IAAG,CAAC;IAEzC,IAAI,IAAI;QACP,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC5B,CAAC;IAED,IAAI,KAAK;QACR,OAAO,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC;IAED,MAAM;QACL,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC;IAC9B,CAAC;CACD;AAED,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAAuB,EAAW,EAAE;IAC7D,IAAI,KAAK,YAAY,UAAU,EAAE,CAAC;QACjC,OAAO,IAAI,cAAc,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAED,OAAO,IAAI,cAAc,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AACxC,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,IAAa,EAAO,EAAE;IACjD,IAAI,IAAI,YAAY,cAAc,EAAE,CAAC;QACpC,OAAO,IAAI,CAAC,IAAI,CAAC;IAClB,CAAC;IAED,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC1B,CAAC,CAAC"}

package/lib/bytes.ts

@@ -0,0 +1,29 @@
+import { fromBase64, toBase64 } from '@atcute/multibase';
+
+export interface Bytes {
+	$bytes: string;
+}
+
+export class BytesWrapper implements Bytes {
+	constructor(public buf: Uint8Array) {}
+
+	get $bytes(): string {
+		return toBase64(this.buf);
+	}
+
+	toJSON(): Bytes {
+		return { $bytes: this.$bytes };
+	}
+}
+
+export const toBytes = (buf: Uint8Array): Bytes => {
+	return new BytesWrapper(buf);
+};
+
+export const fromBytes = (bytes: Bytes): Uint8Array => {
+	if (bytes instanceof BytesWrapper) {
+		return bytes.buf;
+	}
+
+	return fromBase64(bytes.$bytes);
+};

package/lib/cid-link.ts

@@ -0,0 +1,38 @@
+import { type CID, decode, parse } from '@atcute/cid';
+import { toBase32 } from '@atcute/multibase';
+
+export interface CIDLink {
+	$link: string;
+}
+
+export class CIDLinkWrapper implements CIDLink {
+	constructor(public $bytes: Uint8Array) {}
+
+	get $cid(): CID {
+		return decode(this.$bytes);
+	}
+
+	get $link(): string {
+		return 'b' + toBase32(this.$bytes);
+	}
+
+	toJSON(): CIDLink {
+		return { $link: this.$link };
+	}
+}
+
+export const toCIDLink = (value: CID | Uint8Array): CIDLink => {
+	if (value instanceof Uint8Array) {
+		return new CIDLinkWrapper(value);
+	}
+
+	return new CIDLinkWrapper(value.bytes);
+};
+
+export const fromCIDLink = (link: CIDLink): CID => {
+	if (link instanceof CIDLinkWrapper) {
+		return link.$cid;
+	}
+
+	return parse(link.$link);
+};

package/lib/decode.ts

@@ -0,0 +1,206 @@
+import { toBytes, type Bytes } from './bytes.js';
+import { toCIDLink, type CIDLink } from './cid-link.js';
+
+const utf8d = new TextDecoder();
+
+interface State {
+	b: Uint8Array;
+	v: DataView;
+	p: number;
+}
+
+const readArgument = (state: State, info: number): number => {
+	if (info < 24) {
+		return info;
+	}
+
+	switch (info) {
+		case 24:
+			return readUint8(state);
+		case 25:
+			return readUint16(state);
+		case 26:
+			return readUint32(state);
+		case 27:
+			return readUint64(state);
+	}
+
+	throw new Error(`invalid argument encoding; got ${info}`);
+};
+
+const readFloat64 = (state: State): number => {
+	const value = state.v.getFloat64(state.p);
+
+	state.p += 8;
+	return value;
+};
+
+const readUint8 = (state: State): number => {
+	const value = state.v.getUint8(state.p);
+
+	state.p += 1;
+	return value;
+};
+
+const readUint16 = (state: State): number => {
+	const value = state.v.getUint16(state.p);
+
+	state.p += 2;
+	return value;
+};
+
+const readUint32 = (state: State): number => {
+	const value = state.v.getUint32(state.p);
+
+	state.p += 4;
+	return value;
+};
+
+const readUint64 = (state: State): number => {
+	const hi = state.v.getUint32(state.p);
+	const lo = state.v.getUint32(state.p + 4);
+
+	if (hi > 0x1fffff) {
+		throw new RangeError(`can't decode integers beyond safe integer range`);
+	}
+
+	// prettier-ignore
+	const value = (hi * (2 ** 32)) + lo;
+
+	state.p += 8;
+	return value;
+};
+
+const readString = (state: State, length: number): string => {
+	const slice = state.b.subarray(state.p, (state.p += length));
+
+	return utf8d.decode(slice);
+};
+
+const readBytes = (state: State, length: number): Bytes => {
+	const slice = state.b.subarray(state.p, (state.p += length));
+
+	return toBytes(slice);
+};
+
+const readCid = (state: State, length: number): CIDLink => {
+	// CID bytes are prefixed with 0x00 for historical reasons, apparently.
+	const slice = state.b.subarray(state.p + 1, (state.p += length));
+
+	return toCIDLink(slice);
+};
+
+const readValue = (state: State): any => {
+	const prelude = readUint8(state);
+
+	const type = prelude >> 5;
+	const info = prelude & 0x1f;
+
+	if (type === 0) {
+		const value = readArgument(state, info);
+		return value;
+	}
+
+	if (type === 1) {
+		const value = readArgument(state, info);
+		return -1 - value;
+	}
+
+	if (type === 2) {
+		const len = readArgument(state, info);
+		return readBytes(state, len);
+	}
+
+	if (type === 3) {
+		const len = readArgument(state, info);
+
+		return readString(state, len);
+	}
+
+	if (type === 4) {
+		const len = readArgument(state, info);
+		const array = new Array(len);
+
+		for (let idx = 0; idx < len; idx++) {
+			array[idx] = readValue(state);
+		}
+
+		return array;
+	}
+
+	if (type === 5) {
+		const len = readArgument(state, info);
+		const object: Record<string, unknown> = {};
+
+		for (let idx = 0; idx < len; idx++) {
+			const key = readValue(state);
+			if (typeof key !== 'string') {
+				throw new TypeError(`expected map to only have string keys; got ${typeof key}`);
+			}
+
+			object[key] = readValue(state);
+		}
+
+		return object;
+	}
+
+	if (type === 6) {
+		const tag = readArgument(state, info);
+
+		if (tag === 42) {
+			const prelude = readUint8(state);
+
+			const type = prelude >> 5;
+			const info = prelude & 0x1f;
+
+			if (type !== 2) {
+				throw new TypeError(`expected cid tag to have bytes value; got ${type}`);
+			}
+
+			const len = readArgument(state, info);
+
+			return readCid(state, len);
+		}
+
+		throw new TypeError(`unsupported tag; got ${tag}`);
+	}
+
+	if (type === 7) {
+		switch (info) {
+			case 20:
+				return false;
+			case 21:
+				return true;
+			case 22:
+				return null;
+			case 27:
+				return readFloat64(state);
+		}
+
+		throw new Error(`invalid simple value; got ${info}`);
+	}
+
+	throw new TypeError(`invalid type; got ${type}`);
+};
+
+export const decodeFirst = (buf: Uint8Array): [value: any, remainder: Uint8Array] => {
+	const state: State = {
+		b: buf,
+		v: new DataView(buf.buffer, buf.byteOffset, buf.byteLength),
+		p: 0,
+	};
+
+	const value = readValue(state);
+	const remainder = buf.subarray(state.p);
+
+	return [value, remainder];
+};
+
+export const decode = (buf: Uint8Array): any => {
+	const [value, remainder] = decodeFirst(buf);
+	if (remainder.length !== 0) {
+		throw new Error(`decoded value contains remainder`);
+	}
+
+	return value;
+};

package/lib/encode.ts

@@ -0,0 +1,304 @@
+import { BytesWrapper, fromBytes, type Bytes } from './bytes.js';
+import { CIDLinkWrapper, fromCIDLink, type CIDLink } from './cid-link.js';
+
+const CHUNK_SIZE = 1024;
+
+const utf8e = new TextEncoder();
+
+interface State {
+	c: Uint8Array[];
+	b: ArrayBuffer;
+	v: DataView;
+	p: number;
+}
+
+const resizeIfNeeded = (state: State, needed: number): void => {
+	const buf = state.b;
+	const pos = state.p;
+
+	if (buf.byteLength < pos + needed) {
+		state.c.push(new Uint8Array(buf, 0, pos));
+
+		state.b = new ArrayBuffer(Math.max(CHUNK_SIZE, needed));
+		state.v = new DataView(state.b);
+		state.p = 0;
+	}
+};
+
+const getInfo = (arg: number): number => {
+	if (arg < 24) {
+		return arg;
+	} else if (arg < 0x100) {
+		return 24;
+	} else if (arg < 0x10000) {
+		return 25;
+	} else if (arg < 0x100000000) {
+		return 26;
+	} else {
+		return 27;
+	}
+};
+
+const writeFloat64 = (state: State, val: number): void => {
+	resizeIfNeeded(state, 8);
+
+	state.v.setFloat64(state.p, val);
+	state.p += 8;
+};
+
+const writeUint8 = (state: State, val: number): void => {
+	resizeIfNeeded(state, 1);
+
+	state.v.setUint8(state.p, val);
+	state.p += 1;
+};
+
+const writeUint16 = (state: State, val: number): void => {
+	resizeIfNeeded(state, 2);
+
+	state.v.setUint16(state.p, val);
+	state.p += 2;
+};
+
+const writeUint32 = (state: State, val: number): void => {
+	resizeIfNeeded(state, 4);
+
+	state.v.setUint32(state.p, val);
+	state.p += 4;
+};
+
+const writeUint64 = (state: State, val: number): void => {
+	const hi = (val / 2 ** 32) | 0;
+	const lo = val >>> 0;
+
+	resizeIfNeeded(state, 8);
+
+	state.v.setUint32(state.p, hi);
+	state.v.setUint32(state.p + 4, lo);
+	state.p += 8;
+};
+
+const writeTypeAndArgument = (state: State, type: number, arg: number): void => {
+	const info = getInfo(arg);
+
+	writeUint8(state, (type << 5) | info);
+
+	switch (info) {
+		case 24:
+			return writeUint8(state, arg);
+		case 25:
+			return writeUint16(state, arg);
+		case 26:
+			return writeUint32(state, arg);
+		case 27:
+			return writeUint64(state, arg);
+	}
+};
+
+const writeInteger = (state: State, val: number): void => {
+	if (val < 0) {
+		writeTypeAndArgument(state, 1, -val - 1);
+	} else {
+		writeTypeAndArgument(state, 0, val);
+	}
+};
+
+const writeFloat = (state: State, val: number): void => {
+	writeUint8(state, 0xe0 | 27);
+	writeFloat64(state, val);
+};
+
+const writeNumber = (state: State, val: number): void => {
+	if (Number.isNaN(val)) {
+		throw new RangeError(`NaN values not supported`);
+	}
+
+	if (val > Number.MAX_SAFE_INTEGER || val < Number.MIN_SAFE_INTEGER) {
+		throw new RangeError(`can't encode numbers beyond safe integer range`);
+	}
+
+	if (Number.isInteger(val)) {
+		writeInteger(state, val);
+	} else {
+		writeFloat(state, val);
+	}
+};
+
+const writeString = (state: State, val: string): void => {
+	const buf = utf8e.encode(val);
+	const len = buf.byteLength;
+
+	writeTypeAndArgument(state, 3, len);
+	resizeIfNeeded(state, len);
+
+	new Uint8Array(state.b, state.p).set(buf);
+
+	state.p += len;
+};
+
+const writeBytes = (state: State, val: Bytes): void => {
+	const buf = fromBytes(val);
+	const len = buf.byteLength;
+
+	writeTypeAndArgument(state, 2, len);
+	resizeIfNeeded(state, len);
+
+	new Uint8Array(state.b, state.p, len).set(buf);
+
+	state.p += len;
+};
+
+const writeCid = (state: State, val: CIDLink): void => {
+	// CID bytes are prefixed with 0x00 for historical reasons, apparently.
+	const buf = fromCIDLink(val).bytes;
+	const len = buf.byteLength + 1;
+
+	writeTypeAndArgument(state, 6, 42);
+	writeTypeAndArgument(state, 2, len);
+
+	resizeIfNeeded(state, len);
+
+	new Uint8Array(state.b, state.p + 1, len - 1).set(buf);
+
+	state.p += len;
+};
+
+const writeValue = (state: State, val: any): void => {
+	if (val === undefined) {
+		throw new TypeError(`undefined values not supported`);
+	}
+
+	if (val === null) {
+		return writeUint8(state, 0xf6);
+	}
+
+	if (val === false) {
+		return writeUint8(state, 0xf4);
+	}
+
+	if (val === true) {
+		return writeUint8(state, 0xf5);
+	}
+
+	if (typeof val === 'number') {
+		return writeNumber(state, val);
+	}
+
+	if (typeof val === 'string') {
+		return writeString(state, val);
+	}
+
+	if (typeof val === 'object') {
+		if (isArray(val)) {
+			const len = val.length;
+
+			writeTypeAndArgument(state, 4, len);
+
+			for (let idx = 0; idx < len; idx++) {
+				const v = val[idx];
+				writeValue(state, v);
+			}
+
+			return;
+		}
+
+		if ('$link' in val) {
+			if (val instanceof CIDLinkWrapper || typeof val.$link === 'string') {
+				writeCid(state, val);
+				return;
+			}
+
+			throw new TypeError(`unexpected cid-link value`);
+		}
+
+		if ('$bytes' in val) {
+			if (val instanceof BytesWrapper || typeof val.$bytes === 'string') {
+				writeBytes(state, val);
+				return;
+			}
+
+			throw new TypeError(`unexpected bytes value`);
+		}
+
+		if (isPlainObject(val)) {
+			const keys = Object.keys(val)
+				.filter((key) => typeof key === 'string' && val[key] !== undefined)
+				.sort(compareKeys);
+
+			const len = keys.length;
+
+			writeTypeAndArgument(state, 5, len);
+
+			for (let idx = 0; idx < len; idx++) {
+				const key = keys[idx];
+
+				writeString(state, key);
+				writeValue(state, val[key]);
+			}
+
+			return;
+		}
+	}
+
+	throw new TypeError(`unsupported type: ${val}`);
+};
+
+const createState = (): State => {
+	const buf = new ArrayBuffer(CHUNK_SIZE);
+
+	return {
+		c: [],
+		b: buf,
+		v: new DataView(buf),
+		p: 0,
+	};
+};
+
+export const encode = (value: any): Uint8Array => {
+	const state = createState();
+	const chunks = state.c;
+
+	writeValue(state, value);
+	chunks.push(new Uint8Array(state.b, 0, state.p));
+
+	let size = 0;
+	let written = 0;
+
+	let len = chunks.length;
+	let idx: number;
+
+	for (idx = 0; idx < len; idx++) {
+		size += chunks[idx].byteLength;
+	}
+
+	const u8 = new Uint8Array(size);
+
+	for (idx = 0; idx < len; idx++) {
+		const chunk = chunks[idx];
+
+		u8.set(chunk, written);
+		written += chunk.byteLength;
+	}
+
+	return u8;
+};
+
+const isArray = Array.isArray;
+const isPlainObject = (v: any): boolean => {
+	if (typeof v !== 'object' || v === null) {
+		return false;
+	}
+
+	const proto = Object.getPrototypeOf(v);
+	return proto === Object.prototype || proto === null;
+};
+
+const compareKeys = (a: string, b: string): number => {
+	if (a.length < b.length) {
+		return -1;
+	} else if (b.length < a.length) {
+		return 1;
+	} else {
+		return a < b ? -1 : 1;
+	}
+};

package/lib/index.ts

@@ -0,0 +1,5 @@
+export { BytesWrapper, fromBytes, toBytes, type Bytes } from './bytes.js';
+export { CIDLinkWrapper, fromCIDLink, toCIDLink, type CIDLink } from './cid-link.js';
+
+export { decode, decodeFirst } from './decode.js';
+export { encode } from './encode.js';

package/package.json

@@ -1,14 +1,18 @@
 {
   "type": "module",
   "name": "@atcute/cbor",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "DAG-CBOR codec that deals in AT Protocol's HTTP wire format",
   "license": "MIT",
   "repository": {
-    "url": "https://codeberg.org/mary-ext/atcute"
+    "url": "https://github.com/mary-ext/atcute",
+    "directory": "packages/utilities/cbor"
   },
   "files": [
-    "dist/"
+    "dist/",
+    "lib/",
+    "!lib/**/*.bench.ts",
+    "!lib/**/*.test.ts"
   ],
   "exports": {
     ".": "./dist/index.js"
@@ -16,12 +20,12 @@
   "sideEffects": false,
   "devDependencies": {
     "@ipld/dag-cbor": "^9.2.1",
-    "@types/bun": "^1.1.11",
+    "@types/bun": "^1.1.12",
     "mitata": "^1.0.10"
   },
   "dependencies": {
-    "@atcute/base32": "^1.0.0",
-    "@atcute/cid": "^1.0.1"
+    "@atcute/cid": "^1.0.3",
+    "@atcute/multibase": "^1.0.0"
   },
   "scripts": {
     "build": "tsc --project tsconfig.build.json",

package/dist/base64.d.ts

@@ -1,2 +0,0 @@
-export declare const decode: (str: string) => Uint8Array;
-export declare const encode: (data: Uint8Array) => string;

package/dist/base64.js

@@ -1,72 +0,0 @@
-const BASE64_CHARSET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-const BASE64_BITS = 6;
-const BASE64_CODES = /*#__PURE__*/ (() => {
-    const codes = {};
-    for (let i = 0, ilen = BASE64_CHARSET.length; i < ilen; i++) {
-        codes[BASE64_CHARSET[i]] = i;
-    }
-    return codes;
-})();
-export const decode = (str) => {
-    // Calculate padding
-    // let end = str.length;
-    // while (str[end - 1] === '=') {
-    // 	--end;
-    // }
-    const end = str.length;
-    // Allocate
-    const out = new Uint8Array(((end * BASE64_BITS) / 8) | 0);
-    // Parse
-    let bits = 0; // Number of bits currently in the buffer
-    let buffer = 0; // Bits waiting to be written out, MSB first
-    let written = 0; // Next byte to write
-    for (let i = 0; i < end; ++i) {
-        // Read one character from the string:
-        const value = BASE64_CODES[str[i]];
-        if (value === undefined) {
-            throw new SyntaxError(`invalid base64 string`);
-        }
-        // Append the bits to the buffer:
-        buffer = (buffer << BASE64_BITS) | value;
-        bits += BASE64_BITS;
-        // Write out some bits if the buffer has a byte's worth:
-        if (bits >= 8) {
-            bits -= 8;
-            out[written++] = 0xff & (buffer >> bits);
-        }
-    }
-    // Verify
-    if (bits >= BASE64_BITS || (0xff & (buffer << (8 - bits))) !== 0) {
-        throw new SyntaxError('unexpected end of data');
-    }
-    return out;
-};
-export const encode = (data) => {
-    // const pad = BASE64_CHARSET[BASE64_CHARSET.length - 1] === '=';
-    const mask = (1 << BASE64_BITS) - 1;
-    let out = '';
-    let bits = 0; // Number of bits currently in the buffer
-    let buffer = 0; // Bits waiting to be written out, MSB first
-    for (let i = 0; i < data.length; ++i) {
-        // Slurp data into the buffer:
-        buffer = (buffer << 8) | data[i];
-        bits += 8;
-        // Write out as much as we can:
-        while (bits > BASE64_BITS) {
-            bits -= BASE64_BITS;
-            out += BASE64_CHARSET[mask & (buffer >> bits)];
-        }
-    }
-    // Partial character:
-    if (bits !== 0) {
-        out += BASE64_CHARSET[mask & (buffer << (BASE64_BITS - bits))];
-    }
-    // Add padding characters until we hit a byte boundary:
-    // if (pad) {
-    // 	while (((out.length * BASE64_BITS) & 7) !== 0) {
-    // 		out += '=';
-    // 	}
-    // }
-    return out;
-};
-//# sourceMappingURL=base64.js.map

package/dist/base64.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"base64.js","sourceRoot":"","sources":["../lib/base64.ts"],"names":[],"mappings":"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"}