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

package/stdlib/sloppy/node/process.js

@@ -0,0 +1,129 @@
+import { Environment, Process } from "../os.js";
+import { EventEmitter } from "./events.js";
+
+const env = new Proxy(Object.create(null), {
+    get(target, key) {
+        if (typeof key !== "string") {
+            return undefined;
+        }
+        return Object.prototype.hasOwnProperty.call(target, key) ? target[key] : Environment.get(key);
+    },
+    has(target, key) {
+        return typeof key === "string" && (Object.prototype.hasOwnProperty.call(target, key) || Environment.has(key));
+    },
+    set(target, key, value) {
+        if (typeof key !== "string") {
+            return false;
+        }
+        target[key] = String(value);
+        return true;
+    },
+    ownKeys(target) {
+        return [...new Set([...Object.keys(target), ...(Environment.list?.() ?? [])])];
+    },
+    getOwnPropertyDescriptor(target, key) {
+        const value = typeof key === "string"
+            ? (Object.prototype.hasOwnProperty.call(target, key) ? target[key] : Environment.get(key))
+            : undefined;
+        return value === undefined ? undefined : {
+            configurable: true,
+            enumerable: true,
+            value,
+        };
+    },
+});
+
+const monotonicMs = () => {
+    const bridge = globalThis.__sloppy?.time;
+    if (bridge && typeof bridge.monotonicMs === "function") {
+        return bridge.monotonicMs();
+    }
+    if (globalThis.performance && typeof globalThis.performance.now === "function") {
+        return globalThis.performance.now();
+    }
+    return Date.now();
+};
+const startedAt = monotonicMs();
+const emitter = new EventEmitter();
+const on = emitter.on.bind(emitter);
+const off = emitter.off.bind(emitter);
+const addListener = emitter.addListener.bind(emitter);
+const removeListener = emitter.removeListener.bind(emitter);
+const emit = emitter.emit.bind(emitter);
+const once = emitter.once.bind(emitter);
+const argv = Object.freeze(globalThis.__sloppy_program_args?.slice?.() ?? []);
+const cwd = () => globalThis.__sloppy_program_context?.cwd ?? ".";
+const platform = globalThis.__sloppy_runtime?.System?.platform ?? "sloppy";
+const arch = globalThis.__sloppy_runtime?.System?.arch ?? "unknown";
+const sloppyVersion = String(globalThis.__sloppy_runtime?.System?.version ?? "0.1.0");
+const version = sloppyVersion.startsWith("sloppy-") ? sloppyVersion : `sloppy-${sloppyVersion}`;
+const versions = Object.freeze({ sloppy: version.replace(/^sloppy-/, "") });
+const release = Object.freeze({ name: "sloppy", sourceUrl: "https://github.com/RtlZeroMemory/Slop" });
+let exitCode = undefined;
+const nextTick = (fn, ...args) => Promise.resolve().then(() => fn(...args));
+const exit = (code = 0) => {
+    throw new Error(`SLOPPY_E_PROCESS_EXIT_UNSUPPORTED: process.exit(${code}) is not supported.`);
+};
+const hrtimeNanos = () => BigInt(Math.max(0, Math.floor(monotonicMs() * 1000000)));
+const uptime = () => Math.max(0, (monotonicMs() - startedAt) / 1000);
+const hrtime = (previous = undefined) => {
+    const now = hrtimeNanos();
+    const seconds = Number(now / 1000000000n);
+    const nanos = Number(now % 1000000000n);
+    if (previous === undefined) {
+        return [seconds, nanos];
+    }
+    const previousNanos = BigInt(previous[0]) * 1000000000n + BigInt(previous[1]);
+    const diff = now - previousNanos;
+    return [Number(diff / 1000000000n), Number(diff % 1000000000n)];
+};
+hrtime.bigint = hrtimeNanos;
+const memoryUsage = () => Object.freeze({
+    arrayBuffers: 0,
+    external: 0,
+    heapTotal: 0,
+    heapUsed: 0,
+    rss: 0,
+});
+const stream = (name) => Object.freeze({
+    isTTY: false,
+    write() {
+        throw new Error(`SLOPPY_E_PROCESS_STREAM_WRITE_UNSUPPORTED: process.${name}.write is not available in Sloppy's Node compatibility shim.`);
+    },
+});
+
+const process = {
+    arch,
+    argv,
+    browser: false,
+    cwd,
+    env,
+    emit,
+    exit,
+    get exitCode() {
+        return exitCode;
+    },
+    set exitCode(value) {
+        exitCode = value;
+    },
+    hrtime,
+    memoryUsage,
+    nextTick,
+    off,
+    removeListener,
+    on,
+    addListener,
+    once,
+    platform,
+    release,
+    stderr: stream("stderr"),
+    stdin: Object.freeze({ isTTY: false }),
+    stdout: stream("stdout"),
+    uptime,
+    version,
+    versions,
+    Process,
+};
+
+export { addListener, arch, argv, cwd, emit, env, exit, hrtime, memoryUsage, nextTick, off, on, once, platform, Process, release, removeListener, uptime, version, versions };
+export default process;

