@gjsify/buffer 0.0.2

package/README.md

@@ -0,0 +1,7 @@
+# @gjsify/buffer
+
+Node.js buffer module for Gjs
+
+## Inspirations and credits
+- https://deno.land/std/node/buffer.ts
+- https://github.com/feross/buffer

package/lib/cjs/index.js

@@ -0,0 +1,36 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("@gjsify/deno_std/node/buffer"), module.exports);
+var import_buffer = __toESM(require("@gjsify/deno_std/node/buffer"), 1);
+var src_default = import_buffer.default;

package/lib/esm/index.js

@@ -0,0 +1,6 @@
+export * from "@gjsify/deno_std/node/buffer";
+import buffer from "@gjsify/deno_std/node/buffer";
+var src_default = buffer;
+export {
+  src_default as default
+};

package/lib/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from '@gjsify/deno_std/node/buffer';
+import buffer from '@gjsify/deno_std/node/buffer';
+export default buffer;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@gjsify/buffer",
+  "version": "0.0.2",
+  "description": "Node.js buffer module for Gjs",
+  "type": "module",
+  "main": "lib/cjs/index.js",
+  "module": "lib/esm/index.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./lib/types/index.d.ts",
+        "default": "./lib/esm/index.js"
+      },
+      "require": {
+        "types": "./lib/types/index.d.ts",
+        "default": "./lib/cjs/index.js"
+      }
+    }
+  },
+  "scripts": {
+    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo || exit 0",
+    "print:name": "echo '@gjsify/buffer'",
+    "build": "yarn print:name && yarn build:gjsify && yarn build:types",
+    "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
+    "build:types": "tsc --project tsconfig.types.json || exit 0",
+    "build:test": "yarn build:test:gjs && yarn build:test:node",
+    "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
+    "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
+    "test": "yarn print:name && yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
+    "test:gjs": "gjs -m test.gjs.mjs",
+    "test:node": "node test.node.mjs"
+  },
+  "keywords": [
+    "gjs",
+    "node",
+    "buffer"
+  ],
+  "devDependencies": {
+    "@gjsify/cli": "^0.0.2",
+    "@gjsify/unit": "^0.0.2",
+    "@types/node": "^20.3.1",
+    "typescript": "^5.1.3"
+  },
+  "dependencies": {
+    "@gjsify/deno_std": "^0.0.2"
+  }
+}

package/src/index.spec.ts

