noteconnection 0.9.0

package/dist/backend/test_robustness/test_statistics.js

@@ -0,0 +1,58 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const FileLoader_1 = require("../FileLoader");
+const StatisticalAnalyzer_1 = require("../algorithms/StatisticalAnalyzer");
+async function run() {
+    const root = path.resolve(__dirname, '../../../testconcept');
+    console.log(`Loading files from: ${root}`);
+    const files = await FileLoader_1.FileLoader.loadFiles(root);
+    console.log(`Loaded ${files.length} files.`);
+    const terms = files.map(f => f.filename);
+    console.log(`Analyzing ${terms.length} terms...`);
+    const matrix = StatisticalAnalyzer_1.StatisticalAnalyzer.analyze(files, terms);
+    // Low thresholds for demonstration on small dataset
+    const minSupport = 0.05;
+    const asymmetry = 0.1;
+    console.log(`Inferring dependencies (Min Support: ${minSupport}, Asymmetry: ${asymmetry})...`);
+    const deps = StatisticalAnalyzer_1.StatisticalAnalyzer.inferDependencies(matrix, minSupport, asymmetry);
+    console.log(`Inferred ${deps.length} dependencies.`);
+    console.log('Top 20 Suggestions:');
+    deps.slice(0, 20).forEach(d => {
+        console.log(`[${d.source}] -> [${d.target}] (Conf: ${d.confidence.toFixed(2)}, Jaccard: ${d.weight.toFixed(2)})`);
+    });
+}
+run().catch(e => console.error(e));

package/dist/backend/test_robustness/test_vector.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const FileLoader_1 = require("../FileLoader");
+const VectorSpace_1 = require("../algorithms/VectorSpace");
+async function run() {
+    const root = path.resolve(__dirname, '../../../testconcept');
+    console.log(`Loading files from: ${root}`);
+    const files = await FileLoader_1.FileLoader.loadFiles(root);
+    console.log(`Loaded ${files.length} files.`);
+    const vectorSpace = new VectorSpace_1.VectorSpace(files);
+    console.log('Vector Space built.');
+    // Test a specific file
+    const testFile = files[0].filename; // e.g. "Absorption"
+    console.log(`Finding similarities for: [${testFile}]`);
+    const similar = vectorSpace.getSimilar(testFile, 5);
+    similar.forEach(res => {
+        console.log(` -> [${res.id}] Score: ${res.score.toFixed(4)}`);
+    });
+}
+run().catch(e => console.error(e));

package/dist/backend/test_robustness.js