package/stdlib/sloppy/node/querystring.js

@@ -0,0 +1,21 @@
+function parse(input = "") {
+    const output = Object.create(null);
+    for (const part of String(input).split("&")) {
+        if (part === "") {
+            continue;
+        }
+        const [rawKey, rawValue = ""] = part.split("=");
+        output[decodeURIComponent(rawKey.replace(/\+/g, " "))] =
+            decodeURIComponent(rawValue.replace(/\+/g, " "));
+    }
+    return output;
+}
+
+function stringify(value = {}) {
+    return Object.entries(value)
+        .map(([key, item]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(item))}`)
+        .join("&");
+}
+
+export { parse, stringify };
+export default { parse, stringify };

package/stdlib/sloppy/node/stream/promises.js

@@ -0,0 +1,3 @@
+export { pipeline } from "../stream.js";
+
+export default { pipeline };

package/stdlib/sloppy/node/stream.js

@@ -0,0 +1,132 @@
+import { EventEmitter } from "./events.js";
+
+class Stream extends EventEmitter {}
+
+class Readable extends Stream {
+    static from(iterable) {
+        const readable = new Readable();
+        readable._iterable = iterable;
+        return readable;
+    }
+
+    async *[Symbol.asyncIterator]() {
+        for await (const chunk of this._iterable ?? []) {
+            yield chunk;
+        }
+    }
+}
+
+class Writable extends Stream {
+    constructor(options = {}) {
+        super();
+        this._write = typeof options.write === "function" ? options.write : undefined;
+        this.chunks = [];
+        this._pendingWrites = new Set();
+        this._finished = Promise.resolve(this);
+    }
+
+    _invokeWrite(chunk) {
+        return new Promise((resolve, reject) => {
+            try {
+                if (this._write) {
+                    if (this._write.length >= 3) {
+                        this._write(chunk, undefined, (error) => error ? reject(error) : resolve());
+                    } else {
+                        Promise.resolve(this._write(chunk)).then(resolve, reject);
+                    }
+                } else {
+                    this.chunks.push(chunk);
+                    resolve();
+                }
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+
+    _trackWrite(promise) {
+        const tracked = Promise.resolve(promise).finally(() => this._pendingWrites.delete(tracked));
+        this._pendingWrites.add(tracked);
+        return tracked;
+    }
+
+    write(chunk, encodingOrCallback = undefined, callback = undefined) {
+        const done = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+        this._trackWrite(this._invokeWrite(chunk)).then(
+            () => {
+                if (typeof done === "function") {
+                    done();
+                }
+                this.emit("drain");
+            },
+            (error) => {
+                if (typeof done === "function") {
+                    done(error);
+                }
+                this.emit("error", error);
+            },
+        );
+        return true;
+    }
+
+    end(chunk = undefined, encodingOrCallback = undefined, callback = undefined) {
+        if (typeof chunk === "function") {
+            callback = chunk;
+            chunk = undefined;
+        } else if (typeof encodingOrCallback === "function") {
+            callback = encodingOrCallback;
+        }
+        if (chunk !== undefined) {
+            this.write(chunk);
+        }
+        if (typeof callback === "function") {
+            this.once("finish", callback);
+        }
+        this._finished = Promise.all([...this._pendingWrites]).then(
+            () => {
+                this.emit("finish");
+                return this;
+            },
+            (error) => {
+                this.emit("error", error);
+                throw error;
+            },
+        );
+        return this;
+    }
+
+    get finished() {
+        return this._finished;
+    }
+}
+
+class PassThrough extends Writable {
+    write(chunk, encodingOrCallback = undefined, callback = undefined) {
+        super.write(chunk, encodingOrCallback, callback);
+        this.emit("data", chunk);
+        return true;
+    }
+}
+
+async function pipeline(source, destination, callback = undefined) {
+    try {
+        for await (const chunk of source) {
+            destination.write(chunk);
+        }
+        destination.end();
+        await destination.finished;
+        if (typeof callback === "function") {
+            callback();
+        }
+        return destination;
+    } catch (error) {
+        if (typeof callback === "function") {
+            callback(error);
+            return destination;
+        }
+        throw error;
+    }
+}
+
+export { PassThrough, Readable, Stream, Writable, pipeline };
+export default { PassThrough, Readable, Stream, Writable, pipeline };

package/stdlib/sloppy/node/string_decoder.js

@@ -0,0 +1,23 @@
+import { Text } from "../codec.js";
+
+class StringDecoder {
+    constructor(encoding = "utf8") {
+        const normalized = String(encoding).toLowerCase();
+        if (normalized !== "utf8" && normalized !== "utf-8") {
+            throw new TypeError("Sloppy string_decoder only supports utf8.");
+        }
+        this._decoder = Text.utf8.decoder();
+    }
+
+    write(buffer) {
+        return this._decoder.decode(buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer), { stream: true });
+    }
+
+    end(buffer = undefined) {
+        const text = buffer === undefined ? "" : this.write(buffer);
+        return text + this._decoder.finish();
+    }
+}
+
+export { StringDecoder };
+export default { StringDecoder };

package/stdlib/sloppy/node/timers.js

@@ -0,0 +1,26 @@
+import { Time } from "../time.js";
+
+function setTimeout(handler, delay = 0, ...args) {
+    const timer = { cancelled: false };
+    Time.delay(delay).then(() => {
+        if (!timer.cancelled) {
+            handler(...args);
+        }
+    });
+    return timer;
+}
+
+function clearTimeout(timer) {
+    if (timer !== null && typeof timer === "object") {
+        timer.cancelled = true;
+    }
+}
+
+function setImmediate(handler, ...args) {
+    return setTimeout(handler, 0, ...args);
+}
+
+const clearImmediate = clearTimeout;
+
+export { clearImmediate, clearTimeout, setImmediate, setTimeout };
+export default { clearImmediate, clearTimeout, setImmediate, setTimeout };

package/stdlib/sloppy/node/tty.js

@@ -0,0 +1,18 @@
+function isatty() {
+    return false;
+}
+
+class ReadStream {
+    constructor() {
+        this.isTTY = false;
+    }
+}
+
+class WriteStream {
+    constructor() {
+        this.isTTY = false;
+    }
+}
+
+export { isatty, ReadStream, WriteStream };
+export default { isatty, ReadStream, WriteStream };

package/stdlib/sloppy/node/url.js

@@ -0,0 +1,17 @@
+const URLCtor = globalThis.URL;
+const URLSearchParamsCtor = globalThis.URLSearchParams;
+
+function pathToFileURL(path) {
+    return new URLCtor(`file://${String(path).replace(/\\/g, "/")}`);
+}
+
+function fileURLToPath(url) {
+    const parsed = url instanceof URLCtor ? url : new URLCtor(String(url));
+    if (parsed.protocol !== "file:") {
+        throw new TypeError("fileURLToPath requires a file: URL.");
+    }
+    return decodeURIComponent(parsed.pathname);
+}
+
+export { fileURLToPath, pathToFileURL, URLCtor as URL, URLSearchParamsCtor as URLSearchParams };
+export default { URL: URLCtor, URLSearchParams: URLSearchParamsCtor, fileURLToPath, pathToFileURL };

