@xylentis/testgen 0.0.0-stage → 1.0.0

package/dist/vendor/playwright/selectorParser.js

@@ -0,0 +1,427 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { InvalidSelectorError, parseCSS } from './cssParser.js';
+export { InvalidSelectorError, isInvalidSelectorError } from './cssParser.js';
+const kNestedSelectorNames = new Set(['internal:has', 'internal:has-not', 'internal:and', 'internal:or', 'internal:chain', 'left-of', 'right-of', 'above', 'below', 'near']);
+const kNestedSelectorNamesWithDistance = new Set(['left-of', 'right-of', 'above', 'below', 'near']);
+export const customCSSNames = new Set(['not', 'is', 'where', 'has', 'scope', 'light', 'visible', 'text', 'text-matches', 'text-is', 'has-text', 'above', 'below', 'right-of', 'left-of', 'near', 'nth-match']);
+export function parseSelector(selector) {
+    const parsedStrings = parseSelectorString(selector);
+    const parts = [];
+    for (const part of parsedStrings.parts) {
+        if (part.name === 'css' || part.name === 'css:light') {
+            if (part.name === 'css:light')
+                part.body = ':light(' + part.body + ')';
+            const parsedCSS = parseCSS(part.body, customCSSNames);
+            parts.push({
+                name: 'css',
+                body: parsedCSS.selector,
+                source: part.body
+            });
+            continue;
+        }
+        if (kNestedSelectorNames.has(part.name)) {
+            let innerSelector;
+            let distance;
+            try {
+                const unescaped = JSON.parse('[' + part.body + ']');
+                if (!Array.isArray(unescaped) || unescaped.length < 1 || unescaped.length > 2 || typeof unescaped[0] !== 'string')
+                    throw new InvalidSelectorError(`Malformed selector: ${part.name}=` + part.body);
+                innerSelector = unescaped[0];
+                if (unescaped.length === 2) {
+                    if (typeof unescaped[1] !== 'number' || !kNestedSelectorNamesWithDistance.has(part.name))
+                        throw new InvalidSelectorError(`Malformed selector: ${part.name}=` + part.body);
+                    distance = unescaped[1];
+                }
+            }
+            catch (e) {
+                throw new InvalidSelectorError(`Malformed selector: ${part.name}=` + part.body);
+            }
+            const nested = { name: part.name, source: part.body, body: { parsed: parseSelector(innerSelector), distance } };
+            const lastFrame = [...nested.body.parsed.parts].reverse().find(part => part.name === 'internal:control' && part.body === 'enter-frame');
+            const lastFrameIndex = lastFrame ? nested.body.parsed.parts.indexOf(lastFrame) : -1;
+            // The "any-frame" token applies to the whole selector, so nested selectors must not repeat it.
+            const outerParts = parts[0]?.name === 'internal:control' && parts[0].body === 'any-frame' ? parts.slice(1) : parts;
+            // Allow nested selectors to start with the same frame selector.
+            if (lastFrameIndex !== -1 && selectorPartsEqual(nested.body.parsed.parts.slice(0, lastFrameIndex + 1), outerParts.slice(0, lastFrameIndex + 1))) {
+                nested.body.parsed.parts.splice(0, lastFrameIndex + 1);
+                if (nested.body.parsed.capture !== undefined) {
+                    if (nested.body.parsed.capture <= lastFrameIndex)
+                        throw new InvalidSelectorError(`Can not capture the selector before diving into the frame. Only use * after the last frame has been selected`);
+                    // The capture refers to a part index, so it shifts along with the removed prefix.
+                    nested.body.parsed.capture -= lastFrameIndex + 1;
+                }
+            }
+            parts.push(nested);
+            continue;
+        }
+        parts.push({ ...part, source: part.body });
+    }
+    if (kNestedSelectorNames.has(parts[0].name))
+        throw new InvalidSelectorError(`"${parts[0].name}" selector cannot be first`);
+    return {
+        capture: parsedStrings.capture,
+        parts
+    };
+}
+// Matches in any frame of the subtree, instead of the frame itself. Only allowed as the first token.
+export const kAnyFrameSelector = 'internal:control=any-frame';
+// Splits a selector into per-frame chunks separated by "enter-frame" boundaries.
+// The optional leading "any-frame" token is consumed and reported separately.
+export function splitSelectorByFrame(selectorText) {
+    const selector = parseSelector(selectorText);
+    const chunks = [];
+    let chunk = {
+        parts: [],
+    };
+    let anyFrame = false;
+    let chunkStartIndex = 0;
+    for (let i = 0; i < selector.parts.length; ++i) {
+        const part = selector.parts[i];
+        if (part.name === 'internal:control' && part.body === 'any-frame') {
+            // The starting frame applies to the whole selector, so the token only makes sense as the very first one.
+            if (i !== 0)
+                throw new InvalidSelectorError(`"${part.body}" is only allowed as the first selector token, while parsing selector ${selectorText}`);
+            anyFrame = true;
+            chunkStartIndex = i + 1;
+            continue;
+        }
+        if (part.name === 'internal:control' && part.body === 'enter-frame') {
+            const lastPart = chunk.parts[chunk.parts.length - 1];
+            if (!lastPart || (lastPart.name === 'internal:control' && lastPart.body === 'enter-frame'))
+                throw new InvalidSelectorError('Selector cannot start with entering frame, select the iframe first');
+            chunks.push(chunk);
+            chunk = { parts: [] };
+            chunkStartIndex = i + 1;
+            continue;
+        }
+        if (selector.capture === i)
+            chunk.capture = i - chunkStartIndex;
+        chunk.parts.push(part);
+    }
+    if (!chunk.parts.length) {
+        if (anyFrame && !chunks.length)
+            throw new InvalidSelectorError(`Selector cannot be empty after frameLocator(), while parsing selector ${selectorText}`);
+        throw new InvalidSelectorError(`Selector cannot end with entering frame, while parsing selector ${selectorText}`);
+    }
+    const lastPart = chunk.parts[chunk.parts.length - 1];
+    if (lastPart.name === 'internal:control' && lastPart.body === 'enter-frame')
+        throw new InvalidSelectorError(`Selector cannot end with entering frame, while parsing selector ${selectorText}`);
+    chunks.push(chunk);
+    if (typeof selector.capture === 'number' && typeof chunks[chunks.length - 1].capture !== 'number')
+        throw new InvalidSelectorError(`Can not capture the selector before diving into the frame. Only use * after the last frame has been selected`);
+    return { anyFrame, chunks };
+}
+function selectorPartsEqual(list1, list2) {
+    return stringifySelector({ parts: list1 }) === stringifySelector({ parts: list2 });
+}
+export function stringifySelector(selector, forceEngineName) {
+    if (typeof selector === 'string')
+        return selector;
+    return selector.parts.map((p, i) => {
+        let includeEngine = true;
+        if (!forceEngineName && i !== selector.capture) {
+            if (p.name === 'css')
+                includeEngine = false;
+            else if (p.name === 'xpath' && (p.source.startsWith('//') || p.source.startsWith('..')))
+                includeEngine = false;
+        }
+        const prefix = includeEngine ? p.name + '=' : '';
+        return `${i === selector.capture ? '*' : ''}${prefix}${p.source}`;
+    }).join(' >> ');
+}
+export function visitAllSelectorParts(selector, visitor) {
+    const visit = (selector, nested) => {
+        for (const part of selector.parts) {
+            visitor(part, nested);
+            if (kNestedSelectorNames.has(part.name))
+                visit(part.body.parsed, true);
+        }
+    };
+    visit(selector, false);
+}
+function parseSelectorString(selector) {
+    let index = 0;
+    let quote;
+    let start = 0;
+    const result = { parts: [] };
+    const append = () => {
+        const part = selector.substring(start, index).trim();
+        const eqIndex = part.indexOf('=');
+        let name;
+        let body;
+        if (eqIndex !== -1 && part.substring(0, eqIndex).trim().match(/^[a-zA-Z_0-9-+:*]+$/)) {
+            name = part.substring(0, eqIndex).trim();
+            body = part.substring(eqIndex + 1);
+        }
+        else if (part.length > 1 && part[0] === '"' && part[part.length - 1] === '"') {
+            name = 'text';
+            body = part;
+        }
+        else if (part.length > 1 && part[0] === "'" && part[part.length - 1] === "'") {
+            name = 'text';
+            body = part;
+        }
+        else if (/^\(*\/\//.test(part) || part.startsWith('..')) {
+            // If selector starts with '//' or '//' prefixed with multiple opening
+            // parenthesis, consider xpath. @see https://github.com/microsoft/playwright/issues/817
+            // If selector starts with '..', consider xpath as well.
+            name = 'xpath';
+            body = part;
+        }
+        else {
+            name = 'css';
+            body = part;
+        }
+        let capture = false;
+        if (name[0] === '*') {
+            capture = true;
+            name = name.substring(1);
+        }
+        result.parts.push({ name, body });
+        if (capture) {
+            if (result.capture !== undefined)
+                throw new InvalidSelectorError(`Only one of the selectors can capture using * modifier`);
+            result.capture = result.parts.length - 1;
+        }
+    };
+    if (!selector.includes('>>')) {
+        index = selector.length;
+        append();
+        return result;
+    }
+    const shouldIgnoreTextSelectorQuote = () => {
+        const prefix = selector.substring(start, index);
+        const match = prefix.match(/^\s*text\s*=(.*)$/);
+        // Must be a text selector with some text before the quote.
+        return !!match && !!match[1];
+    };
+    while (index < selector.length) {
+        const c = selector[index];
+        if (c === '\\' && index + 1 < selector.length) {
+            index += 2;
+        }
+        else if (c === quote) {
+            quote = undefined;
+            index++;
+        }
+        else if (!quote && (c === '"' || c === '\'' || c === '`') && !shouldIgnoreTextSelectorQuote()) {
+            quote = c;
+            index++;
+        }
+        else if (!quote && c === '>' && selector[index + 1] === '>') {
+            append();
+            index += 2;
+            start = index;
+        }
+        else {
+            index++;
+        }
+    }
+    append();
+    return result;
+}
+export function parseAttributeSelector(selector, allowUnquotedStrings) {
+    let wp = 0;
+    let EOL = selector.length === 0;
+    const next = () => selector[wp] || '';
+    const eat1 = () => {
+        const result = next();
+        ++wp;
+        EOL = wp >= selector.length;
+        return result;
+    };
+    const syntaxError = (stage) => {
+        if (EOL)
+            throw new InvalidSelectorError(`Unexpected end of selector while parsing selector \`${selector}\``);
+        throw new InvalidSelectorError(`Error while parsing selector \`${selector}\` - unexpected symbol "${next()}" at position ${wp}` + (stage ? ' during ' + stage : ''));
+    };
+    function skipSpaces() {
+        while (!EOL && /\s/.test(next()))
+            eat1();
+    }
+    function isCSSNameChar(char) {
+        // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
+        return (char >= '\u0080') // non-ascii
+            || (char >= '\u0030' && char <= '\u0039') // digit
+            || (char >= '\u0041' && char <= '\u005a') // uppercase letter
+            || (char >= '\u0061' && char <= '\u007a') // lowercase letter
+            || (char >= '\u0030' && char <= '\u0039') // digit
+            || char === '\u005f' // "_"
+            || char === '\u002d'; // "-"
+    }
+    function readIdentifier() {
+        let result = '';
+        skipSpaces();
+        while (!EOL && isCSSNameChar(next()))
+            result += eat1();
+        return result;
+    }
+    function readQuotedString(quote) {
+        let result = eat1();
+        if (result !== quote)
+            syntaxError('parsing quoted string');
+        while (!EOL && next() !== quote) {
+            if (next() === '\\')
+                eat1();
+            result += eat1();
+        }
+        if (next() !== quote)
+            syntaxError('parsing quoted string');
+        result += eat1();
+        return result;
+    }
+    function readRegularExpression() {
+        if (eat1() !== '/')
+            syntaxError('parsing regular expression');
+        let source = '';
+        let inClass = false;
+        // https://262.ecma-international.org/11.0/#sec-literals-regular-expression-literals
+        while (!EOL) {
+            if (next() === '\\') {
+                source += eat1();
+                if (EOL)
+                    syntaxError('parsing regular expression');
+            }
+            else if (inClass && next() === ']') {
+                inClass = false;
+            }
+            else if (!inClass && next() === '[') {
+                inClass = true;
+            }
+            else if (!inClass && next() === '/') {
+                break;
+            }
+            source += eat1();
+        }
+        if (eat1() !== '/')
+            syntaxError('parsing regular expression');
+        let flags = '';
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
+        while (!EOL && next().match(/[dgimsuvy]/))
+            flags += eat1();
+        try {
+            return new RegExp(source, flags);
+        }
+        catch (e) {
+            throw new InvalidSelectorError(`Error while parsing selector \`${selector}\`: ${e.message}`);
+        }
+    }
+    function readAttributeToken() {
+        let token = '';
+        skipSpaces();
+        if (next() === `'` || next() === `"`)
+            token = readQuotedString(next()).slice(1, -1);
+        else
+            token = readIdentifier();
+        if (!token)
+            syntaxError('parsing property path');
+        return token;
+    }
+    function readOperator() {
+        skipSpaces();
+        let op = '';
+        if (!EOL)
+            op += eat1();
+        if (!EOL && (op !== '='))
+            op += eat1();
+        if (!['=', '*=', '^=', '$=', '|=', '~='].includes(op))
+            syntaxError('parsing operator');
+        return op;
+    }
+    function readAttribute() {
+        // skip leading [
+        eat1();
+        // read attribute name:
+        // foo.bar
+        // 'foo'  . "ba zz"
+        const jsonPath = [];
+        jsonPath.push(readAttributeToken());
+        skipSpaces();
+        while (next() === '.') {
+            eat1();
+            jsonPath.push(readAttributeToken());
+            skipSpaces();
+        }
+        // check property is truthy: [enabled]
+        if (next() === ']') {
+            eat1();
+            return { name: jsonPath.join('.'), jsonPath, op: '<truthy>', value: null, caseSensitive: false };
+        }
+        const operator = readOperator();
+        let value = undefined;
+        let caseSensitive = true;
+        skipSpaces();
+        if (next() === '/') {
+            if (operator !== '=')
+                throw new InvalidSelectorError(`Error while parsing selector \`${selector}\` - cannot use ${operator} in attribute with regular expression`);
+            value = readRegularExpression();
+        }
+        else if (next() === `'` || next() === `"`) {
+            value = readQuotedString(next()).slice(1, -1);
+            skipSpaces();
+            if (next() === 'i' || next() === 'I') {
+                caseSensitive = false;
+                eat1();
+            }
+            else if (next() === 's' || next() === 'S') {
+                caseSensitive = true;
+                eat1();
+            }
+        }
+        else {
+            value = '';
+            while (!EOL && (isCSSNameChar(next()) || next() === '+' || next() === '.'))
+                value += eat1();
+            if (value === 'true') {
+                value = true;
+            }
+            else if (value === 'false') {
+                value = false;
+            }
+            else {
+                if (!allowUnquotedStrings) {
+                    value = +value;
+                    if (Number.isNaN(value))
+                        syntaxError('parsing attribute value');
+                }
+            }
+        }
+        skipSpaces();
+        if (next() !== ']')
+            syntaxError('parsing attribute value');
+        eat1();
+        if (operator !== '=' && typeof value !== 'string')
+            throw new InvalidSelectorError(`Error while parsing selector \`${selector}\` - cannot use ${operator} in attribute with non-string matching value - ${value}`);
+        return { name: jsonPath.join('.'), jsonPath, op: operator, value, caseSensitive };
+    }
+    const result = {
+        name: '',
+        attributes: [],
+    };
+    result.name = readIdentifier();
+    skipSpaces();
+    while (next() === '[') {
+        result.attributes.push(readAttribute());
+        skipSpaces();
+    }
+    if (!EOL)
+        syntaxError(undefined);
+    if (!result.name && !result.attributes.length)
+        throw new InvalidSelectorError(`Error while parsing selector \`${selector}\` - selector cannot be empty`);
+    return result;
+}
+//# sourceMappingURL=selectorParser.js.map

package/dist/vendor/playwright/stringUtils.js

@@ -0,0 +1,195 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// NOTE: this function should not be used to escape any selectors.
+export function escapeWithQuotes(text, char = '\'') {
+    const stringified = JSON.stringify(text);
+    const escapedText = stringified.substring(1, stringified.length - 1).replace(/\\"/g, '"');
+    if (char === '\'')
+        return char + escapedText.replace(/[']/g, '\\\'') + char;
+    if (char === '"')
+        return char + escapedText.replace(/["]/g, '\\"') + char;
+    if (char === '`')
+        return char + escapedText.replace(/[`]/g, '\\`') + char;
+    throw new Error('Invalid escape char');
+}
+export function escapeTemplateString(text) {
+    return text
+        .replace(/\\/g, '\\\\')
+        .replace(/`/g, '\\`')
+        .replace(/\$\{/g, '\\${');
+}
+export function isString(obj) {
+    return typeof obj === 'string' || obj instanceof String;
+}
+export function toTitleCase(name) {
+    return name.charAt(0).toUpperCase() + name.substring(1);
+}
+export function toSnakeCase(name) {
+    // E.g. ignoreHTTPSErrors => ignore_https_errors.
+    return name.replace(/([a-z0-9])([A-Z])/g, '$1_$2').replace(/([A-Z])([A-Z][a-z])/g, '$1_$2').toLowerCase();
+}
+export function formatObject(value, indent = '  ', mode = 'multiline') {
+    if (typeof value === 'string')
+        return escapeWithQuotes(value, '\'');
+    if (Array.isArray(value))
+        return `[${value.map(o => formatObject(o)).join(', ')}]`;
+    if (typeof value === 'object') {
+        const keys = Object.keys(value).filter(key => key !== 'timeout' && value[key] !== undefined).sort();
+        if (!keys.length)
+            return '{}';
+        const tokens = [];
+        for (const key of keys)
+            tokens.push(`${key}: ${formatObject(value[key])}`);
+        if (mode === 'multiline')
+            return `{\n${tokens.map(t => indent + t).join(`,\n`)}\n}`;
+        return `{ ${tokens.join(', ')} }`;
+    }
+    return String(value);
+}
+export function formatObjectOrVoid(value, indent = '  ') {
+    const result = formatObject(value, indent);
+    return result === '{}' ? '' : result;
+}
+export function quoteCSSAttributeValue(text) {
+    return `"${text.replace(/["\\]/g, char => '\\' + char)}"`;
+}
+let normalizedWhitespaceCache;
+export function cacheNormalizedWhitespaces() {
+    normalizedWhitespaceCache = new Map();
+}
+export function normalizeWhiteSpace(text) {
+    let result = normalizedWhitespaceCache?.get(text);
+    if (result === undefined) {
+        result = text.replace(/[\u200b\u00ad]/g, '').trim().replace(/\s+/g, ' ');
+        normalizedWhitespaceCache?.set(text, result);
+    }
+    return result;
+}
+export function normalizeEscapedRegexQuotes(source) {
+    // This function reverses the effect of escapeRegexForSelector below.
+    // Odd number of backslashes followed by the quote -> remove unneeded backslash.
+    return source.replace(/(^|[^\\])(\\\\)*\\(['"`])/g, '$1$2$3');
+}
+function escapeRegexForSelector(re) {
+    // Unicode mode does not allow "identity character escapes", so we do not escape and
+    // hope that it does not contain quotes and/or >> signs.
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Character_escape
+    // TODO: rework RE usages in internal selectors away from literal representation to json, e.g. {source,flags}.
+    if (re.unicode || re.unicodeSets)
+        return String(re);
+    // Even number of backslashes followed by the quote -> insert a backslash.
+    return String(re).replace(/(^|[^\\])(\\\\)*(["'`])/g, '$1$2\\$3').replace(/>>/g, '\\>\\>');
+}
+export function escapeForTextSelector(text, exact) {
+    if (typeof text !== 'string')
+        return escapeRegexForSelector(text);
+    return `${JSON.stringify(text)}${exact ? 's' : 'i'}`;
+}
+export function escapeForAttributeSelector(value, exact) {
+    if (typeof value !== 'string')
+        return escapeRegexForSelector(value);
+    // TODO: this should actually be
+    //   cssEscape(value).replace(/\\ /g, ' ')
+    // However, our attribute selectors do not conform to CSS parsing spec,
+    // so we escape them differently.
+    return `"${value.replace(/\\/g, '\\\\').replace(/["]/g, '\\"')}"${exact ? 's' : 'i'}`;
+}
+export function trimString(input, cap, suffix = '') {
+    if (input.length <= cap)
+        return input;
+    const chars = [...input];
+    if (chars.length > cap)
+        return chars.slice(0, cap - suffix.length).join('') + suffix;
+    return chars.join('');
+}
+export function trimStringWithEllipsis(input, cap) {
+    return trimString(input, cap, '\u2026');
+}
+export function truncateDataUrl(url) {
+    // Data URLs can carry megabytes of base64 payload, which is never useful in
+    // human/AI-facing output. Keep the media type prefix for context, drop the data.
+    if (!url.startsWith('data:'))
+        return url;
+    const comma = url.indexOf(',');
+    if (comma === -1)
+        return url;
+    return url.slice(0, comma + 1) + '\u2026';
+}
+export function escapeRegExp(s) {
+    // From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+}
+const escaped = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', '\'': '&#39;' };
+export function escapeHTMLAttribute(s) {
+    return s.replace(/[&<>"']/ug, char => escaped[char]);
+}
+export function escapeHTML(s) {
+    return s.replace(/[&<]/ug, char => escaped[char]);
+}
+export function longestCommonSubstring(s1, s2) {
+    const n = s1.length;
+    const m = s2.length;
+    let maxLen = 0;
+    let endingIndex = 0;
+    // Initialize a 2D array with zeros
+    const dp = Array(n + 1)
+        .fill(null)
+        .map(() => Array(m + 1).fill(0));
+    // Build the dp table
+    for (let i = 1; i <= n; i++) {
+        for (let j = 1; j <= m; j++) {
+            if (s1[i - 1] === s2[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+                if (dp[i][j] > maxLen) {
+                    maxLen = dp[i][j];
+                    endingIndex = i;
+                }
+            }
+        }
+    }
+    // Extract the longest common substring
+    return s1.slice(endingIndex - maxLen, endingIndex);
+}
+export function parseRegex(regex) {
+    if (regex[0] !== '/')
+        throw new Error(`Invalid regex, must start with '/': ${regex}`);
+    const lastSlash = regex.lastIndexOf('/');
+    if (lastSlash <= 0)
+        throw new Error(`Invalid regex, must end with '/' followed by optional flags: ${regex}`);
+    const source = regex.slice(1, lastSlash);
+    const flags = regex.slice(lastSlash + 1);
+    return new RegExp(source, flags);
+}
+export function tomlBasicString(value) {
+    // JSON.stringify produces a valid TOML basic string: escapes \", \\, \n, \r, \t and uses \uXXXX for control chars.
+    return JSON.stringify(value);
+}
+export function tomlArray(values) {
+    return `[${values.map(value => tomlBasicString(value)).join(', ')}]`;
+}
+export function tomlMultilineBasicString(value) {
+    // Triple-quoted basic string: escape backslashes first, then any literal """ sequences.
+    const escaped = value.replace(/\\/g, '\\\\').replace(/"""/g, '\\"\\"\\"');
+    return `"""\n${escaped}\n"""`;
+}
+// Semicolons removed from [[\]()#;?] to avoid polynomial backtracking
+// when both that group and (?:;...)* can match runs of semicolons.
+// \d{1,4} relaxed to \d{0,4} so empty params (e.g. ESC[;H) still match.
+export const ansiRegex = new RegExp('([\\u001B\\u009B][[\\]()#?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{0,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~])))', 'g');
+export function stripAnsiEscapes(str) {
+    return str.replace(ansiRegex, '');
+}
+//# sourceMappingURL=stringUtils.js.map

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "@xylentis/testgen",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Record a UI test once with the Playwright recorder, then generate it for Playwright (TypeScript, Go) and Selenium (Java, JavaScript).",
+  "keywords": [
+    "playwright",
+    "selenium",
+    "codegen",
+    "recorder",
+    "test-generator",
+    "e2e",
+    "playwright-go",
+    "junit",
+    "mocha"
+  ],
+  "author": "Xylentis (https://portal.xylentis.com)",
+  "license": "AGPL-3.0-only",
+  "type": "module",
+  "bin": {
+    "testgen": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "runtime",
+    "ui",
+    "docs/testgen-ui.png",
+    "NOTICE"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node -e \"require('node:fs').copyFileSync('src/vendor/playwright/LICENSE', 'dist/vendor/playwright/LICENSE')\"",
+    "prepare": "npm run build",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "e2e": "bash e2e/run.sh"
+  },
+  "dependencies": {
+    "playwright-core": "1.63.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.19.1",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.3"
+  }
+}