recker 1.0.35 → 1.0.36-next.4f24ba8

package/dist/plugins/yaml.js

@@ -0,0 +1,730 @@
+export const YAML_MEDIA_TYPES = [
+    'application/yaml',
+    'application/x-yaml',
+    'text/yaml',
+    'text/x-yaml',
+];
+export const YAML_SUFFIX = '+yaml';
+export function isYamlContentType(contentType) {
+    if (!contentType)
+        return false;
+    const ct = contentType.toLowerCase().split(';')[0].trim();
+    return YAML_MEDIA_TYPES.includes(ct) || ct.endsWith(YAML_SUFFIX);
+}
+export function parseYaml(yaml, options = {}) {
+    const opts = {
+        allowDuplicateKeys: options.allowDuplicateKeys ?? false,
+        parseDates: options.parseDates ?? true,
+        customTags: options.customTags ?? {},
+        maxDepth: options.maxDepth ?? 100,
+        maxKeys: options.maxKeys ?? 10000,
+    };
+    if (!yaml || !yaml.trim()) {
+        return null;
+    }
+    let content = yaml.replace(/^\uFEFF/, '');
+    content = content.replace(/^---\s*$/gm, '').replace(/^\.\.\.\s*$/gm, '');
+    const lines = content.split('\n');
+    const state = {
+        lines,
+        index: 0,
+        depth: 0,
+        keyCount: 0,
+        options: opts,
+    };
+    const anchors = new Map();
+    return parseValue(state, 0, anchors);
+}
+function parseValue(state, baseIndent, anchors) {
+    skipEmptyAndComments(state);
+    if (state.index >= state.lines.length) {
+        return null;
+    }
+    const line = state.lines[state.index];
+    const trimmed = line.trim();
+    if (trimmed === '~' || trimmed === 'null' || trimmed === 'Null' || trimmed === 'NULL') {
+        state.index++;
+        return null;
+    }
+    if (trimmed.startsWith('- ') || trimmed === '-') {
+        return parseSequence(state, baseIndent, anchors);
+    }
+    if (trimmed.includes(':') && !trimmed.startsWith('"') && !trimmed.startsWith("'")) {
+        return parseMapping(state, baseIndent, anchors);
+    }
+    state.index++;
+    return parseScalar(trimmed, state.options, anchors);
+}
+function parseMapping(state, baseIndent, anchors) {
+    const result = {};
+    state.depth++;
+    if (state.depth > state.options.maxDepth) {
+        throw new YamlError('Maximum nesting depth exceeded', state.index);
+    }
+    while (state.index < state.lines.length) {
+        skipEmptyAndComments(state);
+        if (state.index >= state.lines.length)
+            break;
+        const line = state.lines[state.index];
+        const currentIndent = getIndent(line);
+        if (currentIndent < baseIndent && line.trim()) {
+            break;
+        }
+        if (currentIndent < baseIndent) {
+            state.index++;
+            continue;
+        }
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) {
+            state.index++;
+            continue;
+        }
+        if (trimmed.startsWith('- ') && currentIndent <= baseIndent) {
+            break;
+        }
+        const colonIndex = findKeyColon(trimmed);
+        if (colonIndex === -1) {
+            state.index++;
+            continue;
+        }
+        let key = trimmed.substring(0, colonIndex).trim();
+        let valueStr = trimmed.substring(colonIndex + 1).trim();
+        let anchor = null;
+        const anchorMatch = key.match(/^&(\w+)\s+/);
+        if (anchorMatch) {
+            anchor = anchorMatch[1];
+            key = key.substring(anchorMatch[0].length);
+        }
+        if (valueStr.startsWith('*')) {
+            const aliasName = valueStr.substring(1).split(/\s/)[0];
+            if (!anchors.has(aliasName)) {
+                throw new YamlError(`Unknown alias: ${aliasName}`, state.index);
+            }
+            result[key] = anchors.get(aliasName);
+            state.index++;
+            continue;
+        }
+        const valueAnchorMatch = valueStr.match(/^&(\w+)\s*/);
+        if (valueAnchorMatch) {
+            anchor = valueAnchorMatch[1];
+            valueStr = valueStr.substring(valueAnchorMatch[0].length);
+        }
+        key = unquote(key);
+        state.keyCount++;
+        if (state.keyCount > state.options.maxKeys) {
+            throw new YamlError('Maximum number of keys exceeded', state.index);
+        }
+        if (!state.options.allowDuplicateKeys && key in result) {
+            throw new YamlError(`Duplicate key: ${key}`, state.index);
+        }
+        state.index++;
+        let value;
+        if (valueStr === '' || valueStr === '|' || valueStr === '>' || valueStr === '|-' || valueStr === '>-') {
+            if (valueStr === '|' || valueStr === '|-') {
+                value = parseLiteralBlock(state, currentIndent, valueStr === '|-');
+            }
+            else if (valueStr === '>' || valueStr === '>-') {
+                value = parseFoldedBlock(state, currentIndent, valueStr === '>-');
+            }
+            else {
+                skipEmptyAndComments(state);
+                if (state.index < state.lines.length) {
+                    const nextIndent = getIndent(state.lines[state.index]);
+                    if (nextIndent > currentIndent) {
+                        value = parseValue(state, nextIndent, anchors);
+                    }
+                    else {
+                        value = null;
+                    }
+                }
+                else {
+                    value = null;
+                }
+            }
+        }
+        else {
+            value = parseScalar(valueStr, state.options, anchors);
+        }
+        if (anchor) {
+            anchors.set(anchor, value);
+        }
+        result[key] = value;
+    }
+    state.depth--;
+    return result;
+}
+function parseSequence(state, baseIndent, anchors) {
+    const result = [];
+    state.depth++;
+    if (state.depth > state.options.maxDepth) {
+        throw new YamlError('Maximum nesting depth exceeded', state.index);
+    }
+    while (state.index < state.lines.length) {
+        skipEmptyAndComments(state);
+        if (state.index >= state.lines.length)
+            break;
+        const line = state.lines[state.index];
+        const currentIndent = getIndent(line);
+        const trimmed = line.trim();
+        if (currentIndent < baseIndent && trimmed) {
+            break;
+        }
+        if (!trimmed.startsWith('-')) {
+            if (currentIndent <= baseIndent)
+                break;
+            state.index++;
+            continue;
+        }
+        let anchor = null;
+        let valueStr = trimmed.substring(1).trim();
+        const anchorMatch = valueStr.match(/^&(\w+)\s*/);
+        if (anchorMatch) {
+            anchor = anchorMatch[1];
+            valueStr = valueStr.substring(anchorMatch[0].length);
+        }
+        if (valueStr.startsWith('*')) {
+            const aliasName = valueStr.substring(1).split(/\s/)[0];
+            if (!anchors.has(aliasName)) {
+                throw new YamlError(`Unknown alias: ${aliasName}`, state.index);
+            }
+            result.push(anchors.get(aliasName));
+            state.index++;
+            continue;
+        }
+        state.index++;
+        let value;
+        if (valueStr === '') {
+            skipEmptyAndComments(state);
+            if (state.index < state.lines.length) {
+                const nextIndent = getIndent(state.lines[state.index]);
+                if (nextIndent > currentIndent) {
+                    value = parseValue(state, nextIndent, anchors);
+                }
+                else {
+                    value = null;
+                }
+            }
+            else {
+                value = null;
+            }
+        }
+        else if (valueStr.includes(':') && !valueStr.startsWith('"') && !valueStr.startsWith("'")) {
+            state.index--;
+            const fakeLine = ' '.repeat(currentIndent + 2) + valueStr;
+            const originalLine = state.lines[state.index];
+            state.lines[state.index] = fakeLine;
+            value = parseMapping(state, currentIndent + 2, anchors);
+            if (state.index < state.lines.length) {
+                state.lines[state.index - 1] = originalLine;
+            }
+        }
+        else {
+            value = parseScalar(valueStr, state.options, anchors);
+        }
+        if (anchor) {
+            anchors.set(anchor, value);
+        }
+        result.push(value);
+    }
+    state.depth--;
+    return result;
+}
+function parseLiteralBlock(state, baseIndent, chomp) {
+    const lines = [];
+    let contentIndent = -1;
+    while (state.index < state.lines.length) {
+        const line = state.lines[state.index];
+        const indent = getIndent(line);
+        const trimmed = line.trim();
+        if (contentIndent === -1 && trimmed) {
+            contentIndent = indent;
+        }
+        if (contentIndent !== -1 && indent < contentIndent && trimmed) {
+            break;
+        }
+        if (trimmed && indent <= baseIndent) {
+            break;
+        }
+        if (contentIndent !== -1) {
+            const relativeIndent = Math.max(0, indent - contentIndent);
+            lines.push(' '.repeat(relativeIndent) + trimmed);
+        }
+        else {
+            lines.push('');
+        }
+        state.index++;
+    }
+    if (chomp) {
+        while (lines.length > 0 && lines[lines.length - 1] === '') {
+            lines.pop();
+        }
+    }
+    return lines.join('\n');
+}
+function parseFoldedBlock(state, baseIndent, chomp) {
+    const paragraphs = [];
+    let currentParagraph = [];
+    let contentIndent = -1;
+    while (state.index < state.lines.length) {
+        const line = state.lines[state.index];
+        const indent = getIndent(line);
+        const trimmed = line.trim();
+        if (contentIndent === -1 && trimmed) {
+            contentIndent = indent;
+        }
+        if (contentIndent !== -1 && indent < contentIndent && trimmed) {
+            break;
+        }
+        if (trimmed && indent <= baseIndent) {
+            break;
+        }
+        if (contentIndent !== -1) {
+            if (trimmed === '') {
+                if (currentParagraph.length > 0) {
+                    paragraphs.push(currentParagraph.join(' '));
+                    currentParagraph = [];
+                }
+                paragraphs.push('');
+            }
+            else {
+                currentParagraph.push(trimmed);
+            }
+        }
+        state.index++;
+    }
+    if (currentParagraph.length > 0) {
+        paragraphs.push(currentParagraph.join(' '));
+    }
+    if (chomp) {
+        while (paragraphs.length > 0 && paragraphs[paragraphs.length - 1] === '') {
+            paragraphs.pop();
+        }
+    }
+    return paragraphs.join('\n');
+}
+function parseScalar(value, options, anchors) {
+    if (value.startsWith('*')) {
+        const aliasName = value.substring(1).split(/\s|#/)[0];
+        if (!anchors.has(aliasName)) {
+            throw new YamlError(`Unknown alias: ${aliasName}`);
+        }
+        return anchors.get(aliasName);
+    }
+    const commentIndex = findInlineComment(value);
+    if (commentIndex !== -1) {
+        value = value.substring(0, commentIndex).trim();
+    }
+    const tagMatch = value.match(/^!(\S+)\s*/);
+    if (tagMatch) {
+        const tag = tagMatch[1];
+        const tagValue = value.substring(tagMatch[0].length);
+        if (options.customTags[tag]) {
+            return options.customTags[tag](tagValue);
+        }
+        return tagValue;
+    }
+    if (value === '' || value === '~' || value === 'null' || value === 'Null' || value === 'NULL') {
+        return null;
+    }
+    if (value === 'true' || value === 'True' || value === 'TRUE' || value === 'yes' || value === 'Yes' || value === 'YES' || value === 'on' || value === 'On' || value === 'ON') {
+        return true;
+    }
+    if (value === 'false' || value === 'False' || value === 'FALSE' || value === 'no' || value === 'No' || value === 'NO' || value === 'off' || value === 'Off' || value === 'OFF') {
+        return false;
+    }
+    if (value === '.inf' || value === '.Inf' || value === '.INF' || value === '+.inf' || value === '+.Inf' || value === '+.INF') {
+        return Infinity;
+    }
+    if (value === '-.inf' || value === '-.Inf' || value === '-.INF') {
+        return -Infinity;
+    }
+    if (value === '.nan' || value === '.NaN' || value === '.NAN') {
+        return NaN;
+    }
+    if (/^0o[0-7]+$/.test(value)) {
+        return parseInt(value.substring(2), 8);
+    }
+    if (/^0x[0-9a-fA-F]+$/.test(value)) {
+        return parseInt(value, 16);
+    }
+    if (/^[-+]?\d+$/.test(value)) {
+        const num = parseInt(value, 10);
+        if (Number.isSafeInteger(num)) {
+            return num;
+        }
+        return num;
+    }
+    if (/^[-+]?(\d+\.?\d*|\.\d+)([eE][-+]?\d+)?$/.test(value)) {
+        return parseFloat(value);
+    }
+    if (/^\d+:\d{2}(:\d{2})?(\.\d+)?$/.test(value)) {
+        const parts = value.split(':').map(parseFloat);
+        let result = parts[0];
+        for (let i = 1; i < parts.length; i++) {
+            result = result * 60 + parts[i];
+        }
+        return result;
+    }
+    if (options.parseDates) {
+        if (/^\d{4}-\d{2}-\d{2}([T ]\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})?)?$/.test(value)) {
+            const date = new Date(value.replace(' ', 'T'));
+            if (!isNaN(date.getTime())) {
+                return date;
+            }
+        }
+    }
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+        return unquote(value);
+    }
+    if (value.startsWith('[') && value.endsWith(']')) {
+        return parseFlowSequence(value, options, anchors);
+    }
+    if (value.startsWith('{') && value.endsWith('}')) {
+        return parseFlowMapping(value, options, anchors);
+    }
+    return value;
+}
+function parseFlowSequence(value, options, anchors) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner)
+        return [];
+    const items = [];
+    let current = '';
+    let depth = 0;
+    let inQuote = false;
+    let quoteChar = '';
+    for (let i = 0; i < inner.length; i++) {
+        const char = inner[i];
+        if (inQuote) {
+            current += char;
+            if (char === quoteChar && inner[i - 1] !== '\\') {
+                inQuote = false;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            inQuote = true;
+            quoteChar = char;
+            current += char;
+            continue;
+        }
+        if (char === '[' || char === '{') {
+            depth++;
+            current += char;
+            continue;
+        }
+        if (char === ']' || char === '}') {
+            depth--;
+            current += char;
+            continue;
+        }
+        if (char === ',' && depth === 0) {
+            items.push(parseScalar(current.trim(), options, anchors));
+            current = '';
+            continue;
+        }
+        current += char;
+    }
+    if (current.trim()) {
+        items.push(parseScalar(current.trim(), options, anchors));
+    }
+    return items;
+}
+function parseFlowMapping(value, options, anchors) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner)
+        return {};
+    const result = {};
+    let current = '';
+    let depth = 0;
+    let inQuote = false;
+    let quoteChar = '';
+    for (let i = 0; i < inner.length; i++) {
+        const char = inner[i];
+        if (inQuote) {
+            current += char;
+            if (char === quoteChar && inner[i - 1] !== '\\') {
+                inQuote = false;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            inQuote = true;
+            quoteChar = char;
+            current += char;
+            continue;
+        }
+        if (char === '[' || char === '{') {
+            depth++;
+            current += char;
+            continue;
+        }
+        if (char === ']' || char === '}') {
+            depth--;
+            current += char;
+            continue;
+        }
+        if (char === ',' && depth === 0) {
+            const colonIdx = findKeyColon(current);
+            if (colonIdx !== -1) {
+                const key = unquote(current.substring(0, colonIdx).trim());
+                const val = current.substring(colonIdx + 1).trim();
+                result[key] = parseScalar(val, options, anchors);
+            }
+            current = '';
+            continue;
+        }
+        current += char;
+    }
+    if (current.trim()) {
+        const colonIdx = findKeyColon(current);
+        if (colonIdx !== -1) {
+            const key = unquote(current.substring(0, colonIdx).trim());
+            const val = current.substring(colonIdx + 1).trim();
+            result[key] = parseScalar(val, options, anchors);
+        }
+    }
+    return result;
+}
+function getIndent(line) {
+    const match = line.match(/^(\s*)/);
+    return match ? match[1].length : 0;
+}
+function skipEmptyAndComments(state) {
+    while (state.index < state.lines.length) {
+        const trimmed = state.lines[state.index].trim();
+        if (trimmed && !trimmed.startsWith('#')) {
+            break;
+        }
+        state.index++;
+    }
+}
+function findKeyColon(str) {
+    let inQuote = false;
+    let quoteChar = '';
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        if (inQuote) {
+            if (char === quoteChar && str[i - 1] !== '\\') {
+                inQuote = false;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            inQuote = true;
+            quoteChar = char;
+            continue;
+        }
+        if (char === ':') {
+            if (i === str.length - 1 || str[i + 1] === ' ' || str[i + 1] === '\n' || str[i + 1] === '\t') {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+function findInlineComment(str) {
+    let inQuote = false;
+    let quoteChar = '';
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        if (inQuote) {
+            if (char === quoteChar && str[i - 1] !== '\\') {
+                inQuote = false;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            inQuote = true;
+            quoteChar = char;
+            continue;
+        }
+        if (char === '#' && (i === 0 || str[i - 1] === ' ' || str[i - 1] === '\t')) {
+            return i;
+        }
+    }
+    return -1;
+}
+function unquote(str) {
+    if (str.startsWith('"') && str.endsWith('"')) {
+        return str
+            .slice(1, -1)
+            .replace(/\\"/g, '"')
+            .replace(/\\\\/g, '\\')
+            .replace(/\\n/g, '\n')
+            .replace(/\\t/g, '\t')
+            .replace(/\\r/g, '\r')
+            .replace(/\\0/g, '\0')
+            .replace(/\\x([0-9a-fA-F]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
+            .replace(/\\u([0-9a-fA-F]{4})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+    }
+    if (str.startsWith("'") && str.endsWith("'")) {
+        return str.slice(1, -1).replace(/''/g, "'");
+    }
+    return str;
+}
+export class YamlError extends Error {
+    line;
+    constructor(message, line) {
+        super(line !== undefined ? `${message} at line ${line + 1}` : message);
+        this.name = 'YamlError';
+        this.line = line;
+    }
+}
+export function serializeYaml(data, options = {}) {
+    const opts = {
+        indent: options.indent ?? 2,
+        lineWidth: options.lineWidth ?? 80,
+        forceQuotes: options.forceQuotes ?? false,
+        flowStyle: options.flowStyle ?? false,
+        sortKeys: options.sortKeys ?? false,
+        skipUndefined: options.skipUndefined ?? true,
+        documentMarkers: options.documentMarkers ?? false,
+    };
+    let result = '';
+    if (opts.documentMarkers) {
+        result += '---\n';
+    }
+    result += serializeValue(data, 0, opts);
+    if (opts.documentMarkers) {
+        result += '\n...';
+    }
+    return result;
+}
+function serializeValue(value, depth, opts) {
+    if (value === null || value === undefined) {
+        return 'null';
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    if (typeof value === 'number') {
+        if (Number.isNaN(value))
+            return '.nan';
+        if (value === Infinity)
+            return '.inf';
+        if (value === -Infinity)
+            return '-.inf';
+        return String(value);
+    }
+    if (typeof value === 'string') {
+        return serializeString(value, depth, opts);
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (Array.isArray(value)) {
+        return serializeArray(value, depth, opts);
+    }
+    if (typeof value === 'object') {
+        return serializeObject(value, depth, opts);
+    }
+    return String(value);
+}
+function serializeString(str, depth, opts) {
+    const needsQuotes = opts.forceQuotes ||
+        str === '' ||
+        str === 'null' ||
+        str === 'true' ||
+        str === 'false' ||
+        str === '~' ||
+        /^[\d\-.]+$/.test(str) ||
+        /^[&*!|>'"%@`]/.test(str) ||
+        /[:#\[\]{}]/.test(str) ||
+        str.includes('\n');
+    if (str.includes('\n')) {
+        const indent = ' '.repeat(opts.indent * (depth + 1));
+        const lines = str.split('\n');
+        return '|\n' + lines.map((line) => indent + line).join('\n');
+    }
+    if (needsQuotes) {
+        const escaped = str
+            .replace(/\\/g, '\\\\')
+            .replace(/"/g, '\\"')
+            .replace(/\n/g, '\\n')
+            .replace(/\t/g, '\\t')
+            .replace(/\r/g, '\\r');
+        return `"${escaped}"`;
+    }
+    return str;
+}
+function serializeArray(arr, depth, opts) {
+    if (arr.length === 0) {
+        return '[]';
+    }
+    if (opts.flowStyle && arr.length <= 5 && arr.every((v) => typeof v !== 'object' || v === null)) {
+        const items = arr.map((v) => serializeValue(v, depth, opts));
+        const flow = `[${items.join(', ')}]`;
+        if (flow.length <= opts.lineWidth) {
+            return flow;
+        }
+    }
+    const indent = ' '.repeat(opts.indent * depth);
+    const lines = [];
+    for (const item of arr) {
+        if (opts.skipUndefined && item === undefined) {
+            continue;
+        }
+        if (typeof item === 'object' && item !== null && !Array.isArray(item) && !(item instanceof Date)) {
+            const objStr = serializeObject(item, depth + 1, opts);
+            const firstLine = objStr.split('\n')[0];
+            const restLines = objStr.split('\n').slice(1);
+            lines.push(`${indent}- ${firstLine}`);
+            lines.push(...restLines.map((l) => `${indent}  ${l.trimStart()}`));
+        }
+        else if (Array.isArray(item) && item.length > 0 && !opts.flowStyle) {
+            lines.push(`${indent}-`);
+            const nested = serializeArray(item, depth + 1, opts);
+            lines.push(...nested.split('\n').map((l) => `${indent}  ${l.trimStart()}`));
+        }
+        else {
+            lines.push(`${indent}- ${serializeValue(item, depth + 1, opts)}`);
+        }
+    }
+    return lines.join('\n');
+}
+function serializeObject(obj, depth, opts) {
+    const keys = Object.keys(obj);
+    if (keys.length === 0) {
+        return '{}';
+    }
+    if (opts.sortKeys) {
+        keys.sort();
+    }
+    if (opts.flowStyle && keys.length <= 3 && keys.every((k) => typeof obj[k] !== 'object' || obj[k] === null)) {
+        const items = keys.map((k) => `${k}: ${serializeValue(obj[k], depth, opts)}`);
+        const flow = `{${items.join(', ')}}`;
+        if (flow.length <= opts.lineWidth) {
+            return flow;
+        }
+    }
+    const indent = ' '.repeat(opts.indent * depth);
+    const lines = [];
+    for (const key of keys) {
+        const value = obj[key];
+        if (opts.skipUndefined && value === undefined) {
+            continue;
+        }
+        const quotedKey = /^[\w-]+$/.test(key) && key !== 'true' && key !== 'false' && key !== 'null' ? key : `"${key}"`;
+        if (typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof Date)) {
+            lines.push(`${indent}${quotedKey}:`);
+            const nested = serializeObject(value, depth + 1, opts);
+            lines.push(...nested.split('\n'));
+        }
+        else if (Array.isArray(value) && value.length > 0 && !opts.flowStyle) {
+            lines.push(`${indent}${quotedKey}:`);
+            const nested = serializeArray(value, depth + 1, opts);
+            lines.push(...nested.split('\n'));
+        }
+        else {
+            lines.push(`${indent}${quotedKey}: ${serializeValue(value, depth + 1, opts)}`);
+        }
+    }
+    return lines.join('\n');
+}
+export async function yamlResponse(promise, options) {
+    const response = await promise;
+    const text = await response.text();
+    return parseYaml(text, options);
+}
+export { parseYaml as yamlParse, serializeYaml as yamlSerialize };