@slopware/sloppy-darwin-x64 0.1.0-alpha.0

package/stdlib/sloppy/node/assert/strict.js

@@ -0,0 +1,39 @@
+import base, {
+    AssertionError,
+    deepEqual,
+    deepStrictEqual,
+    doesNotReject,
+    doesNotThrow,
+    fail,
+    ifError,
+    notStrictEqual,
+    ok,
+    rejects,
+    strictEqual,
+    throws,
+} from "../assert.js";
+
+const equal = strictEqual;
+function strict(value, message = undefined) {
+    return ok(value, message);
+}
+
+Object.assign(strict, base, { equal });
+
+export {
+    AssertionError,
+    deepEqual,
+    deepStrictEqual,
+    doesNotReject,
+    doesNotThrow,
+    equal,
+    fail,
+    ifError,
+    notStrictEqual,
+    ok,
+    rejects,
+    strictEqual,
+    throws,
+};
+
+export default strict;

package/stdlib/sloppy/node/assert.js

@@ -0,0 +1,228 @@
+class AssertionError extends Error {
+    constructor(options = {}) {
+        super(options.message ?? "Assertion failed");
+        this.name = "AssertionError";
+        this.actual = options.actual;
+        this.expected = options.expected;
+        this.operator = options.operator;
+        this.code = "ERR_ASSERTION";
+    }
+}
+
+function internalFail(options) {
+    throw new AssertionError(options);
+}
+
+function fail(actual = undefined, expected = undefined, message = undefined, operator = "!=") {
+    if (arguments.length === 0) {
+        internalFail({ message: "Failed", operator: "fail" });
+    }
+    if (arguments.length === 1) {
+        if (actual instanceof Error) {
+            throw actual;
+        }
+        internalFail({ message: actual === undefined ? "Failed" : actual, operator: "fail" });
+    }
+    internalFail({
+        actual,
+        expected,
+        message: message ?? `${actual} ${operator} ${expected}`,
+        operator,
+    });
+}
+
+function ok(value, message = undefined) {
+    if (!value) {
+        internalFail({ actual: value, expected: true, operator: "ok", message });
+    }
+}
+
+function equal(actual, expected, message = undefined) {
+    if (actual != expected) {
+        internalFail({ actual, expected, operator: "==", message });
+    }
+}
+
+function strictEqual(actual, expected, message = undefined) {
+    if (!Object.is(actual, expected)) {
+        internalFail({ actual, expected, operator: "strictEqual", message });
+    }
+}
+
+function notStrictEqual(actual, expected, message = undefined) {
+    if (Object.is(actual, expected)) {
+        internalFail({ actual, expected, operator: "notStrictEqual", message });
+    }
+}
+
+function stable(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(stable).join(",")}]`;
+    }
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stable(value[key])}`).join(",")}}`;
+}
+
+function deepStrictEqual(actual, expected, message = undefined) {
+    if (stable(actual) !== stable(expected)) {
+        internalFail({ actual, expected, operator: "deepStrictEqual", message });
+    }
+}
+
+const deepEqual = deepStrictEqual;
+
+function matchExpected(error, expected) {
+    if (expected === undefined) {
+        return true;
+    }
+    if (typeof expected === "function") {
+        try {
+            if (error instanceof expected) {
+                return true;
+            }
+        } catch {
+        }
+        try {
+            return expected(error) === true;
+        } catch {
+            return false;
+        }
+    }
+    if (expected instanceof RegExp) {
+        return expected.test(String(error?.message ?? error));
+    }
+    if (expected !== null && typeof expected === "object") {
+        return Object.entries(expected).every(([key, value]) => Object.is(error?.[key], value));
+    }
+    return false;
+}
+
+function mismatch(error, expected, operator, message) {
+    internalFail({
+        actual: error,
+        expected,
+        operator,
+        message: message ?? `${operator} validation failed.`,
+    });
+}
+
+function isPromiseLike(value) {
+    return value !== null
+        && (typeof value === "object" || typeof value === "function")
+        && typeof value.then === "function";
+}
+
+function requirePromiseLike(value, operator) {
+    if (!isPromiseLike(value)) {
+        throw new TypeError(`${operator} expects a Promise or a function returning a Promise.`);
+    }
+    return value;
+}
+
+function throws(fn, expected = undefined, message = undefined) {
+    if (typeof fn !== "function") {
+        throw new TypeError("assert.throws expects a function.");
+    }
+    try {
+        fn();
+    } catch (error) {
+        if (!matchExpected(error, expected)) {
+            mismatch(error, expected, "throws", message);
+        }
+        return error;
+    }
+    internalFail({ actual: undefined, expected, operator: "throws", message });
+}
+
+function doesNotThrow(fn, expected = undefined, message = undefined) {
+    if (typeof fn !== "function") {
+        throw new TypeError("assert.doesNotThrow expects a function.");
+    }
+    if (typeof expected === "string" && message === undefined) {
+        message = expected;
+        expected = undefined;
+    }
+    try {
+        fn();
+    } catch (error) {
+        if (expected === undefined || matchExpected(error, expected)) {
+            mismatch(error, expected, "doesNotThrow", message);
+        }
+        throw error;
+    }
+}
+
+async function rejects(fn, expected = undefined, message = undefined) {
+    const promise = requirePromiseLike(typeof fn === "function" ? fn() : fn, "assert.rejects");
+    try {
+        await promise;
+    } catch (error) {
+        if (!matchExpected(error, expected)) {
+            mismatch(error, expected, "rejects", message);
+        }
+        return error;
+    }
+    internalFail({ actual: undefined, expected, operator: "rejects", message });
+}
+
+async function doesNotReject(fn, expected = undefined, message = undefined) {
+    if (typeof expected === "string" && message === undefined) {
+        message = expected;
+        expected = undefined;
+    }
+    const promise = requirePromiseLike(typeof fn === "function" ? fn() : fn, "assert.doesNotReject");
+    try {
+        await promise;
+    } catch (error) {
+        if (expected === undefined || matchExpected(error, expected)) {
+            mismatch(error, expected, "doesNotReject", message);
+        }
+        throw error;
+    }
+}
+
+function ifError(value) {
+    if (value !== null && value !== undefined) {
+        internalFail({ actual: value, expected: null, operator: "ifError", message: value?.message });
+    }
+}
+
+function assert(value, message = undefined) {
+    return ok(value, message);
+}
+
+Object.assign(assert, {
+    AssertionError,
+    deepEqual,
+    deepStrictEqual,
+    doesNotReject,
+    doesNotThrow,
+    equal,
+    fail,
+    ifError,
+    notStrictEqual,
+    ok,
+    rejects,
+    strictEqual,
+    throws,
+});
+
+export {
+    AssertionError,
+    deepEqual,
+    deepStrictEqual,
+    doesNotReject,
+    doesNotThrow,
+    equal,
+    fail,
+    ifError,
+    notStrictEqual,
+    ok,
+    rejects,
+    strictEqual,
+    throws,
+};
+
+export default assert;

package/stdlib/sloppy/node/buffer.js

@@ -0,0 +1,247 @@
+import { Base64, Base64Url, Hex, Text } from "../codec.js";
+
+function normalizeEncoding(encoding = "utf8") {
+    const normalized = String(encoding).toLowerCase();
+    if (normalized === "utf-8") {
+        return "utf8";
+    }
+    if (["utf8", "hex", "base64", "base64url"].includes(normalized)) {
+        return normalized;
+    }
+    throw new TypeError(`Sloppy Buffer encoding is not supported: ${encoding}`);
+}
+
+function bytesFromString(value, encoding) {
+    switch (normalizeEncoding(encoding)) {
+        case "utf8":
+            return Text.utf8.encode(value);
+        case "hex":
+            return Hex.decode(value);
+        case "base64":
+            return Base64.decode(value);
+        case "base64url":
+            return Base64Url.decode(value, { padding: "optional" });
+        default:
+            throw new TypeError(`Sloppy Buffer encoding is not supported: ${encoding}`);
+    }
+}
+
+function bytesToString(value, encoding) {
+    switch (normalizeEncoding(encoding)) {
+        case "utf8":
+            return Text.utf8.decode(value);
+        case "hex":
+            return Hex.encode(value);
+        case "base64":
+            return Base64.encode(value);
+        case "base64url":
+            return Base64Url.encode(value);
+        default:
+            throw new TypeError(`Sloppy Buffer encoding is not supported: ${encoding}`);
+    }
+}
+
+class Buffer extends Uint8Array {
+    static from(value, encoding = "utf8") {
+        if (typeof value === "string") {
+            return new Buffer(bytesFromString(value, encoding));
+        }
+        if (value instanceof ArrayBuffer || ArrayBuffer.isView(value) || Array.isArray(value)) {
+            return new Buffer(value);
+        }
+        throw new TypeError("Sloppy Buffer.from expects a string, bytes, or array.");
+    }
+
+    static compare(left, right) {
+        left = Buffer.from(left);
+        right = Buffer.from(right);
+        const length = Math.min(left.byteLength, right.byteLength);
+        for (let index = 0; index < length; index += 1) {
+            if (left[index] !== right[index]) {
+                return left[index] < right[index] ? -1 : 1;
+            }
+        }
+        if (left.byteLength === right.byteLength) {
+            return 0;
+        }
+        return left.byteLength < right.byteLength ? -1 : 1;
+    }
+
+    static isEncoding(encoding) {
+        if (encoding === undefined || encoding === null) {
+            return false;
+        }
+        try {
+            normalizeEncoding(encoding);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    static alloc(size, fill = 0) {
+        const buffer = new Buffer(size);
+        buffer.fill(fill);
+        return buffer;
+    }
+
+    static allocUnsafe(size) {
+        return Buffer.alloc(size);
+    }
+
+    static isBuffer(value) {
+        return value instanceof Buffer;
+    }
+
+    static byteLength(value, encoding = "utf8") {
+        return Buffer.from(value, encoding).byteLength;
+    }
+
+    static concat(list, totalLength = undefined) {
+        if (!Array.isArray(list)) {
+            throw new TypeError("Sloppy Buffer.concat expects an array.");
+        }
+        const buffers = list.map((entry) => Buffer.from(entry));
+        const length = totalLength === undefined
+            ? buffers.reduce((sum, entry) => sum + entry.byteLength, 0)
+            : Number(totalLength);
+        if (!Number.isInteger(length) || length < 0) {
+            throw new TypeError("Sloppy Buffer.concat totalLength must be a non-negative integer.");
+        }
+        const output = new Buffer(length);
+        let offset = 0;
+        for (const buffer of buffers) {
+            output.set(buffer.subarray(0, Math.max(0, length - offset)), offset);
+            offset += buffer.byteLength;
+            if (offset >= length) {
+                break;
+            }
+        }
+        return output;
+    }
+
+    equals(other) {
+        const buffer = Buffer.from(other);
+        if (buffer.byteLength !== this.byteLength) {
+            return false;
+        }
+        for (let index = 0; index < this.byteLength; index += 1) {
+            if (this[index] !== buffer[index]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    subarray(start = 0, end = undefined) {
+        const view = super.subarray(start, end);
+        Object.setPrototypeOf(view, Buffer.prototype);
+        return view;
+    }
+
+    slice(start = 0, end = undefined) {
+        return this.subarray(start, end);
+    }
+
+    compare(other) {
+        return Buffer.compare(this, other);
+    }
+
+    readUInt8(offset = 0) {
+        return this.#readUInt(offset, 1);
+    }
+
+    readUInt16LE(offset = 0) {
+        return this.#readUInt(offset, 2, true);
+    }
+
+    readUInt16BE(offset = 0) {
+        return this.#readUInt(offset, 2, false);
+    }
+
+    readUInt32LE(offset = 0) {
+        return this.#readUInt(offset, 4, true);
+    }
+
+    readUInt32BE(offset = 0) {
+        return this.#readUInt(offset, 4, false);
+    }
+
+    writeUInt8(value, offset = 0) {
+        return this.#writeUInt(value, offset, 1);
+    }
+
+    writeUInt16LE(value, offset = 0) {
+        return this.#writeUInt(value, offset, 2, true);
+    }
+
+    writeUInt16BE(value, offset = 0) {
+        return this.#writeUInt(value, offset, 2, false);
+    }
+
+    writeUInt32LE(value, offset = 0) {
+        return this.#writeUInt(value, offset, 4, true);
+    }
+
+    writeUInt32BE(value, offset = 0) {
+        return this.#writeUInt(value, offset, 4, false);
+    }
+
+    write(value, offset = 0, length = undefined, encoding = "utf8") {
+        if (typeof offset === "string") {
+            encoding = offset;
+            offset = 0;
+            length = undefined;
+        } else if (typeof length === "string") {
+            encoding = length;
+            length = undefined;
+        }
+        const bytes = Buffer.from(String(value), encoding);
+        const start = Number(offset);
+        const available = this.byteLength - start;
+        const count = Math.min(length === undefined ? bytes.byteLength : Number(length), available);
+        if (!Number.isInteger(start) || start < 0 || !Number.isInteger(count) || count < 0) {
+            throw new RangeError("Sloppy Buffer.write offset and length must be non-negative integers.");
+        }
+        this.set(bytes.subarray(0, count), start);
+        return count;
+    }
+
+    toString(encoding = "utf8") {
+        return bytesToString(this, encoding);
+    }
+
+    #checkBounds(offset, width) {
+        offset = Number(offset);
+        if (!Number.isInteger(offset) || offset < 0 || offset + width > this.byteLength) {
+            throw new RangeError("Sloppy Buffer offset is outside the buffer bounds.");
+        }
+        return offset;
+    }
+
+    #readUInt(offset, width, littleEndian = true) {
+        offset = this.#checkBounds(offset, width);
+        let value = 0;
+        for (let index = 0; index < width; index += 1) {
+            const byte = this[offset + (littleEndian ? index : width - 1 - index)];
+            value += byte * 2 ** (8 * index);
+        }
+        return value;
+    }
+
+    #writeUInt(value, offset, width, littleEndian = true) {
+        offset = this.#checkBounds(offset, width);
+        value = Number(value);
+        const max = 2 ** (8 * width);
+        if (!Number.isInteger(value) || value < 0 || value >= max) {
+            throw new RangeError("Sloppy Buffer unsigned integer value is outside the supported range.");
+        }
+        for (let index = 0; index < width; index += 1) {
+            this[offset + (littleEndian ? index : width - 1 - index)] = Math.floor(value / 2 ** (8 * index)) & 0xff;
+        }
+        return offset + width;
+    }
+}
+
+export { Buffer };
+export default { Buffer };

package/stdlib/sloppy/node/console.js

@@ -0,0 +1,33 @@
+const runtimeConsole = globalThis.console;
+
+const Console = runtimeConsole?.Console ?? class Console {
+    log(...values) {
+        runtimeConsole?.log?.(...values);
+    }
+
+    error(...values) {
+        runtimeConsole?.error?.(...values);
+    }
+
+    warn(...values) {
+        (runtimeConsole?.warn ?? runtimeConsole?.log)?.(...values);
+    }
+
+    info(...values) {
+        (runtimeConsole?.info ?? runtimeConsole?.log)?.(...values);
+    }
+
+    debug(...values) {
+        (runtimeConsole?.debug ?? runtimeConsole?.log)?.(...values);
+    }
+};
+
+const log = runtimeConsole?.log?.bind(runtimeConsole) ?? (() => {});
+const error = runtimeConsole?.error?.bind(runtimeConsole) ?? (() => {});
+const warn = runtimeConsole?.warn?.bind(runtimeConsole) ?? log;
+const info = runtimeConsole?.info?.bind(runtimeConsole) ?? log;
+const debug = runtimeConsole?.debug?.bind(runtimeConsole) ?? log;
+const consoleModule = runtimeConsole ?? { Console, debug, error, info, log, warn };
+
+export { Console, debug, error, info, log, warn };
+export default consoleModule;

package/stdlib/sloppy/node/constants.js

@@ -0,0 +1,9 @@
+const O_RDONLY = 0;
+const O_WRONLY = 1;
+const O_RDWR = 2;
+const S_IFMT = 0o170000;
+const S_IFREG = 0o100000;
+const S_IFDIR = 0o040000;
+
+export { O_RDONLY, O_RDWR, O_WRONLY, S_IFDIR, S_IFMT, S_IFREG };
+export default { O_RDONLY, O_RDWR, O_WRONLY, S_IFDIR, S_IFMT, S_IFREG };

package/stdlib/sloppy/node/crypto.js

@@ -0,0 +1,89 @@
+import { ConstantTime, Hash, Hmac, Random, Secret } from "../crypto.js";
+import { Hex, Text } from "../codec.js";
+
+function randomBytes(size) {
+    return Random.bytes(size);
+}
+
+function randomUUID() {
+    return Random.uuid();
+}
+
+function normalizeAlgorithm(algorithm, operation) {
+    const normalized = String(algorithm).toLowerCase().replace(/-/g, "");
+    if (normalized === "sha256") {
+        return "sha256";
+    }
+    if (normalized === "sha384") {
+        return "sha384";
+    }
+    if (normalized === "sha512") {
+        return "sha512";
+    }
+    throw new TypeError(`SLOPPY_E_NODE_CRYPTO_UNSUPPORTED: node:crypto.${operation} only supports sha256, sha384, and sha512.`);
+}
+
+function createHash(algorithm) {
+    return Hash.create(normalizeAlgorithm(algorithm, "createHash"));
+}
+
+function bytesFrom(value, operation) {
+    if (typeof value === "string") {
+        return Text.utf8.encode(value);
+    }
+    if (value instanceof ArrayBuffer) {
+        return new Uint8Array(value).slice();
+    }
+    if (ArrayBuffer.isView(value)) {
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength).slice();
+    }
+    throw new TypeError(`${operation} requires a string, ArrayBuffer, or typed-array bytes.`);
+}
+
+function secretFrom(value) {
+    return typeof value === "string"
+        ? Secret.fromUtf8(value)
+        : Secret.fromBytes(bytesFrom(value, "node:crypto.createHmac key"));
+}
+
+function createHmac(algorithm, key) {
+    const normalized = normalizeAlgorithm(algorithm, "createHmac");
+    if (normalized !== "sha256") {
+        throw new TypeError("SLOPPY_E_NODE_CRYPTO_UNSUPPORTED: node:crypto.createHmac currently supports sha256.");
+    }
+    const secret = secretFrom(key);
+    const chunks = [];
+    return {
+        update(value) {
+            chunks.push(bytesFrom(value, "node:crypto.Hmac.update"));
+            return this;
+        },
+        async digest(encoding = undefined) {
+            const length = chunks.reduce((total, chunk) => total + chunk.byteLength, 0);
+            const input = new Uint8Array(length);
+            let offset = 0;
+            for (const chunk of chunks) {
+                input.set(chunk, offset);
+                offset += chunk.byteLength;
+            }
+            const bytes = await Hmac.sha256(secret, input);
+            if (encoding === "hex") {
+                return Hex.encode(bytes);
+            }
+            if (encoding !== undefined && encoding !== "bytes") {
+                throw new TypeError("Sloppy node:crypto Hmac digest encoding must be bytes or hex.");
+            }
+            return bytes;
+        },
+    };
+}
+
+function timingSafeEqual(left, right) {
+    if (left.byteLength !== right.byteLength) {
+        throw new RangeError("Input buffers must have the same byte length.");
+    }
+    return ConstantTime.equals(left, right);
+}
+
+export { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual };
+export default { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual };

package/stdlib/sloppy/node/diagnostics_channel.js

@@ -0,0 +1,41 @@
+import { EventEmitter } from "./events.js";
+
+const channels = new Map();
+
+class Channel extends EventEmitter {
+    constructor(name) {
+        super();
+        this.name = name;
+    }
+
+    publish(message) {
+        this.emit("message", message, this.name);
+    }
+
+    subscribe(listener) {
+        this.on("message", listener);
+    }
+
+    unsubscribe(listener) {
+        this.removeListener("message", listener);
+    }
+
+    hasSubscribers() {
+        return this.listenerCount("message") > 0;
+    }
+}
+
+function channel(name) {
+    name = String(name);
+    if (!channels.has(name)) {
+        channels.set(name, new Channel(name));
+    }
+    return channels.get(name);
+}
+
+function hasSubscribers(name) {
+    return channels.get(String(name))?.hasSubscribers() ?? false;
+}
+
+export { channel, hasSubscribers };
+export default { channel, hasSubscribers };