@@ -0,0 +1,583 @@
+import { describe, it, expect } from '@gjsify/unit';
+import { Buffer } from 'buffer';
+
+export default async () => {
+
+	// Tests ported from https://github.com/denoland/deno_std/blob/main/node/buffer_test.ts
+
+	await describe('alloc fails if size is not a number', async () => {
+		const invalidSizes = [{}, "1", "foo", []];
+
+		await it('should throw on non-number size', async () => {
+			for (const size of invalidSizes) {
+				expect(() => {
+					// deno-lint-ignore ban-ts-comment
+					// @ts-expect-error
+					Buffer.alloc(size);
+				}).toThrow(TypeError);
+			}
+		});
+	});
+
+
+	await describe('alloc allocates a buffer with the expected size', async () => {
+		const buffer: Buffer = Buffer.alloc(1);
+		await it('Buffer size should be 1', async () => {
+			expect(buffer.length).toBe(1);
+		});
+		await it('Content should be filled with 0', async () => {
+			expect(buffer[0]).toBe(0);
+		});
+	});
+
+	await describe('alloc(0) creates an empty buffer', async () => {
+		const buffer: Buffer = Buffer.alloc(0);
+		await it('Buffer size should be 0', async () => {
+			expect(buffer.length).toBe(0);
+		});
+	});
+
+	await describe('allocUnsafe allocates a buffer with the expected size', async () => {
+		const buffer: Buffer = Buffer.allocUnsafe(1);
+		await it('Buffer size should be 1', async () => {
+			expect(buffer.length).toBe(1);
+		});
+	});
+
+	await describe('allocUnsafe(0) creates an empty buffer', async () => {
+		const buffer: Buffer = Buffer.allocUnsafe(0);
+		await it('Buffer size should be 0', async () => {
+			expect(buffer.length).toBe(0);
+		});
+	});
+
+	await describe('alloc filled correctly with integer', async () => {
+		const buffer: Buffer = Buffer.alloc(3, 5);
+		await it('Should be equal to `Buffer.from([5, 5, 5])`', async () => {
+			expect(buffer).toEqualArray(Buffer.from([5, 5, 5]));
+		});
+	});
+
+	await describe('alloc filled correctly with single character', async () => {
+		await it('Should be equal to `Buffer.from([97, 97, 97, 97, 97])`', async () => {
+			expect(Buffer.alloc(5, "a")).toEqualArray(Buffer.from([97, 97, 97, 97, 97]));
+		});
+	});
+
+	await describe('alloc filled correctly with base64 string', async () => {
+		await it('Should be equal to `Buffer.from([104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100])`', async () => {
+			expect(Buffer.alloc(11, "aGVsbG8gd29ybGQ=", "base64")).toEqualArray(Buffer.from([104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]));
+		});
+	});
+
+	await describe('alloc filled correctly with hex string', async () => {
+		await it('Should be equal to `Buffer.from([100, 101, 110, 111])`', async () => {
+			expect(Buffer.alloc(4, "64656e6f", "hex")).toEqualArray(Buffer.from([100, 101, 110, 111]));
+		});
+	});
+
+	await describe('alloc filled correctly with hex string smaller than alloc size', async () => {
+		await it('Should be equal to `denodenodenod`', async () => {
+			expect(Buffer.alloc(13, "64656e6f", "hex").toString()).toEqual("denodenodenod");
+		});
+	});
+
+	await describe('alloc filled correctly with Uint8Array smaller than alloc size', async () => {
+		await it('Should be equal to `Buffer.from([100, 101, 100, 101, 100, 101, 100])`', async () => {
+			expect(Buffer.alloc(7, new Uint8Array([100, 101]) as any)).toEqualArray(Buffer.from([100, 101, 100, 101, 100, 101, 100]));
+		});
+		await it('Should be equal to `Buffer.from([100, 101, 100, 101, 100, 101])`', async () => {
+			expect(Buffer.alloc(6, new Uint8Array([100, 101]) as any)).toEqualArray(Buffer.from([100, 101, 100, 101, 100, 101]));
+		});
+	});
+
+	await describe('alloc filled correctly with Uint8Array bigger than alloc size', async () => {
+		await it('Should be equal to `Buffer.from([100])`', async () => {
+			expect(Buffer.alloc(1, new Uint8Array([100, 101]) as any)).toEqualArray(Buffer.from([100]));
+		});
+	});
+
+	await describe('alloc filled correctly with Buffer', async () => {
+		await it('Should be equal to `Buffer.from([100, 101, 100, 101, 100, 101])`', async () => {
+			expect(Buffer.alloc(6, Buffer.from([100, 101]))).toEqualArray(Buffer.from([100, 101, 100, 101, 100, 101]));
+		});
+
+		await it('Should be equal to `Buffer.from([100, 101, 100, 101, 100, 101, 100])`', async () => {
+			expect(Buffer.alloc(7, Buffer.from([100, 101]))).toEqualArray(Buffer.from([100, 101, 100, 101, 100, 101, 100]));
+		});
+	});
+
+	// tests from:
+	// https://github.com/nodejs/node/blob/56dbe466fdbc598baea3bfce289bf52b97b8b8f7/test/parallel/test-buffer-bytelength.js#L70
+	await describe('Buffer.byteLength()', async () => {
+		await it('Byte length is the expected for strings`', async () => {
+			// Special case: zero length string
+			expect(Buffer.byteLength("", "ascii")).toBe(0);
+			expect(Buffer.byteLength("", "HeX" as any)).toBe(0);
+
+			// utf8
+			expect(Buffer.byteLength("∑éllö wørl∂!", "utf-8")).toBe(19);
+			expect(Buffer.byteLength("κλμνξο", "utf8")).toBe(12);
+			expect(Buffer.byteLength("挵挶挷挸挹", "utf-8")).toBe(15);
+			expect(Buffer.byteLength("𠝹𠱓𠱸", "UTF8" as any)).toBe(12);
+			// Without an encoding, utf8 should be assumed
+			expect(Buffer.byteLength("hey there")).toBe(9);
+			expect(Buffer.byteLength("𠱸挶νξ#xx :)")).toBe(17);
+			expect(Buffer.byteLength("hello world", "" as any)).toBe(11);
+			// It should also be assumed with unrecognized encoding
+			expect(Buffer.byteLength("hello world", "abc" as any)).toBe(11);
+			expect(Buffer.byteLength("ßœ∑≈", "unkn0wn enc0ding" as any)).toBe(10);
+
+			// base64
+			expect(Buffer.byteLength("aGVsbG8gd29ybGQ=", "base64")).toBe(11);
+			expect(Buffer.byteLength("aGVsbG8gd29ybGQ=", "BASE64" as any)).toBe(11);
+			expect(Buffer.byteLength("bm9kZS5qcyByb2NrcyE=", "base64")).toBe(14);
+			expect(Buffer.byteLength("aGkk", "base64")).toBe(3);
+			expect(
+				Buffer.byteLength("bHNrZGZsa3NqZmtsc2xrZmFqc2RsZmtqcw==", "base64")).toBe(25);
+			// special padding
+			expect(Buffer.byteLength("aaa=", "base64")).toBe(2);
+			expect(Buffer.byteLength("aaaa==", "base64")).toBe(3);
+
+			expect(Buffer.byteLength("Il était tué")).toBe(14);
+			expect(Buffer.byteLength("Il était tué", "utf8")).toBe(14);
+
+			["ascii", "latin1", "binary"]
+				.reduce((es: string[], e: string) => es.concat(e, e.toUpperCase()), [])
+				.forEach((encoding: BufferEncoding) => {
+					expect(Buffer.byteLength("Il était tué", encoding)).toBe(12);
+				});
+
+			["ucs2", "ucs-2", "utf16le", "utf-16le"]
+				.reduce((es: string[], e: string) => es.concat(e, e.toUpperCase()), [])
+				.forEach((encoding: BufferEncoding) => {
+					expect(Buffer.byteLength("Il était tué", encoding)).toBe(24);
+				});
+		});
+	});
+
+	await describe('Byte length is the expected one for non-strings', async () => {
+		await it('Byte length differs on buffers', async () => {
+			expect(
+				Buffer.byteLength(Buffer.alloc(0))
+			).toBe(
+				Buffer.alloc(0).byteLength
+			)
+		});
+	});
+
+	await describe('Two Buffers are concatenated', async () => {
+		await it('The buffers should be equal', async () => {
+			const data1 = [1, 2, 3];
+			const data2 = [4, 5, 6];
+
+			const buffer1 = Buffer.from(data1);
+			const buffer2 = Buffer.from(data2);
+
+			const resultBuffer = Buffer.concat([buffer1, buffer2]);
+			const expectedBuffer = Buffer.from([...data1, ...data2]);
+			expect(resultBuffer).toEqualArray(expectedBuffer);
+		});
+	});
+
+	// TODO: ALso port the tests below
+
+	// Deno.test({
+	// 	name: "A single buffer concatenates and return the same buffer",
+	// 	fn() {
+	// 		const buffer1 = Buffer.alloc(1);
+	// 		const resultBuffer = Buffer.concat([buffer1]);
+	// 		assertEquals(resultBuffer.length, 1, "Buffer length should be 1");
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "No buffers concat returns an empty buffer",
+	// 	fn() {
+	// 		const resultBuffer = Buffer.concat([]);
+	// 		assertEquals(resultBuffer.length, 0, "Buffer length should be 0");
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "Buffer concat respects totalLength parameter",
+	// 	fn() {
+	// 		const maxLength1 = 10;
+	// 		const buffer1 = Buffer.alloc(2);
+	// 		const buffer2 = Buffer.alloc(2);
+	// 		assertEquals(
+	// 			Buffer.concat([buffer1, buffer2], maxLength1).length,
+	// 			maxLength1,
+	// 		);
+
+	// 		const maxLength2 = 3;
+	// 		const buffer3 = Buffer.alloc(2);
+	// 		const buffer4 = Buffer.alloc(2);
+	// 		assertEquals(
+	// 			Buffer.concat([buffer3, buffer4], maxLength2).length,
+	// 			maxLength2,
+	// 		);
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "Buffer 8 bit unsigned integers",
+	// 	fn() {
+	// 		const buffer = Buffer.from([0xff, 0x2a, 0x2a, 0x2a]);
+	// 		assertEquals(buffer.readUInt8(0), 255);
+	// 		assertEquals(buffer.readUInt8(1), 42);
+	// 		assertEquals(buffer.readUInt8(2), 42);
+	// 		assertEquals(buffer.readUInt8(3), 42);
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "Buffer 16 bit unsigned integers",
+	// 	fn() {
+	// 		const buffer = Buffer.from([0x00, 0x2a, 0x42, 0x3f]);
+	// 		assertEquals(buffer.readUInt16BE(0), 0x2a);
+	// 		assertEquals(buffer.readUInt16BE(1), 0x2a42);
+	// 		assertEquals(buffer.readUInt16BE(2), 0x423f);
+	// 		assertEquals(buffer.readUInt16LE(0), 0x2a00);
+	// 		assertEquals(buffer.readUInt16LE(1), 0x422a);
+	// 		assertEquals(buffer.readUInt16LE(2), 0x3f42);
+
+	// 		buffer[0] = 0xfe;
+	// 		buffer[1] = 0xfe;
+	// 		assertEquals(buffer.readUInt16BE(0), 0xfefe);
+	// 		assertEquals(buffer.readUInt16LE(0), 0xfefe);
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "Buffer 32 bit unsigned integers",
+	// 	fn() {
+	// 		const buffer = Buffer.from([0x32, 0x65, 0x42, 0x56, 0x23, 0xff]);
+	// 		assertEquals(buffer.readUInt32BE(0), 0x32654256);
+	// 		assertEquals(buffer.readUInt32BE(1), 0x65425623);
+	// 		assertEquals(buffer.readUInt32BE(2), 0x425623ff);
+	// 		assertEquals(buffer.readUInt32LE(0), 0x56426532);
+	// 		assertEquals(buffer.readUInt32LE(1), 0x23564265);
+	// 		assertEquals(buffer.readUInt32LE(2), 0xff235642);
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "Buffer readUIntBE",
+	// 	fn() {
+	// 		const buffer = Buffer.from([
+	// 			0x01,
+	// 			0x02,
+	// 			0x03,
+	// 			0x04,
+	// 			0x05,
+	// 			0x06,
+	// 			0x07,
+	// 			0x08,
+	// 		]);
+	// 		assertEquals(buffer.readUIntBE(0, 1), 0x01);
+	// 		assertEquals(buffer.readUIntBE(0, 2), 0x0102);
+	// 		assertEquals(buffer.readUIntBE(0, 4), 0x01020304);
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "Buffer readUIntLE",
+	// 	fn() {
+	// 		const buffer = Buffer.from([
+	// 			0x01,
+	// 			0x02,
+	// 			0x03,
+	// 			0x04,
+	// 			0x05,
+	// 			0x06,
+	// 			0x07,
+	// 			0x08,
+	// 		]);
+	// 		assertEquals(buffer.readUIntLE(0, 1), 0x01);
+	// 		assertEquals(buffer.readUIntLE(0, 2), 0x0201);
+	// 		assertEquals(buffer.readUIntLE(0, 4), 0x04030201);
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "Buffer copy works as expected",
+	// 	fn() {
+	// 		const data1 = new Uint8Array([1, 2, 3]);
+	// 		const data2 = new Uint8Array([4, 5, 6]);
+
+	// 		const buffer1 = Buffer.from(data1);
+	// 		const buffer2 = Buffer.from(data2);
+
+	// 		//Mutates data_1
+	// 		data1.set(data2);
+	// 		//Mutates buffer_1
+	// 		buffer2.copy(buffer1);
+
+	// 		assertEquals(
+	// 			Buffer.from(data1),
+	// 			buffer1,
+	// 		);
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "Buffer copy respects the starting point for copy",
+	// 	fn() {
+	// 		const buffer1 = Buffer.from([1, 2, 3]);
+	// 		const buffer2 = Buffer.alloc(8);
+
+	// 		buffer1.copy(buffer2, 5);
+
+	// 		const expected = Buffer.from([0, 0, 0, 0, 0, 1, 2, 3]);
+
+	// 		assertEquals(
+	// 			buffer2,
+	// 			expected,
+	// 		);
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "Buffer copy doesn't throw on offset but copies until offset reached",
+	// 	fn() {
+	// 		const buffer1 = Buffer.from([1, 2, 3]);
+	// 		const buffer2 = Buffer.alloc(8);
+
+	// 		const writtenBytes1 = buffer1.copy(buffer2, 6);
+
+	// 		assertEquals(
+	// 			writtenBytes1,
+	// 			2,
+	// 		);
+
+	// 		assertEquals(
+	// 			buffer2,
+	// 			Buffer.from([0, 0, 0, 0, 0, 0, 1, 2]),
+	// 		);
+
+	// 		const buffer3 = Buffer.from([1, 2, 3]);
+	// 		const buffer4 = Buffer.alloc(8);
+
+	// 		const writtenBytes2 = buffer3.copy(buffer4, 8);
+
+	// 		assertEquals(
+	// 			writtenBytes2,
+	// 			0,
+	// 		);
+
+	// 		assertEquals(
+	// 			buffer4,
+	// 			Buffer.from([0, 0, 0, 0, 0, 0, 0, 0]),
+	// 		);
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "Buffer from string creates a Buffer",
+	// 	fn() {
+	// 		const buffer: Buffer = Buffer.from("test");
+	// 		assertEquals(buffer.length, 4, "Buffer length should be 4");
+	// 		assertEquals(
+	// 			buffer.toString(),
+	// 			"test",
+	// 			"Buffer to string should recover the string",
+	// 		);
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "Buffer from string hex",
+	// 	fn() {
+	// 		for (const encoding of ["hex", "HEX"]) {
+	// 			const buffer: Buffer = Buffer.from(
+	// 				"7468697320697320612074c3a97374",
+	// 				encoding,
+	// 			);
+	// 			assertEquals(buffer.length, 15, "Buffer length should be 15");
+	// 			assertEquals(
+	// 				buffer.toString(),
+	// 				"this is a tést",
+	// 				"Buffer to string should recover the string",
+	// 			);
+	// 		}
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "Buffer from string base64",
+	// 	fn() {
+	// 		for (const encoding of ["base64", "BASE64"]) {
+	// 			const buffer: Buffer = Buffer.from("dGhpcyBpcyBhIHTDqXN0", encoding);
+	// 			assertEquals(buffer.length, 15, "Buffer length should be 15");
+	// 			assertEquals(
+	// 				buffer.toString(),
+	// 				"this is a tést",
+	// 				"Buffer to string should recover the string",
+	// 			);
+	// 		}
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "Buffer to string base64",
+	// 	fn() {
+	// 		for (const encoding of ["base64", "BASE64"]) {
+	// 			const buffer: Buffer = Buffer.from("deno land");
+	// 			assertEquals(
+	// 				buffer.toString(encoding),
+	// 				"ZGVubyBsYW5k",
+	// 				"Buffer to string should recover the string in base64",
+	// 			);
+	// 		}
+	// 		const b64 = "dGhpcyBpcyBhIHTDqXN0";
+	// 		assertEquals(Buffer.from(b64, "base64").toString("base64"), b64);
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "Buffer to string hex",
+	// 	fn() {
+	// 		for (const encoding of ["hex", "HEX"]) {
+	// 			const buffer: Buffer = Buffer.from("deno land");
+	// 			assertEquals(
+	// 				buffer.toString(encoding),
+	// 				"64656e6f206c616e64",
+	// 				"Buffer to string should recover the string",
+	// 			);
+	// 		}
+	// 		const hex = "64656e6f206c616e64";
+	// 		assertEquals(Buffer.from(hex, "hex").toString("hex"), hex);
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "Buffer from string invalid encoding",
+	// 	fn() {
+	// 		const defaultToUtf8Encodings = [null, 5, {}, true, false, ""];
+	// 		const invalidEncodings = ["deno", "base645"];
+
+	// 		for (const encoding of defaultToUtf8Encodings) {
+	// 			assertEquals(Buffer.from("yes", encoding).toString(), "yes");
+	// 		}
+
+	// 		for (const encoding of invalidEncodings) {
+	// 			assertThrows(
+	// 				() => {
+	// 					Buffer.from("yes", encoding);
+	// 				},
+	// 				TypeError,
+	// 				`Unknown encoding: ${encoding}`,
+	// 			);
+	// 		}
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "Buffer from another buffer creates a Buffer",
+	// 	fn() {
+	// 		const buffer: Buffer = Buffer.from(Buffer.from("test"));
+	// 		assertEquals(buffer.length, 4, "Buffer length should be 4");
+	// 		assertEquals(
+	// 			buffer.toString(),
+	// 			"test",
+	// 			"Buffer to string should recover the string",
+	// 		);
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "isBuffer returns true if the object is a buffer",
+	// 	fn() {
+	// 		assertEquals(Buffer.isBuffer(Buffer.from("test")), true);
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "isBuffer returns false if the object is not a buffer",
+	// 	fn() {
+	// 		assertEquals(Buffer.isBuffer({ test: 3 }), false);
+	// 		assertEquals(Buffer.isBuffer(new Uint8Array()), false);
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "Buffer toJSON",
+	// 	fn() {
+	// 		assertEquals(
+	// 			JSON.stringify(Buffer.from("deno")),
+	// 			'{"type":"Buffer","data":[100,101,110,111]}',
+	// 		);
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "buf.slice does not create a copy",
+	// 	fn() {
+	// 		const buf = Buffer.from("ceno");
+	// 		// This method is not compatible with the Uint8Array.prototype.slice()
+	// 		const slice = buf.slice();
+	// 		slice[0]++;
+	// 		assertEquals(slice.toString(), "deno");
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "isEncoding returns true for valid encodings",
+	// 	fn() {
+	// 		[
+	// 			"hex",
+	// 			"HEX",
+	// 			"HeX",
+	// 			"utf8",
+	// 			"utf-8",
+	// 			"ascii",
+	// 			"latin1",
+	// 			"binary",
+	// 			"base64",
+	// 			"BASE64",
+	// 			"BASe64",
+	// 			"ucs2",
+	// 			"ucs-2",
+	// 			"utf16le",
+	// 			"utf-16le",
+	// 		].forEach((enc) => {
+	// 			assertEquals(Buffer.isEncoding(enc), true);
+	// 		});
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name: "isEncoding returns false for invalid encodings",
+	// 	fn() {
+	// 		[
+	// 			"utf9",
+	// 			"utf-7",
+	// 			"Unicode-FTW",
+	// 			"new gnu gun",
+	// 			false,
+	// 			NaN,
+	// 			{},
+	// 			Infinity,
+	// 			[],
+	// 			1,
+	// 			0,
+	// 			-1,
+	// 		].forEach((enc) => {
+	// 			// @ts-expect-error This deliberately ignores the type constraint
+	// 			assertEquals(Buffer.isEncoding(enc), false);
+	// 		});
+	// 	},
+	// });
+
+	// Deno.test({
+	// 	name:
+	// 		"utf8Write handle missing optional length argument (https://github.com/denoland/deno_std/issues/2046)",
+	// 	fn() {
+	// 		const buf = Buffer.alloc(8);
+	// 		// @ts-expect-error Buffer.prototype.utf8Write is an undocumented API
+	// 		assertEquals(buf.utf8Write("abc", 0), 3);
+	// 		assertEquals([...buf], [0x61, 0x62, 0x63, 0, 0, 0, 0, 0]);
+	// 	},
+	// });
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from '@gjsify/deno_std/node/buffer';
+import buffer from '@gjsify/deno_std/node/buffer';
+export default buffer;