package/stdlib/sloppy/node/util.js

@@ -0,0 +1,95 @@
+function inspect(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "function") {
+        return value.name ? `[Function: ${value.name}]` : "[Function]";
+    }
+    try {
+        return JSON.stringify(value);
+    } catch (_) {
+        return String(value);
+    }
+}
+
+function format(first = "", ...rest) {
+    if (typeof first !== "string") {
+        return [first, ...rest].map(inspect).join(" ");
+    }
+    let index = 0;
+    const text = first.replace(/%[sdjifoO%]/g, (token) => {
+        if (token === "%%") {
+            return "%";
+        }
+        if (index >= rest.length) {
+            return token;
+        }
+        const value = rest[index];
+        index += 1;
+        if (token === "%s") {
+            return String(value);
+        }
+        if (token === "%d") {
+            return String(Number(value));
+        }
+        if (token === "%i") {
+            return String(Number.parseInt(value, 10));
+        }
+        if (token === "%f") {
+            return String(Number.parseFloat(value));
+        }
+        if (token === "%j") {
+            try {
+                return JSON.stringify(value);
+            } catch {
+                return "[Circular]";
+            }
+        }
+        return inspect(value);
+    });
+    return [text, ...rest.slice(index).map(inspect)].join(" ");
+}
+
+function promisify(fn) {
+    if (typeof fn !== "function") {
+        throw new TypeError("util.promisify expects a function.");
+    }
+    return (...args) => new Promise((resolve, reject) => {
+        fn(...args, (error, value) => (error ? reject(error) : resolve(value)));
+    });
+}
+
+function callbackify(fn) {
+    if (typeof fn !== "function") {
+        throw new TypeError("util.callbackify expects a function.");
+    }
+    return (...args) => {
+        const callback = args.pop();
+        Promise.resolve()
+            .then(() => fn(...args))
+            .then((value) => callback(null, value), (error) => callback(error));
+    };
+}
+
+function inherits(ctor, superCtor) {
+    if (typeof ctor !== "function" || typeof superCtor !== "function") {
+        throw new TypeError("util.inherits expects constructor functions.");
+    }
+    Object.setPrototypeOf(ctor.prototype, superCtor.prototype);
+    Object.defineProperty(ctor.prototype, "constructor", {
+        configurable: true,
+        enumerable: false,
+        value: ctor,
+        writable: true,
+    });
+}
+
+const types = Object.freeze({
+    isArrayBufferView: ArrayBuffer.isView,
+    isDate: (value) => value instanceof Date,
+    isRegExp: (value) => value instanceof RegExp,
+    isUint8Array: (value) => value instanceof Uint8Array,
+});
+
+export { callbackify, format, inherits, inspect, promisify, types };
+export default { callbackify, format, inherits, inspect, promisify, types };

