bestax-migrate 2.25.5 → 2.25.7

package/dist/sources/_shared/html/style.js

@@ -0,0 +1,185 @@
+/**
+ * A `style="…"` attribute as the object literal React takes.
+ *
+ * The declarations are split by hand, since a style attribute is a flat list
+ * and the only syntax that matters is what can hide a `;` or a `:`: quoted
+ * strings, parentheses (`url(a;b)`), and comments. Property names are camel
+ * cased the way React hyphenates them back: `-ms-` becomes `ms`, any other
+ * vendor prefix a capital (`WebkitTransition`), and a custom property keeps
+ * its name, quoted. Which declaration of a property applies is CSS's choice:
+ * an `!important` one over the rest, else the last.
+ *
+ * As in CSS, a declaration that can't be read (an IE hack like `*zoom: 1`,
+ * an empty value, a string or parenthesis left open) is skipped and the rest
+ * apply; it is handed back for the caller to report. So is an `!important`
+ * one, which is written without its priority, since React sets every value
+ * without one.
+ */
+import { jsString } from './text.js';
+/** A property name CSS accepts: an identifier, or a custom property. */
+const PROPERTY = /^(?:--[\w-]+|-?[a-z_][\w-]*)$/i;
+/** Runs of whitespace as one space, except inside a quoted string. */
+function collapse(value) {
+    let out = '';
+    let quote = null;
+    for (let i = 0; i < value.length; i++) {
+        const char = value[i];
+        if (quote) {
+            out += char;
+            if (char === '\\' && i + 1 < value.length)
+                out += value[++i];
+            else if (char === quote)
+                quote = null;
+        }
+        else if (/\s/.test(char)) {
+            if (!out.endsWith(' '))
+                out += ' ';
+        }
+        else {
+            if (char === '"' || char === "'")
+                quote = char;
+            out += char;
+        }
+    }
+    return out;
+}
+/**
+ * Split on `;` outside strings, parentheses and comments. A comment
+ * separates tokens and is otherwise nothing, so it becomes a space, and one
+ * left open runs to the end. A string or parenthesis left open does too,
+ * taking every later declaration into the one it is in, as it does in CSS.
+ */
+function declarations(text) {
+    const out = [];
+    let current = '';
+    let balanced = true;
+    let quote = null;
+    let depth = 0;
+    const end = () => {
+        const trimmed = current.trim();
+        if (trimmed)
+            out.push({ text: trimmed, balanced });
+        current = '';
+        balanced = true;
+    };
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (quote) {
+            current += char;
+            if (char === '\\' && i + 1 < text.length) {
+                current += text[++i];
+            }
+            else if (char === quote) {
+                quote = null;
+            }
+            continue;
+        }
+        if (char === '/' && text[i + 1] === '*') {
+            const close = text.indexOf('*/', i + 2);
+            if (close === -1)
+                break;
+            i = close + 1;
+            current += ' ';
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+        }
+        else if (char === '(') {
+            depth++;
+        }
+        else if (char === ')') {
+            if (depth === 0)
+                balanced = false;
+            else
+                depth--;
+        }
+        else if (char === ';' && depth === 0) {
+            end();
+            continue;
+        }
+        current += char;
+    }
+    if (quote || depth > 0)
+        balanced = false;
+    end();
+    return out;
+}
+/** The key React reads for a CSS property name. */
+export function styleKey(property) {
+    if (property.startsWith('--'))
+        return property;
+    const name = property.toLowerCase();
+    const camel = (rest) => rest.replace(/-([a-z\d])/g, (_match, char) => char.toUpperCase());
+    if (name.startsWith('-ms-'))
+        return camel(`ms-${name.slice(4)}`);
+    if (name.startsWith('-')) {
+        const rest = camel(name.slice(1));
+        return rest.charAt(0).toUpperCase() + rest.slice(1);
+    }
+    return camel(name);
+}
+function keySource(key) {
+    return /^[A-Za-z_$][\w$]*$/.test(key) ? key : jsString(key);
+}
+/** A style attribute's declarations, read one at a time. */
+export function readStyle(text) {
+    const style = { declarations: [], skipped: [] };
+    for (const part of declarations(text)) {
+        const colon = part.text.indexOf(':');
+        const written = colon === -1 ? '' : part.text.slice(0, colon).trim();
+        let value = collapse(part.text.slice(colon + 1).trim());
+        const important = /\s*!\s*important$/i.exec(value);
+        if (important)
+            value = value.slice(0, important.index);
+        if (!part.balanced || !PROPERTY.test(written) || value === '') {
+            style.skipped.push(part.text);
+            continue;
+        }
+        style.declarations.push({
+            property: written.startsWith('--') ? written : written.toLowerCase(),
+            value,
+            important: Boolean(important),
+            text: part.text,
+        });
+    }
+    return style;
+}
+/**
+ * The declaration that applies for each property, as the cascade picks it
+ * inside one attribute: an `!important` one over any other, else the last.
+ * In the order of the declarations that apply.
+ */
+export function applied(declarations) {
+    const out = new Map();
+    for (const declaration of declarations) {
+        const before = out.get(declaration.property);
+        if (before?.important && !declaration.important)
+            continue;
+        out.delete(declaration.property);
+        out.set(declaration.property, declaration);
+    }
+    return out;
+}
+/** A style attribute's text as a React style object. */
+export function styleObject(text) {
+    const { declarations: read, skipped } = readStyle(text);
+    const issues = skipped.map(detail => ({
+        kind: 'style',
+        detail,
+    }));
+    for (const { property, important, text: written } of read) {
+        if (important) {
+            issues.push({
+                kind: 'style-important',
+                token: property,
+                detail: written,
+            });
+        }
+    }
+    const entries = [...applied(read).values()].map(({ property, value }) => `${keySource(styleKey(property))}: ${jsString(value)}`);
+    return {
+        code: entries.length === 0 ? null : `{ ${entries.join(', ')} }`,
+        issues,
+    };
+}

