@design.estate/dees-catalog 3.90.1 → 3.92.0

package/dist_ts_web/elements/00group-dataview/dees-dataview-codebox/codebox.diff.js

@@ -0,0 +1,342 @@
+/**
+ * Dependency-free line diffing for dees-dataview-codebox: LCS-based
+ * before/after comparison, unified-patch parsing, context folding, split
+ * pairing, and intraline (word-level) change detection. Pure data — no DOM.
+ */
+const splitLines = (text) => {
+    if (!text)
+        return [];
+    const lines = text.split('\n');
+    if (lines.length && lines[lines.length - 1] === '')
+        lines.pop();
+    return lines;
+};
+/** Cells beyond this budget fall back to a trimmed block-replace diff. */
+const maxLcsCells = 4_000_000;
+/**
+ * Line-level diff of two texts. Common prefix/suffix are trimmed first so
+ * the O(n*m) LCS table only covers the changed middle; oversized middles
+ * degrade gracefully to one remove-block + add-block.
+ */
+export const computeLineDiff = (beforeText, afterText) => {
+    const beforeLines = splitLines(beforeText);
+    const afterLines = splitLines(afterText);
+    let prefixLength = 0;
+    while (prefixLength < beforeLines.length
+        && prefixLength < afterLines.length
+        && beforeLines[prefixLength] === afterLines[prefixLength]) {
+        prefixLength++;
+    }
+    let suffixLength = 0;
+    while (suffixLength < beforeLines.length - prefixLength
+        && suffixLength < afterLines.length - prefixLength
+        && beforeLines[beforeLines.length - 1 - suffixLength] === afterLines[afterLines.length - 1 - suffixLength]) {
+        suffixLength++;
+    }
+    const beforeMiddle = beforeLines.slice(prefixLength, beforeLines.length - suffixLength);
+    const afterMiddle = afterLines.slice(prefixLength, afterLines.length - suffixLength);
+    const rows = [];
+    for (let index = 0; index < prefixLength; index++) {
+        rows.push({ kind: 'context', text: beforeLines[index], oldLine: index + 1, newLine: index + 1 });
+    }
+    let oldLine = prefixLength + 1;
+    let newLine = prefixLength + 1;
+    const pushMiddle = (operations) => {
+        for (const operation of operations) {
+            if (operation.kind === 'context') {
+                rows.push({ kind: 'context', text: operation.text, oldLine: oldLine++, newLine: newLine++ });
+            }
+            else if (operation.kind === 'remove') {
+                rows.push({ kind: 'remove', text: operation.text, oldLine: oldLine++ });
+            }
+            else {
+                rows.push({ kind: 'add', text: operation.text, newLine: newLine++ });
+            }
+        }
+    };
+    if (beforeMiddle.length * afterMiddle.length > maxLcsCells) {
+        pushMiddle([
+            ...beforeMiddle.map((text) => ({ kind: 'remove', text })),
+            ...afterMiddle.map((text) => ({ kind: 'add', text })),
+        ]);
+    }
+    else if (beforeMiddle.length || afterMiddle.length) {
+        // classic LCS table over the trimmed middle
+        const rowCount = beforeMiddle.length;
+        const columnCount = afterMiddle.length;
+        const table = new Uint32Array((rowCount + 1) * (columnCount + 1));
+        const cell = (row, column) => table[row * (columnCount + 1) + column];
+        for (let row = rowCount - 1; row >= 0; row--) {
+            for (let column = columnCount - 1; column >= 0; column--) {
+                table[row * (columnCount + 1) + column] = beforeMiddle[row] === afterMiddle[column]
+                    ? cell(row + 1, column + 1) + 1
+                    : Math.max(cell(row + 1, column), cell(row, column + 1));
+            }
+        }
+        const operations = [];
+        let row = 0;
+        let column = 0;
+        while (row < rowCount && column < columnCount) {
+            if (beforeMiddle[row] === afterMiddle[column]) {
+                operations.push({ kind: 'context', text: beforeMiddle[row] });
+                row++;
+                column++;
+            }
+            else if (cell(row + 1, column) >= cell(row, column + 1)) {
+                operations.push({ kind: 'remove', text: beforeMiddle[row] });
+                row++;
+            }
+            else {
+                operations.push({ kind: 'add', text: afterMiddle[column] });
+                column++;
+            }
+        }
+        while (row < rowCount)
+            operations.push({ kind: 'remove', text: beforeMiddle[row++] });
+        while (column < columnCount)
+            operations.push({ kind: 'add', text: afterMiddle[column++] });
+        pushMiddle(operations);
+    }
+    for (let index = 0; index < suffixLength; index++) {
+        rows.push({
+            kind: 'context',
+            text: beforeLines[beforeLines.length - suffixLength + index],
+            oldLine: oldLine++,
+            newLine: newLine++,
+        });
+    }
+    return annotateIntraline(rows);
+};
+/** Parses a unified diff/patch into rows (file headers skipped, hunks kept). */
+export const parseUnifiedDiff = (patchText) => {
+    const rows = [];
+    let oldLine = 0;
+    let newLine = 0;
+    for (const line of patchText.split('\n')) {
+        if (line.startsWith('diff ')
+            || line.startsWith('index ')
+            || line.startsWith('+++')
+            || line.startsWith('---')
+            || line.startsWith('\\ No newline')) {
+            continue;
+        }
+        const hunkMatch = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@(.*)$/.exec(line);
+        if (hunkMatch) {
+            oldLine = Number(hunkMatch[1]);
+            newLine = Number(hunkMatch[2]);
+            rows.push({ kind: 'hunk', text: line });
+            continue;
+        }
+        if (!oldLine && !newLine)
+            continue; // outside any hunk
+        if (line.startsWith('+')) {
+            rows.push({ kind: 'add', text: line.slice(1), newLine: newLine++ });
+        }
+        else if (line.startsWith('-')) {
+            rows.push({ kind: 'remove', text: line.slice(1), oldLine: oldLine++ });
+        }
+        else {
+            rows.push({ kind: 'context', text: line.startsWith(' ') ? line.slice(1) : line, oldLine: oldLine++, newLine: newLine++ });
+        }
+    }
+    return annotateIntraline(rows);
+};
+const maxIntralineChars = 400;
+/**
+ * Word-level segments for balanced remove/add runs (the GitHub-style
+ * intraline tint). Only 1:1 paired lines within a run are annotated.
+ */
+const annotateIntraline = (rows) => {
+    for (let index = 0; index < rows.length; index++) {
+        if (rows[index].kind !== 'remove')
+            continue;
+        const removeStart = index;
+        let removeEnd = index;
+        while (removeEnd + 1 < rows.length && rows[removeEnd + 1].kind === 'remove')
+            removeEnd++;
+        let addEnd = removeEnd;
+        while (addEnd + 1 < rows.length && rows[addEnd + 1].kind === 'add')
+            addEnd++;
+        const removeCount = removeEnd - removeStart + 1;
+        const addCount = addEnd - removeEnd;
+        if (addCount === removeCount) {
+            for (let pairIndex = 0; pairIndex < removeCount; pairIndex++) {
+                const removeRow = rows[removeStart + pairIndex];
+                const addRow = rows[removeEnd + 1 + pairIndex];
+                if (removeRow.text.length <= maxIntralineChars && addRow.text.length <= maxIntralineChars) {
+                    const [removeSegments, addSegments] = intralineSegments(removeRow.text, addRow.text);
+                    removeRow.segments = removeSegments;
+                    addRow.segments = addSegments;
+                }
+            }
+        }
+        index = addEnd;
+    }
+    return rows;
+};
+const tokenizeForIntraline = (text) => {
+    return text.match(/(\s+|[A-Za-z0-9_]+|[^\sA-Za-z0-9_]+)/g) ?? [];
+};
+const intralineSegments = (beforeText, afterText) => {
+    const beforeTokens = tokenizeForIntraline(beforeText);
+    const afterTokens = tokenizeForIntraline(afterText);
+    let prefixLength = 0;
+    while (prefixLength < beforeTokens.length
+        && prefixLength < afterTokens.length
+        && beforeTokens[prefixLength] === afterTokens[prefixLength]) {
+        prefixLength++;
+    }
+    let suffixLength = 0;
+    while (suffixLength < beforeTokens.length - prefixLength
+        && suffixLength < afterTokens.length - prefixLength
+        && beforeTokens[beforeTokens.length - 1 - suffixLength] === afterTokens[afterTokens.length - 1 - suffixLength]) {
+        suffixLength++;
+    }
+    const buildSegments = (tokens) => {
+        const prefix = tokens.slice(0, prefixLength).join('');
+        const middle = tokens.slice(prefixLength, tokens.length - suffixLength).join('');
+        const suffix = tokens.slice(tokens.length - suffixLength).join('');
+        const segments = [];
+        if (prefix)
+            segments.push({ text: prefix, changed: false });
+        if (middle)
+            segments.push({ text: middle, changed: true });
+        if (suffix)
+            segments.push({ text: suffix, changed: false });
+        return segments.length ? segments : [{ text: tokens.join(''), changed: false }];
+    };
+    return [buildSegments(beforeTokens), buildSegments(afterTokens)];
+};
+/**
+ * Folds long unchanged context runs so large files read as a review diff:
+ * keeps `contextLines` around changes, folds runs longer than
+ * `contextLines * 2 + minFoldSize`.
+ */
+export const foldContextRows = (rows, options = {}) => {
+    const contextLines = options.contextLines ?? 3;
+    const minFoldSize = options.minFoldSize ?? 4;
+    const displayRows = [];
+    let contextRun = [];
+    let seenChange = false;
+    const flushRun = (isEnd) => {
+        if (!contextRun.length)
+            return;
+        const keepHead = seenChange ? contextLines : 0;
+        const keepTail = isEnd ? 0 : contextLines;
+        if (contextRun.length > keepHead + keepTail + minFoldSize) {
+            displayRows.push(...contextRun.slice(0, keepHead));
+            displayRows.push({ kind: 'fold', rows: contextRun.slice(keepHead, contextRun.length - keepTail) });
+            if (keepTail)
+                displayRows.push(...contextRun.slice(contextRun.length - keepTail));
+        }
+        else {
+            displayRows.push(...contextRun);
+        }
+        contextRun = [];
+    };
+    for (const row of rows) {
+        if (row.kind === 'context') {
+            contextRun.push(row);
+        }
+        else {
+            flushRun(false);
+            seenChange = true;
+            displayRows.push(row);
+        }
+    }
+    flushRun(true);
+    return displayRows;
+};
+/** Pairs rows into side-by-side cells; balanced remove/add runs align 1:1. */
+export const buildSplitRows = (rows) => {
+    const splitRows = [];
+    let index = 0;
+    while (index < rows.length) {
+        const row = rows[index];
+        if (row.kind === 'hunk') {
+            splitRows.push({ kind: 'hunk', text: row.text });
+            index++;
+            continue;
+        }
+        if (row.kind === 'context') {
+            splitRows.push({
+                kind: 'pair',
+                left: { kind: 'context', text: row.text, line: row.oldLine ?? 0 },
+                right: { kind: 'context', text: row.text, line: row.newLine ?? 0 },
+            });
+            index++;
+            continue;
+        }
+        // change block: collect consecutive removes then adds, pair them up
+        const removes = [];
+        const adds = [];
+        while (index < rows.length && rows[index].kind === 'remove')
+            removes.push(rows[index++]);
+        while (index < rows.length && rows[index].kind === 'add')
+            adds.push(rows[index++]);
+        const pairCount = Math.max(removes.length, adds.length);
+        for (let pairIndex = 0; pairIndex < pairCount; pairIndex++) {
+            const removeRow = removes[pairIndex];
+            const addRow = adds[pairIndex];
+            splitRows.push({
+                kind: 'pair',
+                left: removeRow
+                    ? { kind: 'remove', text: removeRow.text, line: removeRow.oldLine ?? 0, segments: removeRow.segments }
+                    : undefined,
+                right: addRow
+                    ? { kind: 'add', text: addRow.text, line: addRow.newLine ?? 0, segments: addRow.segments }
+                    : undefined,
+            });
+        }
+    }
+    return splitRows;
+};
+export const diffStats = (rows) => {
+    let added = 0;
+    let removed = 0;
+    for (const row of rows) {
+        if (row.kind === 'add')
+            added++;
+        else if (row.kind === 'remove')
+            removed++;
+    }
+    return { added, removed };
+};
+/** Serializes rows back into a unified diff (for copy-to-clipboard). */
+export const toUnifiedDiff = (rows, options = {}) => {
+    const contextLines = options.contextLines ?? 3;
+    const lines = [];
+    if (options.fileNameBefore || options.fileNameAfter) {
+        lines.push(`--- ${options.fileNameBefore ?? 'a'}`);
+        lines.push(`+++ ${options.fileNameAfter ?? 'b'}`);
+    }
+    const hunks = [];
+    let currentHunk;
+    rows.forEach((row, index) => {
+        if (row.kind === 'add' || row.kind === 'remove') {
+            const startIndex = Math.max(0, index - contextLines);
+            if (currentHunk && startIndex <= currentHunk.endIndex + 1) {
+                currentHunk.endIndex = Math.min(rows.length - 1, index + contextLines);
+            }
+            else {
+                currentHunk = { startIndex, endIndex: Math.min(rows.length - 1, index + contextLines) };
+                hunks.push(currentHunk);
+            }
+        }
+    });
+    for (const hunk of hunks) {
+        const hunkRows = rows
+            .slice(hunk.startIndex, hunk.endIndex + 1)
+            .filter((row) => row.kind !== 'hunk');
+        const firstOld = hunkRows.find((row) => row.oldLine !== undefined)?.oldLine ?? 0;
+        const firstNew = hunkRows.find((row) => row.newLine !== undefined)?.newLine ?? 0;
+        const oldCount = hunkRows.filter((row) => row.kind === 'context' || row.kind === 'remove').length;
+        const newCount = hunkRows.filter((row) => row.kind === 'context' || row.kind === 'add').length;
+        lines.push(`@@ -${firstOld},${oldCount} +${firstNew},${newCount} @@`);
+        for (const row of hunkRows) {
+            lines.push(`${row.kind === 'add' ? '+' : row.kind === 'remove' ? '-' : ' '}${row.text}`);
+        }
+    }
+    return lines.join('\n');
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codebox.diff.js","sourceRoot":"","sources":["../../../../ts_web/elements/00group-dataview/dees-dataview-codebox/codebox.diff.ts"],"names":[],"mappings":"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"}

package/dist_ts_web/elements/00group-dataview/dees-dataview-codebox/dees-dataview-codebox.d.ts

@@ -1,5 +1,6 @@
 import { DeesElement, type TemplateResult } from '@design.estate/dees-element';
 import '../../00group-layout/dees-tile/dees-tile.js';
+import '../../00group-utility/dees-icon/dees-icon.js';
 declare global {
     interface HTMLElementTagNameMap {
         'dees-dataview-codebox': DeesDataviewCodebox;
@@ -9,11 +10,55 @@ export declare class DeesDataviewCodebox extends DeesElement {
     static demo: () => TemplateResult<1>;
     static demoGroups: string[];
     accessor progLang: string;
+    /** Shown centered in the title bar; empty hides the title. */
+    accessor filename: string;
     accessor codeToDisplay: string;
+    /**
+     * Diff mode inputs: set `codeBefore` (compared against `codeToDisplay` as
+     * the after state) OR a pre-computed `unifiedDiff` patch. Either activates
+     * diff rendering; `diffView` picks the layout and can force diff mode on
+     * its own (e.g. new-file diffs where `codeBefore` is empty).
+     */
+    accessor codeBefore: string;
+    accessor unifiedDiff: string;
+    /** '' = regular code view; 'inline' = unified rows; 'split' = side by side */
+    accessor diffView: '' | 'inline' | 'split';
+    accessor highlightedCode: string;
+    accessor copied: boolean;
+    accessor expandedFolds: ReadonlySet<number>;
+    accessor highlightVersion: number;
     static styles: import("@design.estate/dees-element").CSSResult[];
-    constructor();
     render(): TemplateResult;
-    private codeToDisplayStore;
+    private renderCode;
+    private renderCodeFooter;
+    private renderDiffFooter;
+    private renderDiff;
+    private renderInlineGrid;
+    private renderSplitGrid;
+    private renderSplitCell;
+    private renderFoldRow;
+    private renderDiffLine;
+    private processedCode;
     private highlightJs;
-    updated(_changedProperties: Map<string, any>): Promise<void>;
+    private highlightToken;
+    private copiedResetTimeout;
+    private diffRows;
+    private diffHighlightCache;
+    /** Diff mode is active when a diff input or an explicit diffView is set. */
+    get isDiffActive(): boolean;
+    get effectiveDiffView(): 'inline' | 'split';
+    willUpdate(changedProperties: Map<string, any>): void;
+    private displayRowsWithFolds;
+    updated(changedProperties: Map<string, any>): Promise<void>;
+    /**
+     * Highlights visible diff lines per-line (full-text highlighting cannot be
+     * split across rows because hljs spans may cross line boundaries). Results
+     * are cached by line text; intraline-segmented rows skip highlighting —
+     * their change tint carries the information.
+     */
+    private highlightDiffLines;
+    private highlightCode;
+    private copyCode;
+    private copyUnifiedDiff;
+    disconnectedCallback(): Promise<void>;
 }

package/dist_ts_web/elements/00group-dataview/dees-dataview-codebox/dees-dataview-codebox.demo.js

@@ -1,4 +1,79 @@
 import { html, cssManager } from '@design.estate/dees-element';
+// Passed via property binding: slotted text cannot carry generics like
+// Promise<User[]> — the HTML parser reads the angle brackets as a tag and
+// truncates the text node.
+const typescriptSample = `interface User {
+  id: number;
+  name: string;
+  email: string;
+  isActive: boolean;
+}
+
+class UserService {
+  private users: User[] = [];
+
+  constructor(private apiUrl: string) {
+    console.log('UserService initialized');
+  }
+
+  async getUsers(): Promise<User[]> {
+    try {
+      const response = await fetch(this.apiUrl);
+      const data = await response.json();
+      return data.users;
+    } catch (error) {
+      console.error('Failed to fetch users:', error);
+      return [];
+    }
+  }
+
+  addUser(user: User): void {
+    this.users.push(user);
+  }
+}
+
+// Usage example
+const service = new UserService('https://api.example.com/users');
+const users = await service.getUsers();
+console.log('Found users:', users.length);`;
+const diffBefore = `export const greet = (name: string) => {
+  const greeting = 'Hello ' + name;
+  console.log(greeting);
+  return greeting;
+};
+
+export const farewell = (name: string) => {
+  return 'Goodbye ' + name;
+};
+
+const unusedHelper = () => {
+  return 42;
+};`;
+const diffAfter = `export const greet = (name: string, excited = false) => {
+  const greeting = \`Hello \${name}\${excited ? '!' : ''}\`;
+  console.log(greeting);
+  return greeting;
+};
+
+export const farewell = (name: string) => {
+  return 'Goodbye ' + name;
+};
+
+export const wave = () => {
+  return '👋';
+};`;
+const longBefore = Array.from({ length: 60 }, (_, i) => `line ${i + 1}: stable content`).join('\n');
+const longAfter = longBefore.replace('line 30: stable content', 'line 30: CHANGED content');
+const unifiedPatchSample = `--- a/src/config.ts
++++ b/src/config.ts
+@@ -1,6 +1,7 @@
+ export const config = {
+-  retries: 3,
++  retries: 5,
++  timeoutMs: 30_000,
+   verbose: false,
+ };
+`;
 export const demoFunc = () => html `
   <style>
     .demoWrapper {
@@ -36,42 +111,11 @@ export const demoFunc = () => html `
     <div class="section">
       <div class="section-title">TypeScript Code Example</div>
       <div class="section-description">A comprehensive TypeScript code example with various syntax highlighting.</div>
-      <dees-dataview-codebox proglang="typescript">
-interface User {
-  id: number;
-  name: string;
-  email: string;
-  isActive: boolean;
-}
-
-class UserService {
-  private users: User[] = [];
-  
-  constructor(private apiUrl: string) {
-    console.log('UserService initialized');
-  }
-  
-  async getUsers(): Promise<User[]> {
-    try {
-      const response = await fetch(this.apiUrl);
-      const data = await response.json();
-      return data.users;
-    } catch (error) {
-      console.error('Failed to fetch users:', error);
-      return [];
-    }
-  }
-  
-  addUser(user: User): void {
-    this.users.push(user);
-  }
-}
-
-// Usage example
-const service = new UserService('https://api.example.com/users');
-const users = await service.getUsers();
-console.log('Found users:', users.length);
-      </dees-dataview-codebox>
+      <dees-dataview-codebox
+        proglang="typescript"
+        filename="user.service.ts"
+        .codeToDisplay=${typescriptSample}
+      ></dees-dataview-codebox>
     </div>
     
     <div class="section">
@@ -95,7 +139,7 @@ const fetchData = async (url) => {
 
 // Modern syntax
 const greet = (name = 'World') => \`Hello, \${name}!\`;
-console.log(greet('ShadCN'));
+console.log(greet('design.estate'));
       </dees-dataview-codebox>
     </div>
     
@@ -175,7 +219,7 @@ data = await processor.process_data([{'id': 1}, {'id': 2}])
     <div class="section">
       <div class="section-title">JSON Example</div>
       <div class="section-description">JSON configuration with proper formatting.</div>
-      <dees-dataview-codebox proglang="json">
+      <dees-dataview-codebox proglang="json" filename="package.json">
 {
   "name": "@design.estate/dees-catalog",
   "version": "1.10.7",
@@ -194,6 +238,51 @@ data = await processor.process_data([{'id': 1}, {'id': 2}])
 }
       </dees-dataview-codebox>
     </div>
+    <div class="section">
+      <div class="section-title">Inline Diff</div>
+      <div class="section-description">Line diff computed from before/after code with intraline change tint and context folding.</div>
+      <dees-dataview-codebox
+        proglang="typescript"
+        filename="greeter.ts"
+        diffView="inline"
+        .codeBefore=${diffBefore}
+        .codeToDisplay=${diffAfter}
+      ></dees-dataview-codebox>
+    </div>
+
+    <div class="section">
+      <div class="section-title">Side-by-Side Diff</div>
+      <div class="section-description">The same change rendered split: before on the left, after on the right, filler rows keep hunks aligned.</div>
+      <dees-dataview-codebox
+        proglang="typescript"
+        filename="greeter.ts"
+        diffView="split"
+        .codeBefore=${diffBefore}
+        .codeToDisplay=${diffAfter}
+      ></dees-dataview-codebox>
+    </div>
+
+    <div class="section">
+      <div class="section-title">Diff With Folded Context</div>
+      <div class="section-description">Unchanged runs collapse to expandable folds so long files read like a review diff.</div>
+      <dees-dataview-codebox
+        proglang="plaintext"
+        filename="big-file.txt"
+        diffView="inline"
+        .codeBefore=${longBefore}
+        .codeToDisplay=${longAfter}
+      ></dees-dataview-codebox>
+    </div>
+
+    <div class="section">
+      <div class="section-title">Unified Patch Input</div>
+      <div class="section-description">Pre-computed unified diffs render directly, hunk headers included.</div>
+      <dees-dataview-codebox
+        proglang="typescript"
+        filename="config.ts"
+        .unifiedDiff=${unifiedPatchSample}
+      ></dees-dataview-codebox>
+    </div>
   </div>
 `;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVlcy1kYXRhdmlldy1jb2RlYm94LmRlbW8uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90c193ZWIvZWxlbWVudHMvMDBncm91cC1kYXRhdmlldy9kZWVzLWRhdGF2aWV3LWNvZGVib3gvZGVlcy1kYXRhdmlldy1jb2RlYm94LmRlbW8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUUvRCxNQUFNLENBQUMsTUFBTSxRQUFRLEdBQUcsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFBOzs7Ozs7OztvQkFRZCxVQUFVLENBQUMsT0FBTyxDQUFDLFNBQVMsRUFBRSxTQUFTLENBQUM7Ozs7Ozs7Ozs7Ozs7Ozs7ZUFnQjdDLFVBQVUsQ0FBQyxPQUFPLENBQUMsU0FBUyxFQUFFLFNBQVMsQ0FBQzs7Ozs7ZUFLeEMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxTQUFTLEVBQUUsU0FBUyxDQUFDOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztDQXVLdEQsQ0FBQSJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVlcy1kYXRhdmlldy1jb2RlYm94LmRlbW8uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90c193ZWIvZWxlbWVudHMvMDBncm91cC1kYXRhdmlldy9kZWVzLWRhdGF2aWV3LWNvZGVib3gvZGVlcy1kYXRhdmlldy1jb2RlYm94LmRlbW8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUUvRCx1RUFBdUU7QUFDdkUsMEVBQTBFO0FBQzFFLDJCQUEyQjtBQUMzQixNQUFNLGdCQUFnQixHQUFHOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7MkNBaUNrQixDQUFDO0FBRTVDLE1BQU0sVUFBVSxHQUFHOzs7Ozs7Ozs7Ozs7R0FZaEIsQ0FBQztBQUVKLE1BQU0sU0FBUyxHQUFHOzs7Ozs7Ozs7Ozs7R0FZZixDQUFDO0FBRUosTUFBTSxVQUFVLEdBQUcsS0FBSyxDQUFDLElBQUksQ0FBQyxFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsa0JBQWtCLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7QUFDcEcsTUFBTSxTQUFTLEdBQUcsVUFBVSxDQUFDLE9BQU8sQ0FBQyx5QkFBeUIsRUFBRSwwQkFBMEIsQ0FBQyxDQUFDO0FBRTVGLE1BQU0sa0JBQWtCLEdBQUc7Ozs7Ozs7OztDQVMxQixDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sUUFBUSxHQUFHLEdBQUcsRUFBRSxDQUFDLElBQUksQ0FBQTs7Ozs7Ozs7b0JBUWQsVUFBVSxDQUFDLE9BQU8sQ0FBQyxTQUFTLEVBQUUsU0FBUyxDQUFDOzs7Ozs7Ozs7Ozs7Ozs7O2VBZ0I3QyxVQUFVLENBQUMsT0FBTyxDQUFDLFNBQVMsRUFBRSxTQUFTLENBQUM7Ozs7O2VBS3hDLFVBQVUsQ0FBQyxPQUFPLENBQUMsU0FBUyxFQUFFLFNBQVMsQ0FBQzs7Ozs7Ozs7Ozs7eUJBVzlCLGdCQUFnQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7c0JBbUluQixVQUFVO3lCQUNQLFNBQVM7Ozs7Ozs7Ozs7O3NCQVdaLFVBQVU7eUJBQ1AsU0FBUzs7Ozs7Ozs7Ozs7c0JBV1osVUFBVTt5QkFDUCxTQUFTOzs7Ozs7Ozs7O3VCQVVYLGtCQUFrQjs7OztDQUl4QyxDQUFBIn0=