@kruntime/komputer 0.1.0

package/dist/shell/builtins/text.js

@@ -0,0 +1,970 @@
+export function formatPrintf(args) {
+    if (!args.length)
+        return '';
+    const format = decodePrintfEscapes(args[0]);
+    const values = args.slice(1);
+    const conversions = printfConversions(format);
+    if (!conversions.length)
+        return format;
+    let valueIndex = 0;
+    let output = '';
+    do {
+        output += format.replace(/%%|%([-+ 0#]*)(\d+)?(?:\.(\d+))?([sd])/g, (match, flags, width, precision, type) => {
+            if (match === '%%')
+                return '%';
+            const raw = values[valueIndex++] ?? (type === 'd' ? '0' : '');
+            const rendered = type === 'd' ? formatInteger(raw) : String(raw);
+            return applyPrintfWidth(rendered, {
+                left: flags.includes('-'),
+                zero: flags.includes('0') && !flags.includes('-'),
+                width: width ? Number(width) : 0,
+                precision: precision ? Number(precision) : undefined,
+            });
+        });
+    } while (valueIndex < values.length);
+    return output;
+}
+function decodePrintfEscapes(format) {
+    return format
+        .replace(/\\n/g, '\n')
+        .replace(/\\t/g, '\t')
+        .replace(/\\r/g, '\r')
+        .replace(/\\\\/g, '\\');
+}
+function printfConversions(format) {
+    return [...format.matchAll(/%%|%[-+ 0#]*\d*(?:\.\d+)?[sd]/g)]
+        .filter((match) => match[0] !== '%%')
+        .map((match) => match[0]);
+}
+function formatInteger(value) {
+    const parsed = Number.parseInt(String(value), 10);
+    return Number.isFinite(parsed) ? String(parsed) : '0';
+}
+function applyPrintfWidth(value, options) {
+    const truncated = options.precision === undefined ? value : value.slice(0, options.precision);
+    if (!options.width || truncated.length >= options.width)
+        return truncated;
+    const pad = (options.zero ? '0' : ' ').repeat(options.width - truncated.length);
+    return options.left ? `${truncated}${pad}` : `${pad}${truncated}`;
+}
+export function parseGrepArgs(args) {
+    const patterns = [];
+    let ignoreCase = false;
+    let invert = false;
+    let lineNumber = false;
+    let recursive = false;
+    let count = false;
+    let filesWithMatches = false;
+    let quiet = false;
+    let fixedStrings = false;
+    let onlyMatching = false;
+    let noFilename = false;
+    let withFilename = false;
+    let maxCount;
+    let beforeContext = 0;
+    let afterContext = 0;
+    const includes = [];
+    const excludes = [];
+    const excludeDirs = [];
+    const rest = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--') {
+            rest.push(...args.slice(index + 1));
+            break;
+        }
+        if (arg === '--count') {
+            count = true;
+            continue;
+        }
+        if (arg === '--files-with-matches') {
+            filesWithMatches = true;
+            continue;
+        }
+        if (arg === '--quiet' || arg === '--silent') {
+            quiet = true;
+            continue;
+        }
+        if (arg === '--only-matching') {
+            onlyMatching = true;
+            continue;
+        }
+        if (arg === '--no-filename') {
+            noFilename = true;
+            continue;
+        }
+        if (arg === '--with-filename') {
+            withFilename = true;
+            continue;
+        }
+        if (arg === '--include') {
+            const value = args[++index];
+            if (value === undefined)
+                throw new Error('grep: option requires an argument: --include');
+            includes.push(value);
+            continue;
+        }
+        if (arg.startsWith('--include=')) {
+            includes.push(arg.slice('--include='.length));
+            continue;
+        }
+        if (arg === '--exclude') {
+            const value = args[++index];
+            if (value === undefined)
+                throw new Error('grep: option requires an argument: --exclude');
+            excludes.push(value);
+            continue;
+        }
+        if (arg.startsWith('--exclude=')) {
+            excludes.push(arg.slice('--exclude='.length));
+            continue;
+        }
+        if (arg === '--exclude-dir') {
+            const value = args[++index];
+            if (value === undefined)
+                throw new Error('grep: option requires an argument: --exclude-dir');
+            excludeDirs.push(value);
+            continue;
+        }
+        if (arg.startsWith('--exclude-dir=')) {
+            excludeDirs.push(arg.slice('--exclude-dir='.length));
+            continue;
+        }
+        if (arg === '--fixed-strings') {
+            fixedStrings = true;
+            continue;
+        }
+        if (arg === '--extended-regexp') {
+            fixedStrings = false;
+            continue;
+        }
+        if (arg === '--max-count') {
+            maxCount = parseNonnegativeCount(args[++index], 'grep: option requires an argument: --max-count');
+            continue;
+        }
+        if (arg.startsWith('--max-count=')) {
+            maxCount = parseNonnegativeCount(arg.slice('--max-count='.length), 'grep: invalid max count');
+            continue;
+        }
+        if (arg === '--after-context') {
+            afterContext = parseNonnegativeCount(args[++index], 'grep: option requires an argument: --after-context');
+            continue;
+        }
+        if (arg.startsWith('--after-context=')) {
+            afterContext = parseNonnegativeCount(arg.slice('--after-context='.length), 'grep: invalid context count');
+            continue;
+        }
+        if (arg === '--before-context') {
+            beforeContext = parseNonnegativeCount(args[++index], 'grep: option requires an argument: --before-context');
+            continue;
+        }
+        if (arg.startsWith('--before-context=')) {
+            beforeContext = parseNonnegativeCount(arg.slice('--before-context='.length), 'grep: invalid context count');
+            continue;
+        }
+        if (arg === '--context') {
+            const context = parseNonnegativeCount(args[++index], 'grep: option requires an argument: --context');
+            beforeContext = context;
+            afterContext = context;
+            continue;
+        }
+        if (arg.startsWith('--context=')) {
+            const context = parseNonnegativeCount(arg.slice('--context='.length), 'grep: invalid context count');
+            beforeContext = context;
+            afterContext = context;
+            continue;
+        }
+        if (arg.startsWith('--'))
+            throw new Error(`grep: unsupported option: ${arg}`);
+        if (arg === '-e') {
+            const pattern = args[++index];
+            if (pattern === undefined)
+                throw new Error('grep: option requires an argument: -e');
+            patterns.push(pattern);
+            continue;
+        }
+        if (arg.startsWith('-e') && arg.length > 2) {
+            patterns.push(arg.slice(2));
+            continue;
+        }
+        if (arg === '-m') {
+            maxCount = parseNonnegativeCount(args[++index], 'grep: option requires an argument: -m');
+            continue;
+        }
+        if (arg.startsWith('-m') && arg.length > 2) {
+            maxCount = parseNonnegativeCount(arg.slice(2), 'grep: invalid max count');
+            continue;
+        }
+        if (arg === '-A') {
+            afterContext = parseNonnegativeCount(args[++index], 'grep: option requires an argument: -A');
+            continue;
+        }
+        if (arg.startsWith('-A') && arg.length > 2) {
+            afterContext = parseNonnegativeCount(arg.slice(2), 'grep: invalid context count');
+            continue;
+        }
+        if (arg === '-B') {
+            beforeContext = parseNonnegativeCount(args[++index], 'grep: option requires an argument: -B');
+            continue;
+        }
+        if (arg.startsWith('-B') && arg.length > 2) {
+            beforeContext = parseNonnegativeCount(arg.slice(2), 'grep: invalid context count');
+            continue;
+        }
+        if (arg === '-C') {
+            const context = parseNonnegativeCount(args[++index], 'grep: option requires an argument: -C');
+            beforeContext = context;
+            afterContext = context;
+            continue;
+        }
+        if (arg.startsWith('-C') && arg.length > 2) {
+            const context = parseNonnegativeCount(arg.slice(2), 'grep: invalid context count');
+            beforeContext = context;
+            afterContext = context;
+            continue;
+        }
+        if (arg.startsWith('-') && arg.length > 1) {
+            for (const flag of arg.slice(1)) {
+                if (flag === 'i')
+                    ignoreCase = true;
+                else if (flag === 'v')
+                    invert = true;
+                else if (flag === 'n')
+                    lineNumber = true;
+                else if (flag === 'r' || flag === 'R')
+                    recursive = true;
+                else if (flag === 'c')
+                    count = true;
+                else if (flag === 'l')
+                    filesWithMatches = true;
+                else if (flag === 'q')
+                    quiet = true;
+                else if (flag === 'o')
+                    onlyMatching = true;
+                else if (flag === 'h')
+                    noFilename = true;
+                else if (flag === 'H')
+                    withFilename = true;
+                else if (flag === 'F')
+                    fixedStrings = true;
+                else if (flag === 'E')
+                    fixedStrings = false;
+                else
+                    throw new Error(`grep: unsupported option: -${flag}`);
+            }
+            continue;
+        }
+        rest.push(arg);
+    }
+    if (!patterns.length) {
+        const pattern = rest.shift();
+        if (pattern !== undefined)
+            patterns.push(pattern);
+    }
+    if (!patterns.length)
+        throw new Error('grep requires a pattern');
+    return { patterns, paths: rest, fixedStrings, ignoreCase, invert, lineNumber, recursive, count, filesWithMatches, quiet, onlyMatching, noFilename, withFilename, maxCount, beforeContext, afterContext, includes, excludes, excludeDirs };
+}
+function parseNonnegativeCount(value, message) {
+    if (value === undefined)
+        throw new Error(message);
+    const count = Number(value);
+    if (!Number.isInteger(count) || count < 0)
+        throw new Error(message);
+    return count;
+}
+export function makeTextMatcher(patterns, options) {
+    const matchers = patterns.map((pattern) => makeSingleTextMatcher(pattern, options));
+    return (line) => matchers.some((matcher) => matcher(line));
+}
+function makeSingleTextMatcher(pattern, options) {
+    if (options.fixedStrings) {
+        const needle = options.ignoreCase ? pattern.toLowerCase() : pattern;
+        return (line) => (options.ignoreCase ? line.toLowerCase() : line).includes(needle);
+    }
+    try {
+        const regex = new RegExp(pattern, options.ignoreCase ? 'i' : '');
+        return (line) => regex.test(line);
+    }
+    catch {
+        const needle = options.ignoreCase ? pattern.toLowerCase() : pattern;
+        return (line) => (options.ignoreCase ? line.toLowerCase() : line).includes(needle);
+    }
+}
+export function extractTextMatches(patterns, line, options) {
+    const matches = patterns.flatMap((pattern) => extractSingleTextMatches(pattern, line, options));
+    return matches.length ? matches : (makeTextMatcher(patterns, options)(line) ? [line] : []);
+}
+function extractSingleTextMatches(pattern, line, options) {
+    if (options.fixedStrings)
+        return extractFixedTextMatches(pattern, line, options.ignoreCase);
+    try {
+        const flags = `g${options.ignoreCase ? 'i' : ''}`;
+        const regex = new RegExp(pattern, flags);
+        const output = [];
+        let match;
+        while ((match = regex.exec(line)) !== null) {
+            output.push(match[0]);
+            if (match[0] === '')
+                regex.lastIndex += 1;
+        }
+        return output;
+    }
+    catch {
+        return extractFixedTextMatches(pattern, line, options.ignoreCase);
+    }
+}
+function extractFixedTextMatches(pattern, line, ignoreCase) {
+    if (!pattern)
+        return [];
+    const haystack = ignoreCase ? line.toLowerCase() : line;
+    const needle = ignoreCase ? pattern.toLowerCase() : pattern;
+    const output = [];
+    let index = 0;
+    while (index <= haystack.length) {
+        const found = haystack.indexOf(needle, index);
+        if (found < 0)
+            break;
+        output.push(line.slice(found, found + pattern.length));
+        index = found + Math.max(1, pattern.length);
+    }
+    return output;
+}
+export function parseWcArgs(args) {
+    const fields = [];
+    const paths = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--') {
+            paths.push(...args.slice(index + 1));
+            break;
+        }
+        if (arg === '--lines') {
+            pushWcField(fields, 'lines');
+            continue;
+        }
+        if (arg === '--words') {
+            pushWcField(fields, 'words');
+            continue;
+        }
+        if (arg === '--bytes' || arg === '--chars') {
+            pushWcField(fields, 'bytes');
+            continue;
+        }
+        if (arg.startsWith('--'))
+            throw new Error(`wc: unsupported option: ${arg}`);
+        if (arg.startsWith('-') && arg.length > 1) {
+            for (const flag of arg.slice(1)) {
+                if (flag === 'l')
+                    pushWcField(fields, 'lines');
+                else if (flag === 'w')
+                    pushWcField(fields, 'words');
+                else if (flag === 'c' || flag === 'm')
+                    pushWcField(fields, 'bytes');
+                else
+                    throw new Error(`wc: unsupported option: -${flag}`);
+            }
+            continue;
+        }
+        paths.push(arg);
+    }
+    return { fields: fields.length ? fields : ['lines', 'words', 'bytes'], paths };
+}
+function pushWcField(fields, field) {
+    if (!fields.includes(field))
+        fields.push(field);
+}
+export function parseHeadTailArgs(args, fallback, command = 'head') {
+    let count = fallback;
+    let unit = 'lines';
+    let fromLine;
+    let fromByte;
+    const paths = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--') {
+            paths.push(...args.slice(index + 1));
+            break;
+        }
+        if (arg === '-n') {
+            const value = requireHeadTailNumber(args[++index], command, '-n');
+            if (value.startsWith('+')) {
+                const parsed = parseHeadTailNumber(value.slice(1), command, '-n');
+                count = parsed;
+                fromLine = Math.max(1, parsed);
+                continue;
+            }
+            count = parseHeadTailNumber(value, command, '-n');
+            continue;
+        }
+        if (arg === '-c' || arg === '--bytes') {
+            const value = requireHeadTailNumber(args[++index], command, arg);
+            unit = 'bytes';
+            if (value.startsWith('+')) {
+                const parsed = parseHeadTailNumber(value.slice(1), command, arg);
+                count = parsed;
+                fromByte = Math.max(1, parsed);
+                continue;
+            }
+            count = parseHeadTailNumber(value, command, arg);
+            continue;
+        }
+        if (/^--bytes=\+?\d+$/.test(arg)) {
+            const value = arg.slice('--bytes='.length);
+            unit = 'bytes';
+            if (value.startsWith('+')) {
+                const parsed = parseHeadTailNumber(value.slice(1), command, '--bytes');
+                count = parsed;
+                fromByte = Math.max(1, parsed);
+                continue;
+            }
+            count = parseHeadTailNumber(value, command, '--bytes');
+            continue;
+        }
+        if (/^-c\+?\d+$/.test(arg)) {
+            const value = arg.slice(2);
+            unit = 'bytes';
+            if (value.startsWith('+')) {
+                const parsed = parseHeadTailNumber(value.slice(1), command, '-c');
+                count = parsed;
+                fromByte = Math.max(1, parsed);
+                continue;
+            }
+            count = parseHeadTailNumber(value, command, '-c');
+            continue;
+        }
+        if (/^-\+\d+$/.test(arg)) {
+            const parsed = parseHeadTailNumber(arg.slice(2), command, '-n');
+            count = parsed;
+            fromLine = Math.max(1, parsed);
+            continue;
+        }
+        if (/^-\d+$/.test(arg)) {
+            count = parseHeadTailNumber(arg.slice(1), command, '-n');
+            continue;
+        }
+        if (arg.startsWith('-'))
+            throw new Error(`${command}: unsupported option: ${arg}`);
+        paths.push(arg);
+    }
+    return { count, unit, fromLine, fromByte, paths };
+}
+function requireHeadTailNumber(value, command, option) {
+    if (value === undefined)
+        throw new Error(`${command}: option requires an argument: ${option}`);
+    return value;
+}
+function parseHeadTailNumber(value, command, option) {
+    if (!/^\d+$/.test(value))
+        throw new Error(`${command}: invalid number for ${option}: ${value}`);
+    return Math.max(0, Number(value));
+}
+export function parseCutArgs(args) {
+    let mode = 'fields';
+    let delimiter = '\t';
+    let fields = [];
+    let chars = [];
+    const paths = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '-d') {
+            delimiter = requireCutValue(args, ++index, '-d');
+            continue;
+        }
+        if (arg === '--delimiter') {
+            delimiter = requireCutValue(args, ++index, '--delimiter');
+            continue;
+        }
+        if (arg.startsWith('--delimiter=')) {
+            delimiter = arg.slice('--delimiter='.length);
+            if (!delimiter)
+                throw new Error('cut: --delimiter requires an argument');
+            continue;
+        }
+        if (arg === '-f') {
+            mode = 'fields';
+            fields = parseNumberSelections(requireCutValue(args, ++index, '-f'));
+            continue;
+        }
+        if (arg === '--fields') {
+            mode = 'fields';
+            fields = parseNumberSelections(requireCutValue(args, ++index, '--fields'));
+            continue;
+        }
+        if (arg.startsWith('--fields=')) {
+            mode = 'fields';
+            fields = parseNumberSelections(arg.slice('--fields='.length));
+            continue;
+        }
+        if (arg.startsWith('-f') && arg.length > 2) {
+            mode = 'fields';
+            fields = parseNumberSelections(arg.slice(2));
+            continue;
+        }
+        if (arg === '-c') {
+            mode = 'chars';
+            chars = parseNumberSelections(requireCutValue(args, ++index, '-c'));
+            continue;
+        }
+        if (arg === '--characters') {
+            mode = 'chars';
+            chars = parseNumberSelections(requireCutValue(args, ++index, '--characters'));
+            continue;
+        }
+        if (arg.startsWith('--characters=')) {
+            mode = 'chars';
+            chars = parseNumberSelections(arg.slice('--characters='.length));
+            continue;
+        }
+        if (arg.startsWith('-c') && arg.length > 2) {
+            mode = 'chars';
+            chars = parseNumberSelections(arg.slice(2));
+            continue;
+        }
+        if (arg === '--') {
+            paths.push(...args.slice(index + 1));
+            break;
+        }
+        if (arg.startsWith('-'))
+            throw new Error(`cut: unsupported option: ${arg}`);
+        if (!arg.startsWith('-'))
+            paths.push(arg);
+    }
+    if (mode === 'fields' && !fields.length)
+        fields = [{ start: 1, end: 1 }];
+    if (mode === 'chars' && !chars.length)
+        chars = [{ start: 1, end: 1 }];
+    return { mode, delimiter, fields, chars, paths };
+}
+function requireCutValue(args, index, option) {
+    const value = args[index];
+    if (value === undefined || value === '')
+        throw new Error(`cut: ${option} requires an argument`);
+    return value;
+}
+export function parseUniqArgs(args) {
+    let count = false;
+    let repeatedOnly = false;
+    let uniqueOnly = false;
+    let ignoreCase = false;
+    const paths = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--') {
+            paths.push(...args.slice(index + 1));
+            break;
+        }
+        if (arg === '--count') {
+            count = true;
+            continue;
+        }
+        if (arg === '--repeated') {
+            repeatedOnly = true;
+            continue;
+        }
+        if (arg === '--unique') {
+            uniqueOnly = true;
+            continue;
+        }
+        if (arg === '--ignore-case') {
+            ignoreCase = true;
+            continue;
+        }
+        if (arg.startsWith('--'))
+            throw new Error(`uniq: unrecognized option '${arg}'`);
+        if (arg.startsWith('-') && arg.length > 1) {
+            for (const flag of arg.slice(1)) {
+                if (flag === 'c')
+                    count = true;
+                else if (flag === 'd')
+                    repeatedOnly = true;
+                else if (flag === 'u')
+                    uniqueOnly = true;
+                else if (flag === 'i')
+                    ignoreCase = true;
+                else
+                    throw new Error(`uniq: invalid option -- '${flag}'`);
+            }
+            continue;
+        }
+        paths.push(arg);
+    }
+    return { count, repeatedOnly, uniqueOnly, ignoreCase, paths };
+}
+export function parseSedArgs(args) {
+    let expression = '';
+    let quiet = false;
+    let inPlace = false;
+    let backupSuffix;
+    const paths = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '-n') {
+            quiet = true;
+            continue;
+        }
+        if (arg === '-i' || arg === '--in-place') {
+            inPlace = true;
+            continue;
+        }
+        if (arg.startsWith('-i') && arg.length > 2) {
+            inPlace = true;
+            backupSuffix = arg.slice(2);
+            continue;
+        }
+        if (arg.startsWith('--in-place=')) {
+            inPlace = true;
+            backupSuffix = arg.slice('--in-place='.length);
+            continue;
+        }
+        if (arg === '-E' || arg === '-r')
+            continue;
+        if (arg === '-e') {
+            expression = args[++index] || '';
+            continue;
+        }
+        if (!expression)
+            expression = arg;
+        else
+            paths.push(arg);
+    }
+    return { expression, paths, quiet, inPlace, backupSuffix };
+}
+export function parseAwkArgs(args) {
+    let fieldSeparator;
+    const rest = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--') {
+            rest.push(...args.slice(index + 1));
+            break;
+        }
+        if (arg === '-F') {
+            fieldSeparator = decodeAwkSeparator(args[++index] || '');
+            continue;
+        }
+        if (arg.startsWith('-F') && arg.length > 2) {
+            fieldSeparator = decodeAwkSeparator(arg.slice(2));
+            continue;
+        }
+        rest.push(arg);
+    }
+    if (!rest.length)
+        throw new Error('awk requires a program');
+    return { program: rest[0], fieldSeparator, paths: rest.slice(1) };
+}
+export function applyUniq(input, options) {
+    const lines = splitLines(input);
+    const rows = [];
+    for (const line of lines) {
+        const key = options.ignoreCase ? line.toLowerCase() : line;
+        const last = rows.at(-1);
+        if (last?.key === key)
+            last.count += 1;
+        else
+            rows.push({ line, key, count: 1 });
+    }
+    const output = rows
+        .filter((row) => !options.repeatedOnly || row.count > 1)
+        .filter((row) => !options.uniqueOnly || row.count === 1)
+        .map((row) => options.count ? `${String(row.count).padStart(7)} ${row.line}` : row.line);
+    return output.length ? `${output.join('\n')}\n` : '';
+}
+export function applySed(input, expression, options = {}) {
+    const printed = applySedPrint(input, expression);
+    if (printed !== undefined)
+        return printed;
+    const deleted = applySedDelete(input, expression, options);
+    if (deleted !== undefined)
+        return deleted;
+    const substitution = parseSedSubstitution(expression);
+    if (!substitution)
+        throw new Error(`unsupported sed expression: ${expression}`);
+    const { pattern, replacement, flags } = substitution;
+    const regex = new RegExp(pattern, flags.includes('g') ? 'g' : '');
+    const rows = [];
+    for (const line of input.split('\n')) {
+        const replaced = line.replace(regex, replacement);
+        if (!options.quiet)
+            rows.push(replaced);
+        else if (flags.includes('p') && replaced !== line)
+            rows.push(replaced);
+    }
+    return rows.join('\n');
+}
+export function applyAwk(input, program, options = {}) {
+    const print = parseAwkPrintProgram(program);
+    if (!print)
+        throw new Error(`unsupported awk program: ${program}`);
+    const fields = print.fields.length ? print.fields : ['$0'];
+    const rows = splitLines(input).flatMap((line, index) => {
+        if (!matchesAwkCondition(line, index + 1, print.condition))
+            return [];
+        const parts = splitAwkFields(line, options.fieldSeparator);
+        return [fields.map((field) => {
+                if (field === '$0')
+                    return line;
+                if (field === 'NR')
+                    return String(index + 1);
+                if (field === 'NF')
+                    return String(parts.length);
+                if (field === '$NF')
+                    return parts.at(-1) ?? '';
+                const match = field.match(/^\$(\d+)$/);
+                if (match)
+                    return parts[Number(match[1]) - 1] ?? '';
+                return field.replace(/^["']|["']$/g, '');
+            }).join(' ')];
+    });
+    return rows.length ? `${rows.join('\n')}\n` : '';
+}
+function parseAwkPrintProgram(program) {
+    const print = program.match(/^(?:(NR\s*(?:==|!=|>=|<=|>|<)\s*\d+|\/.+\/)\s*)?\{\s*print(?:\s+(.+?))?\s*\}$/);
+    if (!print)
+        return undefined;
+    return {
+        condition: print[1],
+        fields: print[2] ? print[2].split(/\s*,\s*|\s+/).filter(Boolean) : [],
+    };
+}
+function matchesAwkCondition(line, lineNumber, condition) {
+    if (!condition)
+        return true;
+    const nr = condition.match(/^NR\s*(==|!=|>=|<=|>|<)\s*(\d+)$/);
+    if (nr) {
+        const value = Number(nr[2]);
+        if (nr[1] === '==')
+            return lineNumber === value;
+        if (nr[1] === '!=')
+            return lineNumber !== value;
+        if (nr[1] === '>=')
+            return lineNumber >= value;
+        if (nr[1] === '<=')
+            return lineNumber <= value;
+        if (nr[1] === '>')
+            return lineNumber > value;
+        if (nr[1] === '<')
+            return lineNumber < value;
+    }
+    const regex = condition.match(/^\/(.+)\/$/);
+    if (regex)
+        return new RegExp(regex[1]).test(line);
+    return false;
+}
+function splitAwkFields(line, fieldSeparator) {
+    if (fieldSeparator === undefined || fieldSeparator === ' ') {
+        const trimmed = line.trim();
+        return trimmed ? trimmed.split(/\s+/) : [];
+    }
+    return line.split(fieldSeparator);
+}
+function decodeAwkSeparator(value) {
+    return value
+        .replace(/\\t/g, '\t')
+        .replace(/\\n/g, '\n')
+        .replace(/\\s/g, ' ');
+}
+export function translateText(input, args) {
+    const deleteMode = args[0] === '-d';
+    const offset = deleteMode ? 1 : 0;
+    const source = expandTrSet(args[offset] || '');
+    if (deleteMode) {
+        const remove = new Set([...source]);
+        return [...input].filter((char) => !remove.has(char)).join('');
+    }
+    const target = expandTrSet(args[offset + 1] || '');
+    if (!source)
+        return input;
+    const mapping = new Map();
+    for (let index = 0; index < source.length; index += 1) {
+        mapping.set(source[index], target[index] ?? target.at(-1) ?? '');
+    }
+    return [...input].map((char) => mapping.get(char) ?? char).join('');
+}
+function parseSedSubstitution(expression) {
+    if (!expression.startsWith('s') || expression.length < 4)
+        return undefined;
+    const delimiter = expression[1];
+    const parts = [];
+    let current = '';
+    let escaped = false;
+    for (let index = 2; index < expression.length; index += 1) {
+        const char = expression[index];
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            current += char;
+            escaped = true;
+            continue;
+        }
+        if (char === delimiter && parts.length < 2) {
+            parts.push(current);
+            current = '';
+            continue;
+        }
+        current += char;
+    }
+    parts.push(current);
+    if (parts.length !== 3)
+        return undefined;
+    return { pattern: parts[0], replacement: translateSedReplacement(parts[1]), flags: parts[2] };
+}
+function translateSedReplacement(value) {
+    let output = '';
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index];
+        if (char === '\\') {
+            const next = value[++index];
+            if (next === undefined) {
+                output += '\\';
+            }
+            else if (/^\d$/.test(next)) {
+                output += `$${next}`;
+            }
+            else if (next === 'n') {
+                output += '\n';
+            }
+            else {
+                output += next;
+            }
+            continue;
+        }
+        if (char === '&') {
+            output += '$&';
+            continue;
+        }
+        output += char === '$' ? '$$' : char;
+    }
+    return output;
+}
+function applySedPrint(input, expression) {
+    const lines = splitLines(input);
+    if (expression === 'p')
+        return lines.length ? `${lines.join('\n')}\n` : '';
+    const range = expression.match(/^(\d+|\$)(?:,(\d+|\$))?p$/);
+    if (range) {
+        const start = sedAddress(range[1], lines.length);
+        const end = sedAddress(range[2] || range[1], lines.length);
+        const selected = lines.filter((_, index) => index + 1 >= start && index + 1 <= end);
+        return selected.length ? `${selected.join('\n')}\n` : '';
+    }
+    const match = expression.match(/^\/(.+)\/p$/);
+    if (match) {
+        const regex = new RegExp(match[1]);
+        const selected = lines.filter((line) => regex.test(line));
+        return selected.length ? `${selected.join('\n')}\n` : '';
+    }
+    return undefined;
+}
+function applySedDelete(input, expression, options = {}) {
+    const address = parseSedAddressExpression(expression, 'd');
+    if (!address)
+        return undefined;
+    if (options.quiet)
+        return '';
+    const lines = splitLines(input);
+    const selected = selectedSedLineIndexes(lines, address);
+    const output = lines.filter((_, index) => !selected.has(index + 1));
+    return output.length ? `${output.join('\n')}\n` : '';
+}
+function parseSedAddressExpression(expression, command) {
+    const escaped = command.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
+    const range = expression.match(new RegExp(`^(\\d+|\\$)(?:,(\\d+|\\$))?${escaped}$`));
+    if (range)
+        return { start: range[1], end: range[2] };
+    const pattern = expression.match(new RegExp(`^/(.+)/${escaped}$`));
+    if (pattern)
+        return { start: '1', pattern: pattern[1] };
+    return undefined;
+}
+function selectedSedLineIndexes(lines, address) {
+    if (address.pattern) {
+        const regex = new RegExp(address.pattern);
+        const indexes = lines
+            .map((line, index) => regex.test(line) ? index + 1 : undefined)
+            .filter((index) => index !== undefined);
+        return new Set(indexes);
+    }
+    const start = sedAddress(address.start, lines.length);
+    const end = sedAddress(address.end || address.start, lines.length);
+    return new Set(lines.map((_, index) => index + 1).filter((number) => number >= start && number <= end));
+}
+function sedAddress(value, lineCount) {
+    return value === '$' ? lineCount : Number(value);
+}
+export function takeLines(input, count, side, fromLine) {
+    const lines = splitLines(input);
+    const selected = fromLine && side === 'tail'
+        ? lines.slice(fromLine - 1)
+        : side === 'head'
+            ? lines.slice(0, count)
+            : lines.slice(Math.max(0, lines.length - count));
+    return selected.length ? `${selected.join('\n')}\n` : '';
+}
+export function takeBytes(input, count, side, fromByte) {
+    const bytes = new TextEncoder().encode(input);
+    const selected = fromByte && side === 'tail'
+        ? bytes.slice(fromByte - 1)
+        : side === 'head'
+            ? bytes.slice(0, count)
+            : bytes.slice(Math.max(0, bytes.length - count));
+    return new TextDecoder().decode(selected);
+}
+function parseNumberSelections(value) {
+    const selections = [];
+    for (const part of value.split(',')) {
+        if (!part)
+            continue;
+        const range = part.match(/^(\d+)-(\d+)$/);
+        if (range) {
+            const start = Number(range[1]);
+            const end = Number(range[2]);
+            if (start > 0 && end >= start)
+                selections.push({ start, end });
+            continue;
+        }
+        const suffix = part.match(/^(\d+)-$/);
+        if (suffix) {
+            const start = Number(suffix[1]);
+            if (start > 0)
+                selections.push({ start });
+            continue;
+        }
+        const prefix = part.match(/^-(\d+)$/);
+        if (prefix) {
+            const end = Number(prefix[1]);
+            if (end > 0)
+                selections.push({ start: 1, end });
+            continue;
+        }
+        const single = Number(part);
+        if (Number.isFinite(single) && single > 0)
+            selections.push({ start: single, end: single });
+    }
+    return selections;
+}
+function expandTrSet(value) {
+    const range = value.match(/^(.?)-(.?)$/);
+    if (!range || range[1].length !== 1 || range[2].length !== 1)
+        return value;
+    const start = range[1].charCodeAt(0);
+    const end = range[2].charCodeAt(0);
+    if (start > end)
+        return value;
+    let output = '';
+    for (let code = start; code <= end; code += 1)
+        output += String.fromCharCode(code);
+    return output;
+}
+export function splitLines(input) {
+    if (!input)
+        return [];
+    const lines = input.split('\n');
+    if (lines.at(-1) === '')
+        lines.pop();
+    return lines;
+}
+//# sourceMappingURL=text.js.map