@@ -0,0 +1,113 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+// src/backend/test_robustness.ts
+const path = __importStar(require("path"));
+const parser_1 = require("./parser");
+const graph_1 = require("./graph");
+async function test() {
+    const inputDir = path.resolve(__dirname, '../../test_robustness');
+    const outputDir = path.resolve(__dirname, '../../test_robustness');
+    const outputFile = path.join(outputDir, 'test_graph_result.json');
+    console.log(`Starting Robustness Test...`);
+    // 1. Load Files
+    // 1. 加载文件
+    const rawFiles = await parser_1.FileLoader.loadFiles(inputDir);
+    console.log(`Loaded ${rawFiles.length} files.`);
+    // 2. Parse Concepts
+    // 2. 解析概念
+    const concepts = parser_1.NoteParser.parse(rawFiles);
+    // 3. Build Graph
+    // 3. 构建图
+    const graph = graph_1.GraphBuilder.buildGraph(concepts);
+    // 4. Export
+    // 4. 导出
+    await graph_1.Exporter.exportToJSON(graph, outputFile);
+    // 5. Validation Logic
+    // 5. 验证逻辑
+    console.log('--- Validation Report ---');
+    // Check Node Count
+    // 检查节点数量
+    if (graph.nodes.length === 6) {
+        console.log('[PASS] Node Count is 6');
+    }
+    else {
+        console.error(`[FAIL] Node Count is ${graph.nodes.length}, expected 6`);
+    }
+    // Check Cycle A->B->C->A
+    // 检查循环 A->B->C->A
+    // Logic: Concept A mentions B -> Edge B->A (B is prerequisite for A)
+    // 逻辑：概念 A 提到 B -> 边 B->A (B 是 A 的先决条件)
+    // Concept B mentions C -> Edge C->B
+    // Concept C mentions A -> Edge A->C
+    // Cycle: A->C->B->A
+    const hasEdge = (src, tgt) => graph.edges.some(e => e.source === src && e.target === tgt);
+    if (hasEdge('Concept B', 'Concept A'))
+        console.log('[PASS] Edge B->A exists');
+    else
+        console.error('[FAIL] Edge B->A missing');
+    if (hasEdge('Concept C', 'Concept B'))
+        console.log('[PASS] Edge C->B exists');
+    else
+        console.error('[FAIL] Edge C->B missing');
+    if (hasEdge('Concept A', 'Concept C'))
+        console.log('[PASS] Edge A->C exists');
+    else
+        console.error('[FAIL] Edge A->C missing');
+    // Check Special Char
+    // 检查特殊字符
+    // Special mentions A -> A->Special
+    if (hasEdge('Concept A', 'Special (Char) Concept'))
+        console.log('[PASS] Edge A->Special exists');
+    else
+        console.error('[FAIL] Edge A->Special missing');
+    // Check Case Insensitivity
+    // 检查不区分大小写
+    // D mentions "concept a" -> A->D
+    if (hasEdge('Concept A', 'Concept D'))
+        console.log('[PASS] Edge A->D (Case Insensitive) exists');
+    else
+        console.error('[FAIL] Edge A->D missing');
+    // Check Empty Concept
+    // 检查空概念
+    // Should be a node, but no edges connected to/from it (unless its name is common)
+    // 应该是一个节点，但没有边连接到它/从它连接（除非它的名字很普通）
+    const emptyNode = graph.nodes.find(n => n.id === 'Empty Concept');
+    if (emptyNode)
+        console.log('[PASS] Empty Concept node exists');
+    else
+        console.error('[FAIL] Empty Concept node missing');
+}
+test().catch(err => console.error(err));

package/dist/backend/types.js