package/stdlib/sloppy/node/zlib.js

@@ -0,0 +1,72 @@
+import { Compression, Text } from "../codec.js";
+
+function toBytes(value) {
+    if (typeof value === "string") {
+        return Text.utf8.encode(value);
+    }
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    if (value instanceof ArrayBuffer) {
+        return new Uint8Array(value);
+    }
+    if (ArrayBuffer.isView(value)) {
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+    throw new TypeError("Sloppy node:zlib input must be a string or bytes.");
+}
+
+function callbackify(promiseFactory, callback) {
+    if (typeof callback !== "function") {
+        throw new TypeError("Sloppy node:zlib callback API requires a callback.");
+    }
+    promiseFactory().then((value) => callback(null, value), (error) => callback(error));
+}
+
+function gzip(input, options, callback) {
+    if (typeof options === "function") {
+        callback = options;
+        options = undefined;
+    }
+    callbackify(() => Compression.gzip(toBytes(input), options), callback);
+}
+
+function gunzip(input, options, callback) {
+    if (typeof options === "function") {
+        callback = options;
+        options = undefined;
+    }
+    callbackify(() => Compression.gunzip(toBytes(input), options), callback);
+}
+
+function unsupportedAsync(name, input, options, callback) {
+    if (typeof options === "function") {
+        callback = options;
+        options = undefined;
+    }
+    callbackify(
+        () => Promise.reject(new Error(`SLOPPY_E_NODE_ZLIB_UNSUPPORTED: node:zlib.${name} is not implemented by Sloppy's Node compatibility shim.`)),
+        callback,
+    );
+}
+
+function deflate(input, options, callback) {
+    unsupportedAsync("deflate", input, options, callback);
+}
+
+function inflate(input, options, callback) {
+    unsupportedAsync("inflate", input, options, callback);
+}
+
+function unsupportedSync(name) {
+    return () => {
+        throw new Error(`SLOPPY_E_NODE_ZLIB_SYNC_UNSUPPORTED: node:zlib.${name} is not available because Sloppy compression is async.`);
+    };
+}
+
+export { deflate, gzip, gunzip, inflate };
+export const gzipSync = unsupportedSync("gzipSync");
+export const gunzipSync = unsupportedSync("gunzipSync");
+export const deflateSync = unsupportedSync("deflateSync");
+export const inflateSync = unsupportedSync("inflateSync");
+export default { deflate, deflateSync, gzip, gzipSync, gunzip, gunzipSync, inflate, inflateSync };