package/dist/sources/_shared/html/text.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Text, strings and comments, written so JSX reads them back as the HTML had
+ * them.
+ *
+ * JSX text is not HTML text: `{` and `}` open and close an expression, `<`
+ * and `>` are tags (TypeScript and Babel both refuse a bare `>`), and an
+ * `&name;` is decoded as an entity. Everything else is literal. Whitespace is
+ * not handled here: `whitespace.ts` decides which of it renders, and the
+ * emitter writes what is left.
+ */
+/**
+ * Text as a JSX child. The caller passes text with no whitespace at either
+ * edge that matters, since JSX trims whitespace next to a line break.
+ */
+export declare function jsxText(text: string): string;
+/** A double-quoted JavaScript string, with invisible characters escaped. */
+export declare function jsString(value: string): string;
+/**
+ * A template literal holding `value` exactly: what preformatted text with a
+ * line break in it is written as, so its lines stay lines.
+ */
+export declare function templateLiteral(value: string): string;
+/**
+ * A string attribute value: quoted as written when JSX reads it back the
+ * same way, and as an expression otherwise. A JSX attribute string has no
+ * escapes, so a `"` would end it, and it decodes entities, as text does.
+ * A backslash and a line break are literal there, but a reprint can change
+ * them, so they go in an expression too.
+ */
+export declare function attributeValue(value: string): string;
+/**
+ * An Internet Explorer conditional comment, either half of the revealed form
+ * (`<!--[if !IE]><!-->` … `<!--<![endif]-->`) included. No browser React
+ * supports reads them.
+ */
+export declare function isConditionalComment(data: string): boolean;
+/**
+ * An HTML comment as JSX comment lines, without indentation. One line stays
+ * one line; more are dedented and set between the comment's own delimiters.
+ * A `*\/` inside would end the comment, so it is escaped.
+ */
+export declare function jsxComment(data: string): string[];
+//# sourceMappingURL=text.d.ts.map

package/dist/sources/_shared/html/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../../src/sources/_shared/html/text.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AA2CH;;;GAGG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO5C;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQrD;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMpD;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAiBjD"}

package/dist/sources/_shared/html/text.js