@@ -0,0 +1,3 @@
+"use strict";
+// src/backend/types.ts
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/backend/utils/frontmatterParser.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrontmatterParser = void 0;
+class FrontmatterParser {
+    /**
+     * Parses YAML frontmatter to extract structured metadata.
+     * 解析 YAML frontmatter 以提取结构化元数据。
+     */
+    static parse(content) {
+        const metadata = {
+            tags: [],
+            prerequisites: [],
+            next: []
+        };
+        const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+        if (!match)
+            return metadata;
+        const yaml = match[1];
+        // Helper to extract list or inline array
+        const extractField = (fieldName) => {
+            const results = [];
+            // 1. Check for List format (starts with newline or empty value)
+            // field:
+            //   - item
+            const listBlockRegex = new RegExp(`${fieldName}:\\s*\\r?\\n((?:\\s*-\\s*.*\\r?\\n?)*)`, 'i');
+            const listMatch = yaml.match(listBlockRegex);
+            if (listMatch) {
+                const lines = listMatch[1].split(/\r?\n/);
+                lines.forEach(line => {
+                    const itemMatch = line.match(/\s*-\s*(.*)/);
+                    if (itemMatch) {
+                        const clean = this.cleanLink(itemMatch[1]);
+                        if (clean)
+                            results.push(clean);
+                    }
+                });
+                // If we found a list, return it. Prioritize list over inline if both exist (rare but possible in bad yaml)
+                if (results.length > 0)
+                    return results;
+            }
+            // 2. Check for Inline value (Array or Single)
+            const inlineRegex = new RegExp(`${fieldName}:\\s*(.*)`, 'i');
+            const inlineMatch = yaml.match(inlineRegex);
+            if (inlineMatch) {
+                let val = inlineMatch[1].trim();
+                if (!val)
+                    return results; // handled by list or empty
+                // Check if it's a comment or invalid
+                if (val.startsWith('#'))
+                    return results;
+                // Case A: WikiLink "[[Link]]" -> Single Item
+                if (val.startsWith('[[')) {
+                    const clean = this.cleanLink(val);
+                    if (clean)
+                        results.push(clean);
+                    return results;
+                }
+                // Case B: Inline Array "[a, b]"
+                if (val.startsWith('[')) {
+                    // Remove outer [ ]
+                    const inner = val.replace(/^\[|\]$/g, '');
+                    inner.split(',').forEach(item => {
+                        const clean = this.cleanLink(item);
+                        if (clean)
+                            results.push(clean);
+                    });
+                    return results;
+                }
+                // Case C: Plain Single Value "Item"
+                // Ensure it's not a list start (dash)
+                if (!val.startsWith('-')) {
+                    const clean = this.cleanLink(val);
+                    if (clean)
+                        results.push(clean);
+                }
+            }
+            return results;
+        };
+        metadata.tags = extractField('tags');
+        metadata.prerequisites = extractField('prerequisites');
+        metadata.next = extractField('next');
+        return metadata;
+    }
+    /**
+     * Cleans a string from WikiLink brackets [[ ]] and whitespace.
+     * 清除 WikiLink 括号 [[ ]] 和空格。
+     */
+    static cleanLink(raw) {
+        let text = raw.trim();
+        // Remove [[ ]]
+        const linkMatch = text.match(/^\[\[(.*?)(?:\|.*?)?\]\]$/);
+        if (linkMatch) {
+            return linkMatch[1].trim();
+        }
+        // Remove quotes if present
+        text = text.replace(/^["']|["']$/g, '');
+        return text;
+    }
+    /**
+     * Extracts tags from YAML frontmatter and WikiLinks [[tag]].
+     * 从 YAML frontmatter 和 WikiLinks [[tag]] 中提取标签。
+     * @deprecated Use parse() for metadata. This method mixes concepts.
+     */
+    static extractTags(content) {
+        const tags = new Set();
+        // Use new parser for YAML tags
+        const parsed = this.parse(content);
+        parsed.tags.forEach(t => tags.add(t));
+        // 2. Scan for [[WikiLinks]] in the entire content
+        // Regex to capture [[Tag]] or [[Tag|Label]]
+        const wikiLinkRegex = /\[\[(.*?)(?:\|.*?)?\]\]/g;
+        let wikiMatch;
+        while ((wikiMatch = wikiLinkRegex.exec(content)) !== null) {
+            if (wikiMatch[1]) {
+                tags.add(wikiMatch[1].trim());
+            }
+        }
+        return Array.from(tags);
+    }
+}
+exports.FrontmatterParser = FrontmatterParser;

package/dist/backend/utils/stringUtils.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.levenshtein = levenshtein;
+exports.isSimilar = isSimilar;
+exports.checkMatch = checkMatch;
+/**
+ * Calculates the Levenshtein distance between two strings.
+ * 计算两个字符串之间的 Levenshtein 距离。
+ */
+function levenshtein(a, b) {
+    const matrix = [];
+    // Increment along the first column of each row
+    for (let i = 0; i <= b.length; i++) {
+        matrix[i] = [i];
+    }
+    // Increment each column in the first row
+    for (let j = 0; j <= a.length; j++) {
+        matrix[0][j] = j;
+    }
+    // Fill in the rest of the matrix
+    for (let i = 1; i <= b.length; i++) {
+        for (let j = 1; j <= a.length; j++) {
+            if (b.charAt(i - 1) == a.charAt(j - 1)) {
+                matrix[i][j] = matrix[i - 1][j - 1];
+            }
+            else {
+                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, // substitution
+                Math.min(matrix[i][j - 1] + 1, // insertion
+                matrix[i - 1][j] + 1 // deletion
+                ));
+            }
+        }
+    }
+    return matrix[b.length][a.length];
+}
+/**
+ * Checks if two strings are similar based on a threshold.
+ * 基于阈值检查两个字符串是否相似。
+ * @param a String A
+ * @param b String B
+ * @param threshold Max distance allowed (default 2)
+ */
+function isSimilar(a, b, threshold = 2) {
+    if (Math.abs(a.length - b.length) > threshold)
+        return false;
+    return levenshtein(a.toLowerCase(), b.toLowerCase()) <= threshold;
+}
+/**
+ * Checks if the content contains the term based on the provided strategy.
+ * 根据提供的策略检查内容是否包含术语。
+ * @param content The text content to search within
+ * @param term The term to search for
+ * @param strategy 'exact-phrase' or 'fuzzy'
+ */
+function checkMatch(content, term, strategy = 'exact-phrase') {
+    if (strategy === 'exact-phrase') {
+        const escapedTerm = term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const regex = new RegExp(`\\b${escapedTerm}\\b`, 'i');
+        return regex.test(content);
+    }
+    else if (strategy === 'fuzzy') {
+        // Simple inclusion as per original logic
+        return content.toLowerCase().includes(term.toLowerCase());
+    }
+    return false;
+}

package/dist/backend/workers/keywordMatchWorker.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_threads_1 = require("worker_threads");
+const stringUtils_1 = require("../utils/stringUtils");
+const { filesChunk, targetIds, strategy, exclusionList } = worker_threads_1.workerData;
+const results = [];
+filesChunk.forEach(sourceFile => {
+    const sourceId = sourceFile.filename;
+    const content = sourceFile.content;
+    targetIds.forEach(targetId => {
+        if (sourceId === targetId)
+            return;
+        if (exclusionList.includes(targetId))
+            return;
+        if ((0, stringUtils_1.checkMatch)(content, targetId, strategy)) {
+            results.push({ source: sourceId, target: targetId });
+        }
+    });
+});
+if (worker_threads_1.parentPort) {
+    worker_threads_1.parentPort.postMessage(results);
+}

package/dist/core/Graph.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Graph = void 0;
+/**
+ * Directed Graph implementation for managing notes and dependencies.
+ * 用于管理笔记和依赖关系的有向图实现。
+ */
+class Graph {
+    constructor() {
+        this.nodes = new Map();
+        this.adjacencyList = new Map();
+        this.reverseAdjacencyList = new Map();
+    }
+    /**
+     * Adds a node to the graph.
+     * 向图中添加一个节点。
+     * @param node The node to add | 要添加的节点
+     */
+    addNode(node) {
+        if (!this.nodes.has(node.id)) {
+            this.nodes.set(node.id, { ...node, inDegree: 0, outDegree: 0 });
+            this.adjacencyList.set(node.id, []);
+            this.reverseAdjacencyList.set(node.id, []);
+        }
+    }
+    /**
+     * Retrieves a node by its ID.
+     * 通过 ID 获取节点。
+     * @param id The node ID | 节点 ID
+     * @returns The node or undefined if not found | 节点，如果未找到则返回 undefined
+     */
+    getNode(id) {
+        return this.nodes.get(id);
+    }
+    /**
+     * Checks if a node exists in the graph.
+     * 检查图中是否存在该节点。
+     * @param id The node ID | 节点 ID
+     */
+    hasNode(id) {
+        return this.nodes.has(id);
+    }
+    /**
+     * Adds a directed edge between two nodes.
+     * 在两个节点之间添加有向边。
+     * @param source Source node ID | 源节点 ID
+     * @param target Target node ID | 目标节点 ID
+     * @param type Relationship type | 关系类型
+     * @param weight Edge weight (confidence) | 边权重 (置信度)
+     */
+    addEdge(source, target, type = 'dependency', weight = 1) {
+        if (!this.nodes.has(source)) {
+            this.addNode({ id: source, label: source, inDegree: 0, outDegree: 0 });
+        }
+        if (!this.nodes.has(target)) {
+            this.addNode({ id: target, label: target, inDegree: 0, outDegree: 0 });
+        }
+        const edge = { source, target, type, weight };
+        // Add to adjacency list (outgoing)
+        const outgoing = this.adjacencyList.get(source) || [];
+        // Prevent duplicate edges
+        if (!outgoing.some(e => e.target === target && e.type === type)) {
+            outgoing.push(edge);
+            this.adjacencyList.set(source, outgoing);
+            // Update out-degree
+            const sourceNode = this.nodes.get(source);
+            sourceNode.outDegree++;
+        }
+        // Add to reverse adjacency list (incoming)
+        const incoming = this.reverseAdjacencyList.get(target) || [];
+        if (!incoming.some(e => e.source === source && e.type === type)) {
+            incoming.push(edge);
+            this.reverseAdjacencyList.set(target, incoming);
+            // Update in-degree
+            const targetNode = this.nodes.get(target);
+            targetNode.inDegree++;
+        }
+    }
+    /**
+     * Gets all outgoing edges from a node.
+     * 获取节点的所有出边。
+     * @param id Node ID | 节点 ID
+     */
+    getOutgoingEdges(id) {
+        return this.adjacencyList.get(id) || [];
+    }
+    /**
+     * Gets all outgoing neighbor IDs for a node.
+     * 获取节点的所有出度邻居 ID。
+     * @param id Node ID | 节点 ID
+     */
+    getNeighbors(id) {
+        return (this.adjacencyList.get(id) || []).map(edge => edge.target);
+    }
+    /**
+     * Gets all nodes in the graph.
+     * 获取图中的所有节点。
+     */
+    getNodes() {
+        return Array.from(this.nodes.values());
+    }
+    /**
+     * Gets all incoming edges to a node.
+     * 获取节点的所有入边。
+     * @param id Node ID | 节点 ID
+     */
+    getIncomingEdges(id) {
+        return this.reverseAdjacencyList.get(id) || [];
+    }
+    /**
+     * Returns the graph data in a serializable format.
+     * 以可序列化的格式返回图数据。
+     */
+    toJSON() {
+        return {
+            nodes: Array.from(this.nodes.values()),
+            edges: Array.from(this.adjacencyList.values()).flat()
+        };
+    }
+}
+exports.Graph = Graph;

package/dist/core/Graph.test.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Graph_1 = require("./Graph");
+describe('Graph Core', () => {
+    let graph;
+    beforeEach(() => {
+        graph = new Graph_1.Graph();
+    });
+    test('should add a node correctly', () => {
+        const node = { id: 'A', label: 'Note A', inDegree: 0, outDegree: 0 };
+        graph.addNode(node);
+        expect(graph.hasNode('A')).toBe(true);
+        expect(graph.getNode('A')).toEqual(expect.objectContaining({ id: 'A' }));
+    });
+    test('should add an edge and update degrees', () => {
+        graph.addEdge('A', 'B');
+        expect(graph.hasNode('A')).toBe(true);
+        expect(graph.hasNode('B')).toBe(true);
+        const nodeA = graph.getNode('A');
+        const nodeB = graph.getNode('B');
+        expect(nodeA?.outDegree).toBe(1);
+        expect(nodeB?.inDegree).toBe(1);
+        const outgoing = graph.getOutgoingEdges('A');
+        expect(outgoing).toHaveLength(1);
+        expect(outgoing[0].target).toBe('B');
+        const incoming = graph.getIncomingEdges('B');
+        expect(incoming).toHaveLength(1);
+        expect(incoming[0].source).toBe('A');
+    });
+    test('should not add duplicate edges', () => {
+        graph.addEdge('A', 'B');
+        graph.addEdge('A', 'B'); // Duplicate
+        const nodeA = graph.getNode('A');
+        expect(nodeA?.outDegree).toBe(1);
+        expect(graph.getOutgoingEdges('A')).toHaveLength(1);
+    });
+});

package/dist/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });