@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash/commands/text-programs/awk-reader.js

@@ -1,450 +1,2 @@
-import { latin1Text } from "../../byte-encoding.js";
-import { readBytes } from "../../contracts/index.js";
-import { Budget, ProgramError, getCachedLatin1Batch } from "./shared.js";
-const resolvedVoid = Promise.resolve();
-const RELEASED_READER_ITERATOR = {
-    next() { return Promise.resolve({ done: true, value: undefined }); },
-};
-const memoryReaderPool = { reader: undefined };
-export function clearAwkReaderPool() { memoryReaderPool.reader = undefined; }
-export class Reader {
-    budget;
-    retention;
-    iterator;
-    blocks = [];
-    blockStrings = [];
-    blockEnds = [];
-    blocksLen = 0;
-    blockEndIdx = 0;
-    head = 0;
-    offset = 0;
-    buffered = 0;
-    ownedBytes = 0;
-    ended = false;
-    closed = false;
-    closing;
-    isPooledMemory = false;
-    activeReads = 0;
-    constructor(source, budget, retention) {
-        this.budget = budget;
-        this.retention = retention;
-        this.iterator = source === undefined
-            ? RELEASED_READER_ITERATOR
-            : typeof source.tryNextSync === "function"
-                ? source[Symbol.asyncIterator]()
-                : readBytes(source, budget.context.signal)[Symbol.asyncIterator]();
-    }
-    static fromMemoryView(chunk, budget, retention) {
-        let reader = memoryReaderPool.reader;
-        if (reader !== undefined) {
-            memoryReaderPool.reader = undefined;
-            reader.budget = budget;
-            reader.retention = retention;
-            reader.iterator = RELEASED_READER_ITERATOR;
-            reader.blocksLen = 0;
-            reader.blockEndIdx = 0;
-            reader.head = 0;
-            reader.offset = 0;
-            reader.buffered = 0;
-            reader.ownedBytes = 0;
-            reader.ended = true;
-            reader.closed = false;
-            reader.closing = undefined;
-            reader.isPooledMemory = true;
-        }
-        else {
-            reader = new Reader(undefined, budget, retention);
-            reader.ended = true;
-            reader.isPooledMemory = true;
-        }
-        budget.step();
-        const length = chunk.byteLength;
-        if (length > budget.maxBufferBytes)
-            throw new ProgramError("text buffer limit exceeded");
-        if (length > 0) {
-            retention.admit(0, length);
-            try {
-                const batch = getCachedLatin1Batch(chunk);
-                const block = chunk;
-                reader.blocks[0] = block;
-                reader.blockStrings[0] = batch?.text;
-                reader.blockEnds[0] = batch?.ends;
-                reader.blocksLen = 1;
-            }
-            catch (error) {
-                retention.release(length);
-                throw error;
-            }
-            reader.buffered = length;
-            reader.ownedBytes = length;
-        }
-        return reader;
-    }
-    get isEnded() {
-        return this.ended && this.buffered === 0;
-    }
-    retain(chunk) {
-        const length = chunk.byteLength;
-        if (length > this.budget.maxBufferBytes - this.buffered)
-            throw new ProgramError("text buffer limit exceeded");
-        if (length === 0)
-            return;
-        this.retention.admit(0, length);
-        try {
-            const block = chunk;
-            const batch = getCachedLatin1Batch(chunk);
-            const idx = this.blocksLen++;
-            this.blocks[idx] = block;
-            this.blockStrings[idx] = batch?.text;
-            this.blockEnds[idx] = batch?.ends;
-        }
-        catch (error) {
-            this.retention.release(length);
-            throw error;
-        }
-        this.buffered += length;
-        this.ownedBytes += length;
-    }
-    tryFillSync() {
-        const syncIter = this.iterator;
-        if (typeof syncIter.tryNextSync !== "function")
-            return false;
-        const signal = this.budget.context.signal;
-        while (!this.ended && !this.closed) {
-            this.budget.step();
-            if (this.head < this.blocksLen) {
-                const lastIdx = this.blocksLen - 1;
-                this.blocks[lastIdx] = new Uint8Array(this.blocks[lastIdx]);
-            }
-            const next = syncIter.tryNextSync();
-            if (this.closed)
-                return true;
-            if (next === undefined)
-                return false;
-            signal.throwIfAborted();
-            if (this.closed)
-                return false;
-            if (next.done) {
-                this.ended = true;
-                return true;
-            }
-            if (next.value.byteLength === 0)
-                continue;
-            this.retain(next.value);
-            return true;
-        }
-        return true;
-    }
-    async fill() {
-        this.budget.step();
-        const signal = this.budget.context.signal;
-        if (this.head < this.blocksLen) {
-            const lastIdx = this.blocksLen - 1;
-            this.blocks[lastIdx] = new Uint8Array(this.blocks[lastIdx]);
-        }
-        const next = await this.iterator.next();
-        signal.throwIfAborted();
-        if (this.closed)
-            return;
-        if (next.done) {
-            this.ended = true;
-            return;
-        }
-        this.retain(next.value);
-    }
-    consume(length) {
-        this.buffered -= length;
-        while (length > 0) {
-            const block = this.blocks[this.head];
-            const available = block.length - this.offset;
-            if (length < available) {
-                this.offset += length;
-                break;
-            }
-            length -= available;
-            this.retention.release(block.length);
-            this.ownedBytes -= block.length;
-            this.blocks[this.head] = undefined;
-            this.blockStrings[this.head] = undefined;
-            this.blockEnds[this.head] = undefined;
-            this.blockEndIdx = 0;
-            this.head++;
-            this.offset = 0;
-        }
-        if (this.head === this.blocksLen) {
-            this.blocksLen = 0;
-            this.blockEndIdx = 0;
-            this.head = 0;
-        }
-        else if (this.head >= 256 && this.head * 2 >= this.blocksLen) {
-            const rem = this.blocksLen - this.head;
-            this.blocks.copyWithin(0, this.head, this.blocksLen);
-            this.blockStrings.copyWithin(0, this.head, this.blocksLen);
-            this.blockEnds.copyWithin(0, this.head, this.blocksLen);
-            this.blocks.fill(undefined, rem, this.blocksLen);
-            this.blockStrings.fill(undefined, rem, this.blocksLen);
-            this.blockEnds.fill(undefined, rem, this.blocksLen);
-            this.blocksLen = rem;
-            this.head = 0;
-        }
-    }
-    finish(length, consumed) {
-        const firstBlock = this.blocks[this.head];
-        if (length <= firstBlock.length - this.offset) {
-            const str = (this.blockStrings[this.head] ??= latin1Text(firstBlock));
-            const record = str.slice(this.offset, this.offset + length);
-            this.consume(consumed);
-            return record;
-        }
-        // The returned record is a bounded transient; runtime slots own its charge.
-        const bytes = new Uint8Array(length);
-        let written = 0;
-        for (let index = this.head; written < length; index++) {
-            const block = this.blocks[index];
-            const start = index === this.head ? this.offset : 0;
-            const count = Math.min(length - written, block.length - start);
-            bytes.set(block.subarray(start, start + count), written);
-            written += count;
-        }
-        const record = latin1Text(bytes);
-        this.consume(consumed);
-        return record;
-    }
-    trimLeading() {
-        const block = this.blocks[this.head];
-        if (!block)
-            return false;
-        let end = this.offset;
-        const stop = Math.min(block.length, end + 4096);
-        while (end < stop && block[end] === 10)
-            end++;
-        const found = end < block.length && block[end] !== 10;
-        this.consume(end - this.offset);
-        return found;
-    }
-    scan(separator, state) {
-        let work = 4096;
-        while (state.block < this.blocksLen && work > 0) {
-            const block = this.blocks[state.block];
-            while (state.offset < block.length && work-- > 0) {
-                const byte = block[state.offset++];
-                const index = state.bytes++;
-                if (separator === "") {
-                    if (state.paragraphEnd >= 0) {
-                        if (byte !== 10)
-                            return { length: state.paragraphEnd, consumed: index };
-                    }
-                    else {
-                        if (byte === 10 && state.newline === index - 1)
-                            state.paragraphEnd = index - 1;
-                        state.newline = byte === 10 ? index : -1;
-                    }
-                }
-                else if (byte === separator.charCodeAt(0))
-                    return { length: index, consumed: index + 1 };
-            }
-            if (state.offset === block.length) {
-                state.block++;
-                state.offset = 0;
-            }
-        }
-        return undefined;
-    }
-    readSync(separator) {
-        if (this.closed)
-            return undefined;
-        if (this.budget.context.signal.aborted)
-            this.budget.context.signal.throwIfAborted();
-        if (separator.length > 1)
-            throw new ProgramError("RS must be one byte or empty for paragraph records");
-        if (separator.length === 1 && !this.closed && this.head < this.blocksLen) {
-            const headBlock = this.blocks[this.head];
-            const idx = headBlock.indexOf(separator.charCodeAt(0), this.offset);
-            if (idx >= 0 && idx - this.offset < 4096) {
-                this.budget.step();
-                const str = (this.blockStrings[this.head] ??= latin1Text(headBlock));
-                const record = str.slice(this.offset, idx);
-                this.consume(idx - this.offset + 1);
-                return record;
-            }
-        }
-        return this.read(separator);
-    }
-    readSliceSync(separator, out) {
-        if (this.closed)
-            return false;
-        if (this.budget.context.signal.aborted)
-            this.budget.context.signal.throwIfAborted();
-        if (separator.length === 1 && !this.closed) {
-            if (this.head >= this.blocksLen && !this.ended) {
-                this.tryFillSync();
-            }
-            if (this.head < this.blocksLen) {
-                const headBlock = this.blocks[this.head];
-                const sepCode = separator.charCodeAt(0);
-                const cachedEnds = sepCode === 10 ? this.blockEnds[this.head] : undefined;
-                if (cachedEnds !== undefined) {
-                    let eIdx = this.blockEndIdx;
-                    while (eIdx < cachedEnds.length && cachedEnds[eIdx] < this.offset)
-                        eIdx++;
-                    if (eIdx < cachedEnds.length) {
-                        const idx = cachedEnds[eIdx];
-                        if (idx - this.offset < 4096) {
-                            this.blockEndIdx = eIdx + 1;
-                            out.source = (this.blockStrings[this.head] ??= latin1Text(headBlock));
-                            out.start = this.offset;
-                            out.end = idx;
-                            this.consume(idx - this.offset + 1);
-                            return true;
-                        }
-                    }
-                }
-                const idx = headBlock.indexOf(sepCode, this.offset);
-                if (idx >= 0 && idx - this.offset < 4096) {
-                    out.source = (this.blockStrings[this.head] ??= latin1Text(headBlock));
-                    out.start = this.offset;
-                    out.end = idx;
-                    this.consume(idx - this.offset + 1);
-                    return true;
-                }
-                if (idx < 0 && this.head + 1 === this.blocksLen && !this.ended) {
-                    this.tryFillSync();
-                    if (this.head + 1 === this.blocksLen && this.ended && headBlock.length - this.offset < 4096) {
-                        out.source = (this.blockStrings[this.head] ??= latin1Text(headBlock));
-                        out.start = this.offset;
-                        out.end = headBlock.length;
-                        this.consume(headBlock.length - this.offset);
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    }
-    async read(separator) {
-        this.activeReads++;
-        try {
-            if (this.closed)
-                return undefined;
-            const budget = this.budget;
-            budget.context.signal.throwIfAborted();
-            if (separator.length > 1)
-                throw new ProgramError("RS must be one byte or empty for paragraph records");
-            if (separator.length === 1 && !this.closed && this.head < this.blocksLen) {
-                const headBlock = this.blocks[this.head];
-                const idx = headBlock.indexOf(separator.charCodeAt(0), this.offset);
-                if (idx >= 0 && idx - this.offset < 4096) {
-                    budget.step();
-                    const record = latin1Text(headBlock.subarray(this.offset, idx));
-                    this.consume(idx - this.offset + 1);
-                    return record;
-                }
-            }
-            if (separator === "") {
-                while (!this.closed) {
-                    budget.step();
-                    if (this.trimLeading())
-                        break;
-                    if (this.buffered === 0) {
-                        if (this.ended)
-                            return undefined;
-                        await this.fill();
-                    }
-                    if (this.closed)
-                        return undefined;
-                    const pendingCheck = budget.checkpointSync();
-                    if (pendingCheck)
-                        await pendingCheck;
-                }
-            }
-            const state = { block: this.head, offset: this.offset, bytes: 0, newline: -1, paragraphEnd: -1 };
-            while (true) {
-                if (this.closed)
-                    return undefined;
-                budget.step();
-                const found = this.scan(separator, state);
-                if (found)
-                    return this.finish(found.length, found.consumed);
-                if (state.block === this.blocksLen) {
-                    if (this.ended) {
-                        if (this.buffered === 0)
-                            return undefined;
-                        const length = separator !== "" ? this.buffered : state.paragraphEnd >= 0 ? state.paragraphEnd
-                            : state.newline === this.buffered - 1 ? this.buffered - 1 : this.buffered;
-                        return this.finish(length, this.buffered);
-                    }
-                    await this.fill();
-                }
-                if (this.closed)
-                    return undefined;
-                const pendingCheck = budget.checkpointSync();
-                if (pendingCheck)
-                    await pendingCheck;
-            }
-        }
-        finally {
-            this.activeReads--;
-        }
-    }
-    close() {
-        if (this.closing)
-            return this.closing;
-        const wasEnded = this.ended;
-        this.closed = true;
-        this.ended = true;
-        if (this.blocksLen > 0) {
-            this.blocks.fill(undefined, 0, this.blocksLen);
-            this.blockStrings.fill(undefined, 0, this.blocksLen);
-            this.blockEnds.fill(undefined, 0, this.blocksLen);
-            this.blocksLen = 0;
-        }
-        this.head = this.offset = this.buffered = 0;
-        this.retention.release(this.ownedBytes);
-        this.ownedBytes = 0;
-        const origIter = this.iterator;
-        this.iterator = RELEASED_READER_ITERATOR;
-        this.budget = undefined;
-        this.retention = undefined;
-        if (this.isPooledMemory && this.activeReads === 0 && memoryReaderPool.reader === undefined) {
-            this.isPooledMemory = false;
-            memoryReaderPool.reader = this;
-        }
-        if (wasEnded || !origIter.return) {
-            this.closing = resolvedVoid;
-            return resolvedVoid;
-        }
-        this.closing = Promise.resolve().then(async () => { await origIter.return?.(); });
-        return this.closing;
-    }
-    closeSyncOrAsync() {
-        if (this.closing)
-            return this.closing === resolvedVoid ? undefined : this.closing;
-        const wasEnded = this.ended;
-        this.closed = true;
-        this.ended = true;
-        if (this.blocksLen > 0) {
-            this.blocks.fill(undefined, 0, this.blocksLen);
-            this.blockStrings.fill(undefined, 0, this.blocksLen);
-            this.blockEnds.fill(undefined, 0, this.blocksLen);
-            this.blocksLen = 0;
-        }
-        this.head = this.offset = this.buffered = 0;
-        this.retention.release(this.ownedBytes);
-        this.ownedBytes = 0;
-        const origIter = this.iterator;
-        this.iterator = RELEASED_READER_ITERATOR;
-        this.budget = undefined;
-        this.retention = undefined;
-        if (this.isPooledMemory && this.activeReads === 0 && memoryReaderPool.reader === undefined) {
-            this.isPooledMemory = false;
-            memoryReaderPool.reader = this;
-        }
-        if (wasEnded || !origIter.return) {
-            this.closing = resolvedVoid;
-            return undefined;
-        }
-        this.closing = Promise.resolve().then(async () => { await origIter.return?.(); });
-        return this.closing;
-    }
-}
+export * from "../../../safe-bash-command-awk/awk-reader.js";
 //# sourceMappingURL=awk-reader.js.map

package/dist/safe-bash/commands/text-programs/awk-retention.d.ts

@@ -1,14 +1,2 @@
-/** Logical invocation-owned text, independent of per-buffer limits and RSS. */
-export declare class AwkRetention {
-    readonly capacity: number;
-    private readonly signal?;
-    private retained;
-    private readonly unlimited;
-    private readonly capSmi;
-    constructor(capacity: number, signal?: AbortSignal | undefined);
-    get retainedBytes(): number;
-    admit(previousBytes: number, nextBytes: number): void;
-    replace<T>(previousBytes: number, nextBytes: number, create: () => T): T;
-    release(bytes: number): void;
-}
+export * from "../../../safe-bash-command-awk/awk-retention.js";
 //# sourceMappingURL=awk-retention.d.ts.map

package/dist/safe-bash/commands/text-programs/awk-retention.js

@@ -1,52 +1,2 @@
-import { ProgramError } from "./shared.js";
-/** Logical invocation-owned text, independent of per-buffer limits and RSS. */
-export class AwkRetention {
-    capacity;
-    signal;
-    retained = 0;
-    unlimited;
-    capSmi;
-    constructor(capacity, signal) {
-        this.capacity = capacity;
-        this.signal = signal;
-        if ((capacity !== Infinity && !Number.isSafeInteger(capacity)) || capacity < 0)
-            throw new ProgramError("retained text capacity must be a nonnegative safe integer");
-        this.unlimited = capacity === Infinity;
-        this.capSmi = !this.unlimited && capacity <= 0x3fffffff ? (capacity | 0) : 0x3fffffff;
-    }
-    get retainedBytes() { return this.retained; }
-    admit(previousBytes, nextBytes) {
-        if (this.signal?.aborted)
-            this.signal.throwIfAborted();
-        if ((previousBytes | 0) === previousBytes && previousBytes >= 0 && previousBytes <= this.retained && (nextBytes | 0) === nextBytes && nextBytes >= 0) {
-            const nextRetained = (this.retained + nextBytes - previousBytes) | 0;
-            if (this.unlimited || nextRetained <= this.capSmi) {
-                this.retained = nextRetained;
-                return;
-            }
-        }
-        if (!Number.isSafeInteger(previousBytes) || previousBytes < 0 || previousBytes > this.retained
-            || !Number.isSafeInteger(nextBytes) || nextBytes < 0)
-            throw new ProgramError("invalid retained text accounting");
-        if (nextBytes > this.capacity - this.retained + previousBytes)
-            throw new ProgramError("awk retained text limit exceeded");
-        this.retained += nextBytes - previousBytes;
-    }
-    replace(previousBytes, nextBytes, create) {
-        this.signal?.throwIfAborted();
-        if (!Number.isSafeInteger(previousBytes) || previousBytes < 0 || previousBytes > this.retained
-            || !Number.isSafeInteger(nextBytes) || nextBytes < 0)
-            throw new ProgramError("invalid retained text accounting");
-        if (nextBytes > this.capacity - this.retained + previousBytes)
-            throw new ProgramError("awk retained text limit exceeded");
-        const value = create();
-        this.retained += nextBytes - previousBytes;
-        return value;
-    }
-    release(bytes) {
-        if (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > this.retained)
-            throw new ProgramError("invalid retained text release");
-        this.retained -= bytes;
-    }
-}
+export * from "../../../safe-bash-command-awk/awk-retention.js";
 //# sourceMappingURL=awk-retention.js.map

package/dist/safe-bash/commands/text-programs/awk-runtime.d.ts

@@ -1,151 +1,2 @@
-import { type CommandContext } from "../../contracts/index.js";
-import type { AwkProgram } from "./awk-syntax.js";
-import { Budget } from "./shared.js";
-import { AwkRetention } from "./awk-retention.js";
-import type { AwkInspection } from "./awk-inspection.js";
-export declare class AwkRuntime {
-    private program;
-    context: CommandContext;
-    budget: Budget;
-    retention: AwkRetention;
-    private operandAssignments;
-    private ordchr;
-    private inspection?;
-    private readonly variables;
-    private readonly frames;
-    private readonly arrays;
-    private regexes;
-    private outputs;
-    private inputs;
-    private environInitialized;
-    private mainReader;
-    private argument;
-    private sawFile;
-    private defaultUsed;
-    private rawFields;
-    private get fields();
-    private set fields(value);
-    private fieldStarts;
-    private fieldEnds;
-    private fieldCount;
-    private deferredFieldSeparator;
-    private fieldsMaterialized;
-    private fieldGeneration;
-    private lazyFieldGen;
-    private lazyFields;
-    private fieldBytes;
-    private rawRecord;
-    private recordSource;
-    private recordStart;
-    private recordEnd;
-    private get record();
-    private set record(value);
-    private get recordLength();
-    private readonly sliceBox;
-    private recordValue;
-    private entries;
-    private fsText;
-    private rsText;
-    private convfmtText;
-    private nrNum;
-    private nrDirty;
-    private fnrNum;
-    private fnrDirty;
-    private nfNum;
-    private nfDirty;
-    private phase;
-    private status;
-    private randomSeed;
-    private randomState;
-    constructor(program: AwkProgram, context: CommandContext, budget: Budget, retention: AwkRetention, args: readonly string[], assignments: readonly string[], separator?: string, operandAssignments?: boolean, ordchr?: boolean, inspection?: AwkInspection | undefined);
-    private ensureEnviron;
-    private store;
-    private syncSpecialVars;
-    private get;
-    private getScalar;
-    private asText;
-    private varText;
-    private retainName;
-    private storeScalar;
-    private bindArray;
-    private releaseStore;
-    private set;
-    private setNumber;
-    private array;
-    private arraySet;
-    private pattern;
-    private regex;
-    private splitSync;
-    private split;
-    private parseSliceNumber;
-    private getFieldNumber;
-    private getField;
-    private ensureFields;
-    private ensureSliceFieldsSplit;
-    private setRecordSliceSync;
-    private setRecordSync;
-    private setRecordSlow;
-    private setRecord;
-    private replaceRecord;
-    private join;
-    private rebuild;
-    private key;
-    private keySlow;
-    private reference;
-    private arithmetic;
-    private scalarExpression;
-    private evaluate;
-    private evaluateRegexMatch;
-    private evaluateFieldAsync;
-    private evaluateArrayAsync;
-    private evaluateConditionalAsync;
-    private evaluateUnaryArrayAsync;
-    private evaluateUnaryValueAsync;
-    private evaluateAssignVarAsync;
-    private evaluateAssignArrayRightAsync;
-    private evaluateAssignArrayKeyAsync;
-    private evaluateBinaryWithRightPromise;
-    private evaluateBinarySyncOperands;
-    private evaluateBinaryWithLeftPromise;
-    private evaluateUnarySlow;
-    private evaluateBinarySlow;
-    private getline;
-    private call;
-    private recordChecks;
-    private stdoutBuffer;
-    private flushStdout;
-    private executeSync;
-    private tryFastExpressionStatement;
-    private executeSyncBody;
-    private executePrintRemainder;
-    private ignorePromiseValue;
-    private executeIfAsync;
-    private executeAfterCheckpoint;
-    private executeBlockRemainder;
-    private execute;
-    private assignment;
-    private exit;
-    private finishSyncCleanup;
-    runSyncOrAsync(): number | Promise<number>;
-    private finishRunAfterFlush;
-    private finishRunAfterSyncProgram;
-    private finishRunFromPromise;
-    run(): Promise<number>;
-    private tryRunProgramSync;
-    private runEndPhaseSyncOrAsync;
-    private continueEndPhaseAsync;
-    private continueProgramAsyncAfterRecord;
-    private continueProgramAsyncAtRule;
-    private continueProgramAsyncRulesAndLoop;
-    private continueProgramSlowAsync;
-    private _unusedOldRun;
-    private readMainRecord;
-    private incrementCounter;
-    private readMainRecordSync;
-    private readMainRecordAfterPromise;
-    private readMainRecordSlowAfterEof;
-    private readMainRecordSlow;
-    private tryOpenNextMainReaderSync;
-    private runProgram;
-}
+export * from "../../../safe-bash-command-awk/awk-runtime.js";
 //# sourceMappingURL=awk-runtime.d.ts.map