@@ -0,0 +1,120 @@
+/**
+ * Text, strings and comments, written so JSX reads them back as the HTML had
+ * them.
+ *
+ * JSX text is not HTML text: `{` and `}` open and close an expression, `<`
+ * and `>` are tags (TypeScript and Babel both refuse a bare `>`), and an
+ * `&name;` is decoded as an entity. Everything else is literal. Whitespace is
+ * not handled here: `whitespace.ts` decides which of it renders, and the
+ * emitter writes what is left.
+ */
+/** An `&` that JSX would read as the start of an entity. */
+const ENTITY_LIKE = /&(?=#\d+;|#x[\da-f]+;|[a-z][a-z\d]*;)/i;
+/**
+ * Characters that render as nothing, or as a space a reader can't tell from
+ * an ordinary one: no-break and typographic spaces, joiners, direction
+ * marks, fillers, the soft hyphen and the byte-order mark. They are written
+ * as an entity or an escape, so the code shows them.
+ */
+const INVISIBLE_RANGES = [
+    [0xa0, 0xa0],
+    [0xad, 0xad],
+    [0x34f, 0x34f],
+    [0x61c, 0x61c],
+    [0x115f, 0x1160],
+    [0x17b4, 0x17b5],
+    [0x180e, 0x180e],
+    [0x2000, 0x200f],
+    [0x2028, 0x202f],
+    [0x205f, 0x2064],
+    [0x2066, 0x206f],
+    [0x3000, 0x3000],
+    [0x3164, 0x3164],
+    [0xfeff, 0xfeff],
+    [0xffa0, 0xffa0],
+];
+const INVISIBLE_CLASS = `[${INVISIBLE_RANGES.map(([from, to]) => `\\u{${from.toString(16)}}-\\u{${to.toString(16)}}`).join('')}]`;
+const INVISIBLE = new RegExp(INVISIBLE_CLASS, 'gu');
+/** The two of those with a name every reader knows. */
+const NAMED = {
+    [String.fromCodePoint(0xa0)]: '&nbsp;',
+    [String.fromCodePoint(0xad)]: '&shy;',
+};
+function hex(char) {
+    return char.codePointAt(0).toString(16).toUpperCase().padStart(4, '0');
+}
+/**
+ * Text as a JSX child. The caller passes text with no whitespace at either
+ * edge that matters, since JSX trims whitespace next to a line break.
+ */
+export function jsxText(text) {
+    return text
+        .replace(new RegExp(ENTITY_LIKE, 'gi'), '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(INVISIBLE, char => NAMED[char] ?? `&#x${hex(char)};`)
+        .replace(/[{}]/g, brace => `{"${brace}"}`);
+}
+/** A double-quoted JavaScript string, with invisible characters escaped. */
+export function jsString(value) {
+    return JSON.stringify(value).replace(INVISIBLE, char => `\\u${hex(char)}`);
+}
+/**
+ * A template literal holding `value` exactly: what preformatted text with a
+ * line break in it is written as, so its lines stay lines.
+ */
+export function templateLiteral(value) {
+    const body = value
+        .replace(/\\/g, '\\\\')
+        .replace(/`/g, '\\`')
+        .replace(/\$\{/g, '\\${')
+        .replace(/\r/g, '\\r')
+        .replace(INVISIBLE, char => `\\u${hex(char)}`);
+    return `\`${body}\``;
+}
+/**
+ * A string attribute value: quoted as written when JSX reads it back the
+ * same way, and as an expression otherwise. A JSX attribute string has no
+ * escapes, so a `"` would end it, and it decodes entities, as text does.
+ * A backslash and a line break are literal there, but a reprint can change
+ * them, so they go in an expression too.
+ */
+export function attributeValue(value) {
+    const plain = !/["\\\r\n]/.test(value) &&
+        !ENTITY_LIKE.test(value) &&
+        value.replace(INVISIBLE, '') === value;
+    return plain ? `"${value}"` : `{${jsString(value)}}`;
+}
+/**
+ * An Internet Explorer conditional comment, either half of the revealed form
+ * (`<!--[if !IE]><!-->` … `<!--<![endif]-->`) included. No browser React
+ * supports reads them.
+ */
+export function isConditionalComment(data) {
+    return /^\s*\[if\s[^\]]*\]>/i.test(data) || /^\s*<!\[endif\]\s*$/i.test(data);
+}
+/**
+ * An HTML comment as JSX comment lines, without indentation. One line stays
+ * one line; more are dedented and set between the comment's own delimiters.
+ * A `*\/` inside would end the comment, so it is escaped.
+ */
+export function jsxComment(data) {
+    const text = data.replace(/\*\//g, '*\\/');
+    const lines = text.split(/\r\n|\r|\n/).map(line => line.trimEnd());
+    while (lines.length > 0 && lines[0].trim() === '')
+        lines.shift();
+    while (lines.length > 0 && lines[lines.length - 1].trim() === '')
+        lines.pop();
+    if (lines.length === 0)
+        return ['{/* */}'];
+    if (lines.length === 1)
+        return [`{/* ${lines[0].trim()} */}`];
+    const margin = Math.min(...lines
+        .filter(line => line.trim() !== '')
+        .map(line => line.match(/^[ \t]*/)[0].length));
+    return [
+        '{/*',
+        ...lines.map(line => (line.trim() === '' ? '' : `  ${line.slice(margin)}`)),
+        '*/}',
+    ];
+}

package/dist/sources/_shared/html/whitespace.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Which whitespace in an HTML tree renders, decided the way CSS lays it out.
+ *
+ * JSX has whitespace rules of its own, and they are not CSS's: it keeps a
+ * space between two tags on one line and drops every run with a line break
+ * in it. So the emitter needs to know, for each run of whitespace in the
+ * HTML, whether it renders at all. Inside `<pre>`, `<textarea>` and
+ * `<listing>`, under an inline `white-space` that preserves it, and in a
+ * script or a stylesheet, every character is kept exactly. Elsewhere a run
+ * is one space, and it renders nothing:
+ *
+ *   - at the start or end of a line: the start or end of a block container,
+ *     or beside a block-level box or a `<br>`, seen through inline elements;
+ *   - right after another space, which it collapses into;
+ *   - inside a flex or grid container, a `<select>`, `<head>` or `<html>`,
+ *     where every child is a box of its own, so a text's edges are line
+ *     edges too;
+ *   - between the shapes of an SVG or MathML drawing, outside its text.
+ *
+ * A table, its rows, groups, cells and captions are block-level boxes and
+ * block containers, so a run between two of them renders nothing (the first
+ * rule). Inline content in a table, which only CSS can put there, sits in an
+ * anonymous cell, and a run inside it renders as it does in any block.
+ *
+ * Comments and `display: none` boxes render nothing, so a run is judged by
+ * what is beside them. An element's display comes from `displayOf`; the
+ * default reads an inline `style` and then the HTML UA stylesheet, which is
+ * where it stops: a page's own CSS can change any display, and the honest
+ * limit is that this reads no CSS file.
+ */
+import { type CommentNode, type Element, type ParentNode } from './parse.js';
+/** An element's CSS `display`, or undefined when the hook can't tell. */
+export type DisplayOf = (element: Element) => string | undefined;
+export type Piece = 
+/** An element or a comment, in its place. */
+{
+    kind: 'node';
+    node: Element | CommentNode;
+}
+/** A run of text with no whitespace in it. */
+ | {
+    kind: 'word';
+    text: string;
+    line: number | null;
+}
+/**
+ * A run of whitespace: one space when `kept`, nothing otherwise.
+ * `newlines` counts the line breaks it had, for the emitter's layout.
+ */
+ | {
+    kind: 'space';
+    kept: boolean;
+    newlines: number;
+    line: number | null;
+}
+/** Preformatted text, every character of which renders. */
+ | {
+    kind: 'exact';
+    text: string;
+    line: number | null;
+};
+/** The display an element's own `style` attribute gives it. */
+export declare function inlineStyleDisplay(element: Element): string | undefined;
+/**
+ * The display the HTML spec's UA stylesheet gives an element: by its tag,
+ * and `none` for what it hides by attribute (`[hidden]`, a hidden input, a
+ * closed dialog). Undefined for an element in another namespace.
+ */
+export declare function uaDisplay(element: Element): string | undefined;
+/**
+ * An inline `display`, when it is one CSS reads (otherwise the declaration
+ * is ignored), else the UA stylesheet's.
+ */
+export declare const defaultDisplayOf: DisplayOf;
+/**
+ * Every element's and fragment's children as pieces, from `root` down.
+ * `root` is laid out as a block container, as a page's body is.
+ */
+export declare function layoutWhitespace(root: ParentNode, displayOf?: DisplayOf): Map<ParentNode, Piece[]>;
+//# sourceMappingURL=whitespace.d.ts.map

package/dist/sources/_shared/html/whitespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whitespace.d.ts","sourceRoot":"","sources":["../../../../src/sources/_shared/html/whitespace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAKL,KAAK,WAAW,EAChB,KAAK,OAAO,EACZ,KAAK,UAAU,EAEhB,MAAM,YAAY,CAAC;AAGpB,yEAAyE;AACzE,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,GAAG,SAAS,CAAC;AAEjE,MAAM,MAAM,KAAK;AACf,6CAA6C;AAC3C;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,GAAG,WAAW,CAAA;CAAE;AAC/C,8CAA8C;GAC5C;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE;AACrD;;;GAGG;GACD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE;AACzE,2DAA2D;GACzD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAyJzD,+DAA+D;AAC/D,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAEvE;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAkB9D;AAMD;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAM9B,CAAC;AAsIF;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,UAAU,EAChB,SAAS,GAAE,SAA4B,GACtC,GAAG,CAAC,UAAU,EAAE,KAAK,EAAE,CAAC,CA0G1B"}