jamdesk 1.1.196 → 1.1.197

package/vendored/lib/remark-style-string-to-object.ts

@@ -0,0 +1,482 @@
+/**
+ * remark-style-string-to-object
+ *
+ * MDX AST plugin that rewrites a string `style="…"` attribute on intrinsic JSX
+ * elements into a React style OBJECT.
+ *
+ * WHY: MDX has no raw HTML — everything angle-bracketed is parsed as JSX. So an
+ * embed pasted from a third-party site keeps its HTML `style` attribute and MDX
+ * hands React a plain string, which React refuses:
+ *
+ *   The `style` prop expects a mapping from style properties to values, not a
+ *   string.  (minified: React error #62)
+ *
+ * That throw happens at RENDER, not at compile, so nothing that guards the
+ * compile step sees it: `render-doc-page.tsx` catches compile failures only,
+ * and the editor's `compileMdx` try/catch likewise. In the editor the throw
+ * escaped all the way to the dashboard's root error boundary and unmounted the
+ * whole app ("Something went wrong"); in production it breaks the page render.
+ * Reported by a customer whose iframe carried a scribehow.com embed's
+ * `style="aspect-ratio: 1 / 1; border: 0; min-height: 480px"`.
+ *
+ * Markdown-generated HTML does NOT have this problem — hast elements go through
+ * `hast-util-to-jsx-runtime`, which already converts `style` via `style-to-js`.
+ * The gap is specific to MDX JSX nodes, which bypass hast entirely, so the fix
+ * belongs at the mdast/JSX layer — here.
+ *
+ * Two AST shapes carry a `style` attribute, mirroring remark-svg-namespace-attrs
+ * (the same problem class: HTML-shaped attributes pasted into MDX):
+ *  1. mdast JSX nodes (`mdxJsxFlowElement`, `mdxJsxTextElement`) — the pasted
+ *     `<iframe style="…">` in the doc body. The attribute value is a string.
+ *  2. estree JSX nodes inside expression containers
+ *     (`mdxJsxAttributeValueExpression` for `<Card icon={<svg style="…"/>}>`,
+ *     `mdxFlowExpression` / `mdxTextExpression` for `{<svg …/>}` blocks,
+ *     `mdxjsEsm` for `export const Icon = () => <svg style="…"/>`). There the
+ *     value is a `JSXAttribute` with a string `Literal`.
+ *
+ * SCOPE — intrinsic elements only. React throws for DOM elements; a custom
+ * component may legitimately declare `style?: string`, and rewriting its prop
+ * would break it. Element names are therefore converted only when they look
+ * intrinsic (lowercase first letter, no dot). Same rule React itself uses to
+ * decide between a DOM tag and a component.
+ *
+ * VALUES stay verbatim strings. React appends `px` to a bare NUMBER on most
+ * properties, so coercing `line-height: 2` to the number 2 would silently
+ * produce `line-height: 2px`. Keeping the source string also preserves
+ * `!important` (which React's SSR serializer emits as written).
+ */
+
+import type { Root } from 'mdast';
+import type { MdxJsxFlowElement, MdxJsxTextElement } from 'mdast-util-mdx-jsx';
+import type { MdxFlowExpression, MdxTextExpression } from 'mdast-util-mdx-expression';
+import type { MdxjsEsm } from 'mdast-util-mdxjs-esm';
+import { visit } from 'unist-util-visit';
+import { visit as visitEstree } from 'estree-util-visit';
+import type {
+  Program,
+  JSXOpeningElement,
+  JSXIdentifier,
+  JSXMemberExpression,
+  JSXNamespacedName,
+  ObjectExpression,
+  Property,
+} from 'estree-jsx';
+
+/** One parsed CSS declaration: the React property key and its verbatim value. */
+interface Declaration {
+  key: string;
+  value: string;
+}
+
+/**
+ * Does the quote opened at `open` ever close?
+ *
+ * An UNMATCHED quote must not put a scanner into string mode. If it does, every
+ * later `;` and `:` looks quoted, so the rest of the attribute folds into the
+ * current value and those declarations vanish with no error:
+ *
+ *   font-family: Kim's Handwriting; color: red; border: 0
+ *
+ * — one apostrophe in a font name and the author silently loses `color` and
+ * `border`. A stray quote is far likelier than a deliberate unterminated string,
+ * so it is treated as an ordinary character and the remaining declarations
+ * survive.
+ */
+function quoteCloses(s: string, open: number, quote: string): boolean {
+  for (let i = open + 1; i < s.length; i += 1) {
+    if (s[i] === '\\') {
+      i += 1;
+      continue;
+    }
+    if (s[i] === quote) return true;
+  }
+  return false;
+}
+
+/** True when a quote at `i` should open a string rather than be literal text. */
+function opensString(s: string, i: number): boolean {
+  const ch = s[i];
+  return (ch === '"' || ch === "'") && quoteCloses(s, i, ch);
+}
+
+/**
+ * Index just past the `)` closing a `url(` whose body starts at `from`.
+ * Quotes are honoured so `url("a)b.png")` is not cut at the inner paren.
+ * An unclosed `url(` runs to the end of the value.
+ */
+function endOfUrlToken(s: string, from: number): number {
+  let quote: string | null = null;
+  for (let i = from; i < s.length; i += 1) {
+    const ch = s[i];
+    if (quote) {
+      if (ch === '\\') i += 1;
+      else if (ch === quote) quote = null;
+      continue;
+    }
+    if (opensString(s, i)) quote = ch;
+    else if (ch === ')') return i + 1;
+  }
+  return s.length;
+}
+
+/**
+ * Split a `style` attribute into declarations.
+ *
+ * Hand-rolled rather than pulling in `style-to-object`: that package is present
+ * only TRANSITIVELY (via @mdx-js/mdx → hast-util-to-jsx-runtime → style-to-js),
+ * and this file is vendored verbatim into both `builder/cli/vendored/` and
+ * `dashboard/hosting/vendored/builder/`, where a direct dependency would have to
+ * be added to three package trees and the CLI's generated workspace lockfile.
+ *
+ * The grammar that actually matters here is small, but the two structures below
+ * are NOT optional — both appear in real pasted embeds:
+ *   - parentheses: `url(data:image/png;base64,…)` contains BOTH `;` and `:`
+ *   - quotes: `content: "a;b"`, `font-family: 'A;B'`
+ * so the scanner tracks quote state and paren depth and only breaks on a
+ * top-level, unquoted delimiter. Escapes inside quotes (`"\""`) are honoured so
+ * a backslash-escaped quote does not end the string early.
+ */
+function splitDeclarations(style: string): Declaration[] {
+  const out: Declaration[] = [];
+  style = stripCssComments(style);
+  let depth = 0;
+  let quote: string | null = null;
+  let start = 0;
+
+  const flush = (end: number): void => {
+    const decl = style.slice(start, end);
+    start = end + 1;
+    const parsed = parseDeclaration(decl);
+    if (parsed) out.push(parsed);
+  };
+
+  for (let i = 0; i < style.length; i += 1) {
+    const ch = style[i];
+    if (quote) {
+      // A backslash escapes the next character inside a quoted string, so `\"`
+      // does not terminate it. Skip the escaped character outright.
+      if (ch === '\\') i += 1;
+      else if (ch === quote) quote = null;
+      continue;
+    }
+    if (opensString(style, i)) quote = ch;
+    else if (ch === '(') depth += 1;
+    else if (ch === ')') depth = Math.max(0, depth - 1);
+    else if (ch === ';' && depth === 0) flush(i);
+  }
+  flush(style.length);
+  return out;
+}
+
+/**
+ * Remove `/* … *\/` comments, which are legal anywhere in a style attribute and
+ * are NOT legal in a React style value.
+ *
+ * This is a silent-corruption guard, not tidiness. `color: red /* note *\/`
+ * would otherwise become the value `"red /* note *\/"`, and React assigns that
+ * straight to `style.color`, where it is invalid and the browser DROPS the whole
+ * declaration — the author's colour vanishes with no error anywhere. A leading
+ * comment is worse: `/* note *\/ color: red` parses the comment into the
+ * PROPERTY NAME and emits a garbage key.
+ *
+ * Quote-aware, because `content: "/*"` is a string, not a comment. An
+ * unterminated `/*` runs to the end of the value, matching the CSS spec.
+ *
+ * Also url-aware. An UNQUOTED `url(…)` is a single URL token and CSS does not
+ * recognise comments inside it, so a `/*` in a path — `url(https://cdn/a/*b.png)`
+ * — would otherwise open a comment that never closes and take the rest of the
+ * style with it, truncating the URL mid-string and deleting every later
+ * declaration. The token is copied through verbatim instead.
+ */
+function stripCssComments(style: string): string {
+  if (!style.includes('/*')) return style;
+  let out = '';
+  let quote: string | null = null;
+  for (let i = 0; i < style.length; i += 1) {
+    const ch = style[i];
+    if (quote) {
+      if (ch === '\\') {
+        out += ch + (style[i + 1] ?? '');
+        i += 1;
+        continue;
+      }
+      if (ch === quote) quote = null;
+      out += ch;
+      continue;
+    }
+    if (opensString(style, i)) {
+      quote = ch;
+      out += ch;
+      continue;
+    }
+    if ((ch === 'u' || ch === 'U') && /^url\(/i.test(style.slice(i, i + 4))) {
+      const end = endOfUrlToken(style, i + 4);
+      out += style.slice(i, end);
+      i = end - 1;
+      continue;
+    }
+    if (ch === '/' && style[i + 1] === '*') {
+      const end = style.indexOf('*/', i + 2);
+      // Unterminated comment consumes the rest, per CSS.
+      if (end === -1) return out;
+      i = end + 1;
+      // A comment is a token separator, so leave whitespace behind rather than
+      // gluing `border/*x*\/0` into `border0`.
+      out += ' ';
+      continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+
+/**
+ * Split one declaration on its FIRST top-level colon. `background: url(a:b)`
+ * and `content: "a:b"` both carry later colons that are part of the value.
+ */
+function parseDeclaration(decl: string): Declaration | null {
+  let depth = 0;
+  let quote: string | null = null;
+  for (let i = 0; i < decl.length; i += 1) {
+    const ch = decl[i];
+    if (quote) {
+      if (ch === '\\') i += 1;
+      else if (ch === quote) quote = null;
+      continue;
+    }
+    if (opensString(decl, i)) quote = ch;
+    else if (ch === '(') depth += 1;
+    else if (ch === ')') depth = Math.max(0, depth - 1);
+    else if (ch === ':' && depth === 0) {
+      const name = decl.slice(0, i).trim();
+      const value = decl.slice(i + 1).trim();
+      // A declaration needs both halves. `color:` (no value) and `: red` (no
+      // property) are dropped rather than emitted as an empty-keyed property,
+      // which would render as a stray `:value` in the style attribute.
+      if (!name || !value) return null;
+      return { key: toReactProperty(name), value };
+    }
+  }
+  // No colon at all — `novalue`. Not a declaration.
+  return null;
+}
+
+/**
+ * Convert a CSS property name to the key React expects.
+ *
+ *   aspect-ratio      → aspectRatio
+ *   -webkit-line-clamp → WebkitLineClamp   (React capitalises the vendor prefix)
+ *   -moz-appearance    → MozAppearance
+ *   -ms-flex           → msFlex            (the documented -ms- exception:
+ *                                           lowercase `ms`, unlike every other
+ *                                           vendor prefix — matches React's own
+ *                                           hyphenation table)
+ *   --brand-color      → --brand-color     (custom property, passed through:
+ *                                           React sets these with
+ *                                           style.setProperty and camelCasing
+ *                                           would break the lookup)
+ *
+ * A kebab key is not merely untidy — React renders it but logs "Unsupported
+ * style property aspect-ratio. Did you mean aspectRatio?" on every render, which
+ * is the exact noise remark-svg-namespace-attrs was written to eliminate.
+ */
+function toReactProperty(name: string): string {
+  // CSS custom property. Two leading dashes, case-sensitive, never camelCased.
+  if (name.startsWith('--')) return name;
+
+  const lower = name.toLowerCase();
+  // `-ms-` is the one prefix React lowercases; every other `-x-` prefix gets an
+  // upper-cased first letter. Strip the leading dash first so the generic
+  // kebab→camel pass below sees a normal name.
+  if (lower.startsWith('-ms-')) return camelCase(lower.slice(1));
+  if (lower.startsWith('-')) {
+    const camel = camelCase(lower.slice(1));
+    return camel.charAt(0).toUpperCase() + camel.slice(1);
+  }
+  return camelCase(lower);
+}
+
+function camelCase(name: string): string {
+  return name.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase());
+}
+
+/** Build the estree ObjectExpression React will receive as the `style` prop. */
+function buildObjectExpression(declarations: Declaration[]): ObjectExpression {
+  const properties: Property[] = declarations.map((d) => ({
+    type: 'Property',
+    method: false,
+    shorthand: false,
+    computed: false,
+    // Always a string-literal key: custom properties (`--brand`) and vendor
+    // forms are not valid bare identifiers, and a quoted key is valid for the
+    // camelCase ones too, so one shape covers every case.
+    key: { type: 'Literal', value: d.key },
+    value: { type: 'Literal', value: d.value },
+    kind: 'init',
+  }));
+  return { type: 'ObjectExpression', properties };
+}
+
+/**
+ * Serialize declarations back to a JS object literal source string.
+ *
+ * MDX carries both an estree (`data.estree`) and the raw `value` source for an
+ * attribute expression, and downstream tooling reads either one, so both are
+ * emitted and must agree. JSON.stringify gives correctly escaped keys and
+ * values for the Literal nodes above.
+ */
+function toSource(declarations: Declaration[]): string {
+  const body = declarations
+    .map((d) => `${JSON.stringify(d.key)}: ${JSON.stringify(d.value)}`)
+    .join(', ');
+  return `{${body}}`;
+}
+
+/**
+ * React treats a lowercase-initial, dot-free tag as a DOM element and anything
+ * else as a component. Only DOM elements throw on a string `style`, and only
+ * they are safe to rewrite.
+ */
+function isIntrinsic(name: string | null | undefined): boolean {
+  if (!name) return false;
+  if (name.includes('.')) return false;
+  const first = name.charAt(0);
+  return first === first.toLowerCase() && first !== first.toUpperCase();
+}
+
+/**
+ * Rewrite `style="…"` on an mdast JSX element.
+ *
+ * An unparseable style (`style=""`, `style=";;"`, `style="novalue"`) has its
+ * attribute REMOVED, not blanked. A JSX attribute carrying no value is
+ * `style={true}`, and React's guard is `styles != null && typeof styles !==
+ * 'object'` — `true` fails it and throws error #62 exactly like the string did.
+ * `rewriteJsxOpening` drops it for the same reason.
+ */
+function rewriteMdastAttrs(node: MdxJsxFlowElement | MdxJsxTextElement): void {
+  if (!isIntrinsic(node.name)) return;
+  const kept: typeof node.attributes = [];
+  for (const attr of node.attributes) {
+    // Only a literal string `style`. An existing `style={{…}}` arrives as an
+    // mdxJsxAttributeValueExpression and is already correct.
+    if (
+      attr.type !== 'mdxJsxAttribute' ||
+      attr.name !== 'style' ||
+      typeof attr.value !== 'string'
+    ) {
+      kept.push(attr);
+      continue;
+    }
+    const declarations = splitDeclarations(attr.value);
+    if (!declarations.length) continue; // drop, per the note above
+    attr.value = {
+      type: 'mdxJsxAttributeValueExpression',
+      value: toSource(declarations),
+      data: {
+        estree: {
+          type: 'Program',
+          sourceType: 'module',
+          comments: [],
+          body: [
+            {
+              type: 'ExpressionStatement',
+              expression: buildObjectExpression(declarations),
+            },
+          ],
+        },
+      },
+    };
+    kept.push(attr);
+  }
+  node.attributes = kept;
+}
+
+function jsxName(
+  nameNode: JSXIdentifier | JSXMemberExpression | JSXNamespacedName,
+): string {
+  if (nameNode.type === 'JSXIdentifier') return nameNode.name;
+  if (nameNode.type === 'JSXNamespacedName') {
+    return `${nameNode.namespace.name}:${nameNode.name.name}`;
+  }
+  return jsxName(nameNode.object) + '.' + jsxName(nameNode.property);
+}
+
+/** Rewrite `style="…"` on a single estree JSX opening element. */
+function rewriteJsxOpening(opening: JSXOpeningElement): void {
+  if (!isIntrinsic(jsxName(opening.name))) return;
+  const kept: typeof opening.attributes = [];
+  for (const attr of opening.attributes) {
+    // Only a bare string literal on a `style` attribute — `style={{…}}` is a
+    // JSXExpressionContainer and is already correct.
+    if (
+      attr.type !== 'JSXAttribute' ||
+      attr.name.type !== 'JSXIdentifier' ||
+      attr.name.name !== 'style' ||
+      !attr.value ||
+      attr.value.type !== 'Literal' ||
+      typeof attr.value.value !== 'string'
+    ) {
+      kept.push(attr);
+      continue;
+    }
+    const declarations = splitDeclarations(attr.value.value);
+    if (!declarations.length) continue; // drop, per the note on rewriteMdastAttrs
+    attr.value = {
+      type: 'JSXExpressionContainer',
+      expression: buildObjectExpression(declarations),
+    };
+    kept.push(attr);
+  }
+  opening.attributes = kept;
+}
+
+function rewriteEstreeProgram(estree: Program | null | undefined): void {
+  if (!estree) return;
+  visitEstree(estree, (node) => {
+    if (node.type === 'JSXElement') {
+      rewriteJsxOpening(node.openingElement);
+    }
+  });
+}
+
+export function remarkStyleStringToObject() {
+  return (tree: Root) => {
+    visit(
+      tree,
+      [
+        'mdxJsxFlowElement',
+        'mdxJsxTextElement',
+        'mdxFlowExpression',
+        'mdxTextExpression',
+        'mdxjsEsm',
+      ],
+      (node) => {
+        if (node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') {
+          const jsxNode = node as MdxJsxFlowElement | MdxJsxTextElement;
+          rewriteMdastAttrs(jsxNode);
+          // Also walk estree subtrees inside attribute value expressions —
+          // `<Card icon={<svg style="…"/>}>`. Runs regardless of whether the
+          // OUTER element was intrinsic: the inner element is judged on its own.
+          for (const attr of jsxNode.attributes) {
+            if (attr.type !== 'mdxJsxAttribute') continue;
+            const value = attr.value;
+            if (
+              value &&
+              typeof value === 'object' &&
+              value.type === 'mdxJsxAttributeValueExpression'
+            ) {
+              rewriteEstreeProgram(value.data?.estree);
+            }
+          }
+        } else {
+          // mdxFlowExpression / mdxTextExpression — body-level `{…}` blocks.
+          // mdxjsEsm — `export const Icon = () => <svg style="…"/>`, whose JSX
+          // exists only in estree.
+          rewriteEstreeProgram(
+            (node as MdxFlowExpression | MdxTextExpression | MdxjsEsm).data?.estree,
+          );
+        }
+      },
+    );
+  };
+}

package/vendored/lib/render-doc-page.tsx

@@ -40,6 +40,7 @@ import { MARKDOWN_BLOCK_STRUCTURE } from '@/components/mdx/markdown-classes';
 import { rehypeCodeMeta, rehypeRestoreDataTitle } from '@/lib/rehype-code-meta';
 import { rehypeClassToClassName } from '@/lib/rehype-class-to-classname';
 import { remarkSvgNamespaceAttrs } from '@/lib/remark-svg-namespace-attrs';
+import { remarkStyleStringToObject } from '@/lib/remark-style-string-to-object';
 import { rehypeNoZoomToData } from '@/lib/rehype-nozoom-to-data';
 import { rehypeUnwrapNestedAnchors } from './rehype-unwrap-nested-anchors';
 import { loadSnippetsAndInlineComponents } from './render-doc-page-parallel-helpers';
@@ -139,6 +140,7 @@ function getCommonMdxOptions(
       remarkGfm,
       [remarkVisibility, { audience: 'humans' }],
       remarkSvgNamespaceAttrs,
+      remarkStyleStringToObject,
       ...getTypographyRemarkPlugins(config),
       ...getLatexRemarkPlugins(config),
     ],

package/vendored/lib/snippet-loader-isr.ts

@@ -17,6 +17,8 @@ import { extractSnippetImports, normalizeSnippetPath } from './preprocess-mdx';
 import { filterVisibility } from './visibility-filter';
 import { injectPromptSources } from './inject-prompt-source';
 import { mdxSecurityOptions } from './mdx-security-options';
+import { remarkSvgNamespaceAttrs } from './remark-svg-namespace-attrs';
+import { remarkStyleStringToObject } from './remark-style-string-to-object';
 import {
   mdxEvalGuardPlugin,
   guardPropertyKey,
@@ -271,7 +273,17 @@ async function compilePlainMdxSnippet(
   const { content } = await compileMDX({
     source,
     components: builtInComponents,
-    options: { ...mdxSecurityOptions, parseFrontmatter: true },
+    options: {
+      ...mdxSecurityOptions,
+      parseFrontmatter: true,
+      // Both HTML-shaped-attribute repairs, matching every other compile site
+      // (pinned by remark-svg-namespace-attrs-coverage.test.ts). A pasted
+      // `<iframe style="…">` throws React error #62 at render here just as it
+      // does on a page, and a snippet crash takes down every page that includes
+      // it. The REHYPE pipeline is still deliberately omitted — see the note
+      // above about D2 fences.
+      mdxOptions: { remarkPlugins: [remarkSvgNamespaceAttrs, remarkStyleStringToObject] },
+    },
   });
   const PlainMdxSnippet: AnyComponent = () => content as React.ReactElement;
   PlainMdxSnippet.displayName = 'PlainMdxSnippet';

package/vendored/scripts/build-search-index.cjs

@@ -207,17 +207,21 @@ function preprocessFrontmatter(content) {
   const body = content.slice(frontmatterEnd);
 
   const lines = frontmatter.split('\n');
+  // Lines belonging to a previous key's multi-line value are VALUE TEXT, not
+  // key/value pairs. Mirror of lib/frontmatter-utils.ts.
+  const isContinuation = markContinuationLines(lines);
   const fixedLines = lines.map((line, i) => {
     if (!line.trim() || line.trim().startsWith('#')) return line;
+    if (isContinuation[i]) return line;
 
     // Key may contain colon-segments (og:title, twitter:card) — split on the
     // first colon followed by whitespace/EOL. Mirror of lib/frontmatter-utils.ts.
-    const match = line.match(/^(\s*)([a-zA-Z_][a-zA-Z0-9_.-]*(?::[a-zA-Z0-9_.-]+)*):\s*(.*)$/);
+    const match = line.match(KEY_LINE);
     if (!match) return line;
 
     const [, indent, key, value] = match;
 
-    if (!value || value.startsWith('"') || value.startsWith("'") || /^[|>][-+]?$/.test(value)) {
+    if (!value || value.startsWith('"') || value.startsWith("'") || isBlockScalar(value)) {
       return line;
     }
 
@@ -240,6 +244,38 @@ function preprocessFrontmatter(content) {
   return '---\n' + fixedLines.join('\n') + endMatch[0] + body;
 }
 
+/** Mirror of KEY_LINE in lib/frontmatter-utils.ts. */
+const KEY_LINE =
+  /^(\s*)([a-zA-Z_][a-zA-Z0-9_.-]*(?::[a-zA-Z0-9_.-]+)*):\s*(.*)$/;
+
+/** Mirror of isBlockScalar in lib/frontmatter-utils.ts. */
+function isBlockScalar(value) {
+  return /^[|>][-+]?\d*$/.test(value.trim());
+}
+
+/**
+ * Mirror of markContinuationLines in lib/frontmatter-utils.ts. Without it the
+ * search index rebuilt a wrapped value's continuation as `key: value` — the
+ * added space landed in a customer's indexed description, and where the line
+ * was a plain (non-block) wrap it made js-yaml reject the page outright.
+ */
+function markContinuationLines(lines) {
+  const out = new Array(lines.length).fill(false);
+  for (let i = 0; i < lines.length; i++) {
+    if (out[i]) continue;
+    const match = lines[i].match(KEY_LINE);
+    if (!match) continue;
+    const [, indent, , value] = match;
+    if (!isBlockScalar(value) && !hasFoldedContinuation(lines, i)) continue;
+    for (let j = i + 1; j < lines.length; j++) {
+      if (!lines[j].trim()) { out[j] = true; continue; }
+      if (lines[j].search(/\S/) <= indent.length) break;
+      out[j] = true;
+    }
+  }
+  return out;
+}
+
 /** Mirror of hasFoldedContinuation in lib/frontmatter-utils.ts. */
 function hasFoldedContinuation(lines, i) {
   for (let j = i + 1; j < lines.length; j++) {