@entelligentsia/forgecli 0.3.0 → 0.7.6

package/node_modules/@entelligentsia/pi-tui/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@entelligentsia/pi-tui",
+  "version": "0.75.0",
+  "description": "Terminal User Interface library with differential rendering for efficient text-based applications",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "clean": "shx rm -rf dist",
+    "build": "tsgo -p tsconfig.build.json",
+    "dev": "tsgo -p tsconfig.build.json --watch --preserveWatchOutput",
+    "test": "node --test --import tsx test/*.test.ts",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ],
+  "keywords": [
+    "tui",
+    "terminal",
+    "ui",
+    "text-editor",
+    "differential-rendering",
+    "typescript",
+    "cli"
+  ],
+  "author": "Mario Zechner",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/earendil-works/pi-mono.git",
+    "directory": "packages/tui"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "@types/mime-types": "^2.1.4",
+    "chalk": "^5.5.0",
+    "get-east-asian-width": "^1.3.0",
+    "marked": "^15.0.12",
+    "mime-types": "^3.0.1"
+  },
+  "devDependencies": {
+    "@xterm/headless": "^5.5.0",
+    "@xterm/xterm": "^5.5.0"
+  }
+}

package/node_modules/@smithy/core/checksum.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Do not edit:
+ * This is a compatibility redirect for bundlers that do not support package.json exports field.
+ */
+export * from "./dist-types/submodules/checksum/index.d";

package/node_modules/@smithy/core/checksum.js

@@ -0,0 +1,5 @@
+/**
+ * Do not edit:
+ * This is a compatibility redirect for bundlers that do not support package.json exports field.
+ */
+module.exports = require("./dist-cjs/submodules/checksum/index.js");

package/node_modules/@smithy/core/client.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Do not edit:
+ * This is a compatibility redirect for contexts that do not understand package.json exports field.
+ */
+declare module "@smithy/core/client" {
+  export * from "@smithy/core/dist-types/submodules/client/index.d";
+}

package/node_modules/@smithy/core/client.js

@@ -0,0 +1,6 @@
+
+/**
+ * Do not edit:
+ * This is a compatibility redirect for contexts that do not understand package.json exports field.
+ */
+module.exports = require("./dist-cjs/submodules/client/index.js");

package/node_modules/@smithy/core/config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Do not edit:
+ * This is a compatibility redirect for bundlers that do not support package.json exports field.
+ */
+export * from "./dist-types/submodules/config/index.d";

package/node_modules/@smithy/core/config.js

@@ -0,0 +1,5 @@
+/**
+ * Do not edit:
+ * This is a compatibility redirect for bundlers that do not support package.json exports field.
+ */
+module.exports = require("./dist-cjs/submodules/config/index.js");

package/node_modules/@smithy/core/dist-cjs/index.js

@@ -1,9 +1,8 @@
 'use strict';
 
 var types = require('@smithy/types');
-var protocolHttp = require('@smithy/protocol-http');
-var utilMiddleware = require('@smithy/util-middleware');
 var protocols = require('@smithy/core/protocols');
+var client = require('@smithy/core/client');
 
 const getSmithyContext = (context) => context[types.SMITHY_CONTEXT_KEY] || (context[types.SMITHY_CONTEXT_KEY] = {});
 
@@ -40,7 +39,7 @@ const httpAuthSchemeMiddleware = (config, mwOptions) => (next, context) => async
     const authSchemePreference = config.authSchemePreference ? await config.authSchemePreference() : [];
     const resolvedOptions = resolveAuthOptions(options, authSchemePreference);
     const authSchemes = convertHttpAuthSchemesToMap(config.httpAuthSchemes);
-    const smithyContext = utilMiddleware.getSmithyContext(context);
+    const smithyContext = client.getSmithyContext(context);
     const failureReasons = [];
     for (const option of resolvedOptions) {
         const scheme = authSchemes.get(option.schemeId);
@@ -108,10 +107,10 @@ const defaultErrorHandler = (signingProperties) => (error) => {
 };
 const defaultSuccessHandler = (httpResponse, signingProperties) => { };
 const httpSigningMiddleware = (config) => (next, context) => async (args) => {
-    if (!protocolHttp.HttpRequest.isInstance(args.request)) {
+    if (!protocols.HttpRequest.isInstance(args.request)) {
         return next(args);
     }
-    const smithyContext = utilMiddleware.getSmithyContext(context);
+    const smithyContext = client.getSmithyContext(context);
     const scheme = smithyContext.selectedHttpAuthScheme;
     if (!scheme) {
         throw new Error(`No HttpAuthScheme was selected: unable to sign request`);
@@ -230,7 +229,7 @@ class HttpApiKeyAuthSigner {
         if (!identity.apiKey) {
             throw new Error("request could not be signed with `apiKey` since the `apiKey` is not defined");
         }
-        const clonedRequest = protocolHttp.HttpRequest.clone(httpRequest);
+        const clonedRequest = protocols.HttpRequest.clone(httpRequest);
         if (signingProperties.in === types.HttpApiKeyAuthLocation.QUERY) {
             clonedRequest.query[signingProperties.name] = identity.apiKey;
         }
@@ -251,7 +250,7 @@ class HttpApiKeyAuthSigner {
 
 class HttpBearerAuthSigner {
     async sign(httpRequest, identity, signingProperties) {
-        const clonedRequest = protocolHttp.HttpRequest.clone(httpRequest);
+        const clonedRequest = protocols.HttpRequest.clone(httpRequest);
         if (!identity.token) {
             throw new Error("request could not be signed with `token` since the `token` is not defined");
         }

package/node_modules/@smithy/core/dist-cjs/middleware-http-auth-scheme/httpAuthSchemeMiddleware.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.httpAuthSchemeMiddleware = void 0;
-const util_middleware_1 = require("@smithy/util-middleware");
+const client_1 = require("@smithy/core/client");
 const resolveAuthOptions_1 = require("./resolveAuthOptions");
 function convertHttpAuthSchemesToMap(httpAuthSchemes) {
     const map = new Map();
@@ -15,7 +15,7 @@ const httpAuthSchemeMiddleware = (config, mwOptions) => (next, context) => async
     const authSchemePreference = config.authSchemePreference ? await config.authSchemePreference() : [];
     const resolvedOptions = (0, resolveAuthOptions_1.resolveAuthOptions)(options, authSchemePreference);
     const authSchemes = convertHttpAuthSchemesToMap(config.httpAuthSchemes);
-    const smithyContext = (0, util_middleware_1.getSmithyContext)(context);
+    const smithyContext = (0, client_1.getSmithyContext)(context);
     const failureReasons = [];
     for (const option of resolvedOptions) {
         const scheme = authSchemes.get(option.schemeId);

package/node_modules/@smithy/core/dist-cjs/middleware-http-signing/httpSigningMiddleware.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.httpSigningMiddleware = void 0;
-const protocol_http_1 = require("@smithy/protocol-http");
-const util_middleware_1 = require("@smithy/util-middleware");
+const client_1 = require("@smithy/core/client");
+const protocols_1 = require("@smithy/core/protocols");
 const defaultErrorHandler = (signingProperties) => (error) => {
     throw error;
 };
 const defaultSuccessHandler = (httpResponse, signingProperties) => { };
 const httpSigningMiddleware = (config) => (next, context) => async (args) => {
-    if (!protocol_http_1.HttpRequest.isInstance(args.request)) {
+    if (!protocols_1.HttpRequest.isInstance(args.request)) {
         return next(args);
     }
-    const smithyContext = (0, util_middleware_1.getSmithyContext)(context);
+    const smithyContext = (0, client_1.getSmithyContext)(context);
     const scheme = smithyContext.selectedHttpAuthScheme;
     if (!scheme) {
         throw new Error(`No HttpAuthScheme was selected: unable to sign request`);

package/node_modules/@smithy/core/dist-cjs/submodules/cbor/index.js

@@ -1,13 +1,9 @@
 'use strict';
 
 var serde = require('@smithy/core/serde');
-var utilUtf8 = require('@smithy/util-utf8');
 var protocols = require('@smithy/core/protocols');
-var protocolHttp = require('@smithy/protocol-http');
-var utilBodyLengthBrowser = require('@smithy/util-body-length-browser');
+var client = require('@smithy/core/client');
 var schema = require('@smithy/core/schema');
-var utilMiddleware = require('@smithy/util-middleware');
-var utilBase64 = require('@smithy/util-base64');
 
 const majorUint64 = 0;
 const majorNegativeInt64 = 1;
@@ -185,7 +181,7 @@ function bytesToUtf8(bytes, at, to) {
     if (textDecoder) {
         return textDecoder.decode(bytes.subarray(at, to));
     }
-    return utilUtf8.toUtf8(bytes.subarray(at, to));
+    return serde.toUtf8(bytes.subarray(at, to));
 }
 function demote(bigInteger) {
     const num = Number(bigInteger);
@@ -529,7 +525,7 @@ function encode(_input) {
                 cursor += data.write(input, cursor);
             }
             else {
-                const bytes = utilUtf8.fromUtf8(input);
+                const bytes = serde.fromUtf8(input);
                 encodeHeader(majorUtf8String, bytes.byteLength);
                 data.set(bytes, cursor);
                 cursor += bytes.byteLength;
@@ -785,11 +781,11 @@ const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, bod
     if (body !== undefined) {
         contents.body = body;
         try {
-            contents.headers["content-length"] = String(utilBodyLengthBrowser.calculateBodyLength(body));
+            contents.headers["content-length"] = String(serde.calculateBodyLength(body));
         }
         catch (e) { }
     }
-    return new protocolHttp.HttpRequest(contents);
+    return new protocols.HttpRequest(contents);
 };
 
 class CborCodec extends protocols.SerdeContext {
@@ -819,7 +815,7 @@ class CborShapeSerializer extends protocols.SerdeContext {
         }
         if (ns.isBlobSchema()) {
             if (typeof source === "string") {
-                return (this.serdeContext?.base64Decoder ?? utilBase64.fromBase64)(source);
+                return (this.serdeContext?.base64Decoder ?? serde.fromBase64)(source);
             }
             return source;
         }
@@ -913,7 +909,7 @@ class CborShapeDeserializer extends protocols.SerdeContext {
         }
         if (ns.isBlobSchema()) {
             if (typeof value === "string") {
-                return (this.serdeContext?.base64Decoder ?? utilBase64.fromBase64)(value);
+                return (this.serdeContext?.base64Decoder ?? serde.fromBase64)(value);
             }
             return value;
         }
@@ -1038,7 +1034,7 @@ class SmithyRpcV2CborProtocol extends protocols.RpcProtocol {
             }
             catch (e) { }
         }
-        const { service, operation } = utilMiddleware.getSmithyContext(context);
+        const { service, operation } = client.getSmithyContext(context);
         const path = `/service/${service}/operation/${operation}`;
         if (request.path.endsWith("/")) {
             request.path += path.slice(1);
@@ -1084,7 +1080,7 @@ class SmithyRpcV2CborProtocol extends protocols.RpcProtocol {
         const ns = schema.NormalizedSchema.of(errorSchema);
         const ErrorCtor = registry.getErrorCtor(errorSchema);
         const message = dataObject.message ?? dataObject.Message ?? "Unknown";
-        const exception = new ErrorCtor(message);
+        const exception = new ErrorCtor({});
         const output = {};
         for (const [name, member] of ns.structIterator()) {
             output[name] = this.deserializer.readValue(member, dataObject[name]);

package/node_modules/@smithy/core/dist-cjs/submodules/checksum/index.browser.js

@@ -0,0 +1,202 @@
+'use strict';
+
+var serde = require('@smithy/core/serde');
+
+async function blobReader(blob, onChunk, chunkSize = 1024 * 1024) {
+    const size = blob.size;
+    let totalBytesRead = 0;
+    while (totalBytesRead < size) {
+        const slice = blob.slice(totalBytesRead, Math.min(size, totalBytesRead + chunkSize));
+        onChunk(new Uint8Array(await slice.arrayBuffer()));
+        totalBytesRead += slice.size;
+    }
+}
+
+const blobHasher = async function blobHasher(hashCtor, blob) {
+    const hash = new hashCtor();
+    await blobReader(blob, (chunk) => {
+        hash.update(chunk);
+    });
+    return hash.digest();
+};
+
+const BLOCK_SIZE = 64;
+const DIGEST_LENGTH = 16;
+const INIT = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476];
+
+class Md5 {
+    state;
+    buffer;
+    bufferLength;
+    bytesHashed;
+    finished;
+    constructor() {
+        this.reset();
+    }
+    update(sourceData) {
+        if (isEmptyData(sourceData)) {
+            return;
+        }
+        else if (this.finished) {
+            throw new Error("Attempted to update an already finished hash.");
+        }
+        const data = convertToBuffer(sourceData);
+        let position = 0;
+        let { byteLength } = data;
+        this.bytesHashed += byteLength;
+        while (byteLength > 0) {
+            this.buffer.setUint8(this.bufferLength++, data[position++]);
+            byteLength--;
+            if (this.bufferLength === BLOCK_SIZE) {
+                this.hashBuffer();
+                this.bufferLength = 0;
+            }
+        }
+    }
+    async digest() {
+        if (!this.finished) {
+            const { buffer, bufferLength: undecoratedLength, bytesHashed } = this;
+            const bitsHashed = bytesHashed * 8;
+            buffer.setUint8(this.bufferLength++, 0b10000000);
+            if (undecoratedLength % BLOCK_SIZE >= BLOCK_SIZE - 8) {
+                for (let i = this.bufferLength; i < BLOCK_SIZE; i++) {
+                    buffer.setUint8(i, 0);
+                }
+                this.hashBuffer();
+                this.bufferLength = 0;
+            }
+            for (let i = this.bufferLength; i < BLOCK_SIZE - 8; i++) {
+                buffer.setUint8(i, 0);
+            }
+            buffer.setUint32(BLOCK_SIZE - 8, bitsHashed >>> 0, true);
+            buffer.setUint32(BLOCK_SIZE - 4, Math.floor(bitsHashed / 0x100000000), true);
+            this.hashBuffer();
+            this.finished = true;
+        }
+        const out = new DataView(new ArrayBuffer(DIGEST_LENGTH));
+        for (let i = 0; i < 4; i++) {
+            out.setUint32(i * 4, this.state[i], true);
+        }
+        return new Uint8Array(out.buffer, out.byteOffset, out.byteLength);
+    }
+    hashBuffer() {
+        const { buffer, state } = this;
+        let a = state[0], b = state[1], c = state[2], d = state[3];
+        a = ff(a, b, c, d, buffer.getUint32(0, true), 7, 0xd76aa478);
+        d = ff(d, a, b, c, buffer.getUint32(4, true), 12, 0xe8c7b756);
+        c = ff(c, d, a, b, buffer.getUint32(8, true), 17, 0x242070db);
+        b = ff(b, c, d, a, buffer.getUint32(12, true), 22, 0xc1bdceee);
+        a = ff(a, b, c, d, buffer.getUint32(16, true), 7, 0xf57c0faf);
+        d = ff(d, a, b, c, buffer.getUint32(20, true), 12, 0x4787c62a);
+        c = ff(c, d, a, b, buffer.getUint32(24, true), 17, 0xa8304613);
+        b = ff(b, c, d, a, buffer.getUint32(28, true), 22, 0xfd469501);
+        a = ff(a, b, c, d, buffer.getUint32(32, true), 7, 0x698098d8);
+        d = ff(d, a, b, c, buffer.getUint32(36, true), 12, 0x8b44f7af);
+        c = ff(c, d, a, b, buffer.getUint32(40, true), 17, 0xffff5bb1);
+        b = ff(b, c, d, a, buffer.getUint32(44, true), 22, 0x895cd7be);
+        a = ff(a, b, c, d, buffer.getUint32(48, true), 7, 0x6b901122);
+        d = ff(d, a, b, c, buffer.getUint32(52, true), 12, 0xfd987193);
+        c = ff(c, d, a, b, buffer.getUint32(56, true), 17, 0xa679438e);
+        b = ff(b, c, d, a, buffer.getUint32(60, true), 22, 0x49b40821);
+        a = gg(a, b, c, d, buffer.getUint32(4, true), 5, 0xf61e2562);
+        d = gg(d, a, b, c, buffer.getUint32(24, true), 9, 0xc040b340);
+        c = gg(c, d, a, b, buffer.getUint32(44, true), 14, 0x265e5a51);
+        b = gg(b, c, d, a, buffer.getUint32(0, true), 20, 0xe9b6c7aa);
+        a = gg(a, b, c, d, buffer.getUint32(20, true), 5, 0xd62f105d);
+        d = gg(d, a, b, c, buffer.getUint32(40, true), 9, 0x02441453);
+        c = gg(c, d, a, b, buffer.getUint32(60, true), 14, 0xd8a1e681);
+        b = gg(b, c, d, a, buffer.getUint32(16, true), 20, 0xe7d3fbc8);
+        a = gg(a, b, c, d, buffer.getUint32(36, true), 5, 0x21e1cde6);
+        d = gg(d, a, b, c, buffer.getUint32(56, true), 9, 0xc33707d6);
+        c = gg(c, d, a, b, buffer.getUint32(12, true), 14, 0xf4d50d87);
+        b = gg(b, c, d, a, buffer.getUint32(32, true), 20, 0x455a14ed);
+        a = gg(a, b, c, d, buffer.getUint32(52, true), 5, 0xa9e3e905);
+        d = gg(d, a, b, c, buffer.getUint32(8, true), 9, 0xfcefa3f8);
+        c = gg(c, d, a, b, buffer.getUint32(28, true), 14, 0x676f02d9);
+        b = gg(b, c, d, a, buffer.getUint32(48, true), 20, 0x8d2a4c8a);
+        a = hh(a, b, c, d, buffer.getUint32(20, true), 4, 0xfffa3942);
+        d = hh(d, a, b, c, buffer.getUint32(32, true), 11, 0x8771f681);
+        c = hh(c, d, a, b, buffer.getUint32(44, true), 16, 0x6d9d6122);
+        b = hh(b, c, d, a, buffer.getUint32(56, true), 23, 0xfde5380c);
+        a = hh(a, b, c, d, buffer.getUint32(4, true), 4, 0xa4beea44);
+        d = hh(d, a, b, c, buffer.getUint32(16, true), 11, 0x4bdecfa9);
+        c = hh(c, d, a, b, buffer.getUint32(28, true), 16, 0xf6bb4b60);
+        b = hh(b, c, d, a, buffer.getUint32(40, true), 23, 0xbebfbc70);
+        a = hh(a, b, c, d, buffer.getUint32(52, true), 4, 0x289b7ec6);
+        d = hh(d, a, b, c, buffer.getUint32(0, true), 11, 0xeaa127fa);
+        c = hh(c, d, a, b, buffer.getUint32(12, true), 16, 0xd4ef3085);
+        b = hh(b, c, d, a, buffer.getUint32(24, true), 23, 0x04881d05);
+        a = hh(a, b, c, d, buffer.getUint32(36, true), 4, 0xd9d4d039);
+        d = hh(d, a, b, c, buffer.getUint32(48, true), 11, 0xe6db99e5);
+        c = hh(c, d, a, b, buffer.getUint32(60, true), 16, 0x1fa27cf8);
+        b = hh(b, c, d, a, buffer.getUint32(8, true), 23, 0xc4ac5665);
+        a = ii(a, b, c, d, buffer.getUint32(0, true), 6, 0xf4292244);
+        d = ii(d, a, b, c, buffer.getUint32(28, true), 10, 0x432aff97);
+        c = ii(c, d, a, b, buffer.getUint32(56, true), 15, 0xab9423a7);
+        b = ii(b, c, d, a, buffer.getUint32(20, true), 21, 0xfc93a039);
+        a = ii(a, b, c, d, buffer.getUint32(48, true), 6, 0x655b59c3);
+        d = ii(d, a, b, c, buffer.getUint32(12, true), 10, 0x8f0ccc92);
+        c = ii(c, d, a, b, buffer.getUint32(40, true), 15, 0xffeff47d);
+        b = ii(b, c, d, a, buffer.getUint32(4, true), 21, 0x85845dd1);
+        a = ii(a, b, c, d, buffer.getUint32(32, true), 6, 0x6fa87e4f);
+        d = ii(d, a, b, c, buffer.getUint32(60, true), 10, 0xfe2ce6e0);
+        c = ii(c, d, a, b, buffer.getUint32(24, true), 15, 0xa3014314);
+        b = ii(b, c, d, a, buffer.getUint32(52, true), 21, 0x4e0811a1);
+        a = ii(a, b, c, d, buffer.getUint32(16, true), 6, 0xf7537e82);
+        d = ii(d, a, b, c, buffer.getUint32(44, true), 10, 0xbd3af235);
+        c = ii(c, d, a, b, buffer.getUint32(8, true), 15, 0x2ad7d2bb);
+        b = ii(b, c, d, a, buffer.getUint32(36, true), 21, 0xeb86d391);
+        state[0] = (a + state[0]) & 0xffffffff;
+        state[1] = (b + state[1]) & 0xffffffff;
+        state[2] = (c + state[2]) & 0xffffffff;
+        state[3] = (d + state[3]) & 0xffffffff;
+    }
+    reset() {
+        this.state = Uint32Array.from(INIT);
+        this.buffer = new DataView(new ArrayBuffer(BLOCK_SIZE));
+        this.bufferLength = 0;
+        this.bytesHashed = 0;
+        this.finished = false;
+    }
+}
+function cmn(q, a, b, x, s, t) {
+    a = (((a + q) & 0xffffffff) + ((x + t) & 0xffffffff)) & 0xffffffff;
+    return (((a << s) | (a >>> (32 - s))) + b) & 0xffffffff;
+}
+function ff(a, b, c, d, x, s, t) {
+    return cmn((b & c) | (~b & d), a, b, x, s, t);
+}
+function gg(a, b, c, d, x, s, t) {
+    return cmn((b & d) | (c & ~d), a, b, x, s, t);
+}
+function hh(a, b, c, d, x, s, t) {
+    return cmn(b ^ c ^ d, a, b, x, s, t);
+}
+function ii(a, b, c, d, x, s, t) {
+    return cmn(c ^ (b | ~d), a, b, x, s, t);
+}
+function isEmptyData(data) {
+    if (typeof data === "string") {
+        return data.length === 0;
+    }
+    return data.byteLength === 0;
+}
+function convertToBuffer(data) {
+    if (typeof data === "string") {
+        return serde.fromUtf8(data);
+    }
+    if (ArrayBuffer.isView(data)) {
+        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+    }
+    return new Uint8Array(data);
+}
+
+const no = Symbol.for("node-only");
+const fileStreamHasher = no;
+const readableStreamHasher = no;
+
+exports.Md5 = Md5;
+exports.blobHasher = blobHasher;
+exports.blobReader = blobReader;
+exports.fileStreamHasher = fileStreamHasher;
+exports.readableStreamHasher = readableStreamHasher;